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:\... | ['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 ... | ['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... | ['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//... | ['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... | ['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)... | ['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 prin... | ['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 re... | ['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(): retur... | ['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... | ['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)\nel... | ['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*mat... | ['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,... | ['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... | ['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 ... | ['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)/... | ['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 ... | ['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()", "''... | ['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... | ['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:\... | ['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 >... | ['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... | ['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(... | ['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 - ... | ['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;', '... | ['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*((... | ['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... | ['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 ma... | ['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 ... | ['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 * fl... | ['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... | ['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 inp... | ['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 ... | ['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:\... | ['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,... | ['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 - ... | ['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... | ['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_... | ['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... | ['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 ... | ['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 ... | ['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(... | ['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\na... | ['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... | ['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+... | ['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 ... | ['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... | ['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 *... | ['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)... | ['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:... | ['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... | ['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\... | ['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... | ['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.floo... | ['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 ... | ['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 \nprin... | ['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, 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... | ['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 ... | ['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)//... | ['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... | ['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... | ['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 ... | ['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.