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 |
|---|---|---|---|---|---|---|---|---|---|---|
p03317 | u111555888 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | [' N,K=map(int,input().split())\na=list(map(int,input().split()))\nindex=a.index(1)\nl=index\nr=index\ncnt=0\nif index<=(N//2-1 if N%2==0 else N//2):\n while l!=0:\n if cnt==0:\n if l-K+1<0:\n r=K-1\n l=max(0,l-K+1)\n cnt+=1\n while r!=N-1:\n r=min(N-1,r+K-1)\n cnt+=1\n print(cnt)\nelse:\n... | ['Runtime Error', 'Accepted'] | ['s540850718', 's049388067'] | [2940.0, 3060.0] | [17.0, 16.0] | [453, 99] |
p03317 | u115682115 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K = map(int,input().rstrip().split())\nA = list(map(int,input().rstrip().split()))\nsum =0\nwhile len(A)>=2:\n sum+=1\n A.insert(K,min(A[:K]))\n print(A)\n del A[0:K]\nprint(sum)', 'N,K = map(int,input().rstrip().split())\nA = list(map(int,input().rstrip().split()))\nsum =0\nwhile len(A)>=2:\n sum+=1... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s264292270', 's907780782', 's026818332'] | [141196.0, 141224.0, 3060.0] | [1646.0, 1647.0, 17.0] | [184, 184, 81] |
p03317 | u116233709 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k=map(int,input().split())\na=list(map(int,input().split()))\nli=[]\nimport collections\nA=collections.Counter(a)\nfor key in A.keys():\n li.append(key)\nx=A[li[0]] \nprint(int((n-x)//(k-1)))\n\n \n ', 'n,k=map(int,input().split())\na=list(map(int,input().split()))\nli=[]\nimport collections\nimport... | ['Wrong Answer', 'Accepted'] | ['s630300297', 's295186521'] | [18936.0, 19808.0] | [70.0, 67.0] | [206, 222] |
p03317 | u123745130 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,m=map(int,input().split())\nl=list(map(int,input().split()))\nprint(-(-((len(l)-m)//(m-1))))', 'n,m=map(int,input().split())\nl=list(map(int,input().split()))\nprint(-(-(len(l)-m)//(m-1)))\n', 'n,m=map(int,input().split())\nl=list(map(int,input().split()))\nprint(-(-int((len(l)-m)//(m-1))))\n', 'n,m=map(int,input()... | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s547499891', 's677341158', 's870861714', 's027574903'] | [13880.0, 13812.0, 13880.0, 13880.0] | [41.0, 41.0, 40.0, 39.0] | [92, 91, 96, 95] |
p03317 | u123756661 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k=map(int,input().split())\na=[int(i) for i in input().split()]\nchk=a.index(1)\nl=chk+k-2\nr=n-(chk+1)+k-2\nt1=l%(k-1)\nt2=r%(k-1)\nprint(min(l//(k-1)+r//(k-1),((l-t2)//(k-1))+(r//(k-1)), (l//(k-1))+((r-t1)//(k-1))))\n', 'n,k=map(int,input().split())\na=[int(i) for i in input().split()]\nchk=a.index(1)\nl=chk+k-2\... | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s063334385', 's401288351', 's533197760', 's775309544', 's828151513', 's919091839', 's310947082'] | [13880.0, 13880.0, 13880.0, 13880.0, 13880.0, 13880.0, 13812.0] | [44.0, 44.0, 44.0, 46.0, 44.0, 45.0, 45.0] | [213, 217, 115, 188, 210, 205, 309] |
p03317 | u131411061 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K = map(int,input().split())\nA = list(map(int,input().split()))\n\nif (N-1)%(K-1) == 0:\n print(N-1//K-1)\nelse:\n print(N-1//K-1 + 1)', 'N,K = map(int,input().split())\nA = list(map(int,input().split()))\n\nif (N-1)%(K-1) == 0:\n print((N-1)//(K-1))\nelse:\n print((N-1)//(K-1) + 1)'] | ['Wrong Answer', 'Accepted'] | ['s055101333', 's480594846'] | [13880.0, 14008.0] | [41.0, 39.0] | [137, 145] |
p03317 | u137542041 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['from math import ceil, floor\n\nN, K = map(int, input().split())\nA = list(map(int, input().split()))\n\nif N == K:\n print(1)\n exit()\n\nidx = 0\nfor i in range(N):\n if A[i] == 1:\n idx = i\n break\n\nans = N\nfor k in range(K):\n temp = 1\n l = max(idx - k, 0)\n r = min(l + K - 1, ... | ['Wrong Answer', 'Accepted'] | ['s805158266', 's343630986'] | [20316.0, 20508.0] | [97.0, 50.0] | [640, 165] |
p03317 | u138486156 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n, k = map(int, input().split())\na = list(map(int, input().split()))\n\nif n == k:\n print(1)\n exit()\n\nidx = a.index(1)\n\nif idx < (n//2):\n a = idx//(k-1)\nelse:\n a = (n-idx-1)//(k-1)\n\nm = n - k - (k-1)*a\n\nif m // (k-1):\n b = m//(k-1)+1\nelse:\n b = m//(k-1)\n\nprint(a+1+b)\n\n', 'from c... | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s101490650', 's655840158', 's113817952'] | [13880.0, 3316.0, 13812.0] | [45.0, 20.0, 40.0] | [285, 280, 121] |
p03317 | u138537142 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ["info = list(map(int, input().split(' ')))\narray = list(map(int, input().split(' ')))\n\nprint((info[0]-1)//(info[1]-1))", "info = list(map(int, input().split(' ')))\narray = list(map(int, input().split(' ')))\n\nif info[1] == info[0]:\n print(1)\nelif info[1] == 2:\n print(info[0]-1)\nelif info[0]//(info[1]-1)... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s728101376', 's744808534', 's185794221'] | [13812.0, 13880.0, 13812.0] | [39.0, 39.0, 40.0] | [117, 246, 127] |
p03317 | u140697185 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\nN,K = map(int , input().split())\nA = list(map(int , input().split()))\n\nleft_num = A.index(1)\nright_num = N-left_num-1\nprint(left_num)\nprint(right_num)\n\nans = math.ceil(left_num/(K-1))+math.ceil(right_num/(K-1))\nprint(ans)', 'import math\nN,K = map(int , input().split())\nA = list(map(int , input... | ['Wrong Answer', 'Accepted'] | ['s234221366', 's274653095'] | [13812.0, 13812.0] | [41.0, 40.0] | [233, 122] |
p03317 | u149260203 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ["import math\nN,K = [int(i) for i in input().split()]\na = list(input().split())\nm = a.index('1')\nif m == 0 or m == N-1:\n print(math.ceil((N-1)/(K-1)))\nelse:\n res = (K - m%K)%K\n print(math.ceil((m)/(K-1)) + math.ceil((N-m-1-res)/(K-1)))", "import math\nN,K = [int(i) for i in input().split()]\na = list(i... | ['Wrong Answer', 'Accepted'] | ['s551296057', 's969001168'] | [10740.0, 10740.0] | [27.0, 27.0] | [242, 254] |
p03317 | u151366507 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\n\nN, K = map(int, input().split())\nA = list(map(int, input().split() ))\nmath.ceil( (N-1)/(K-1) )', 'import math\n\nN, K = map(int, input().split())\nA = list(map(int, input().split() ))\nprint(math.ceil( (N-1)/(K-1) ))'] | ['Wrong Answer', 'Accepted'] | ['s236323438', 's879060164'] | [13812.0, 13812.0] | [45.0, 43.0] | [107, 114] |
p03317 | u159335277 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n, k = list(map(int, input().split()))\na = list(map(int, input().split()))\n\nminpos = 0\nfor i in range(0, n):\n if a[i] == 1: minpos = i\nprint((minpos + k - 2) / (k - 1) + (n - minpos - 1 + k - 2) / (k - 1))', 'n, k = list(map(int, input().split()))\na = list(map(int, input().split()))\n\nprint((n - 1 + k - 2) /... | ['Wrong Answer', 'Accepted'] | ['s294153432', 's880220232'] | [14008.0, 13880.0] | [49.0, 40.0] | [206, 110] |
p03317 | u160244242 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n, k = map(int, input().split())\nlst = list(map(int, input().split()))\na = lst.index(1)\nprint(math.ceil(a/2) + math.ceil((n-a-1)/2))', 'import math\nn, k = map(int, input().split())\nlst = list(map(int, input().split()))\na = lst.index(1)\nprint(math.ceil((n - 1) / (k-1)))'] | ['Runtime Error', 'Accepted'] | ['s908621397', 's238794386'] | [14008.0, 13812.0] | [41.0, 42.0] | [132, 133] |
p03317 | u161537170 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ["import math\n\ndef calc_manipulate_times(Klen,len):\n if len == 0:\n return 0\n elif Klen>=len:\n return 1\n else:\n return math.ceil((len - Klen)/(Klen-1)) + 1\n\nN,K = map(int,input('').split())\nA = list(input().split(' '))\n\nleft_count = A.index('1')+1\nright_count = len(A)-A.index(... | ['Wrong Answer', 'Accepted'] | ['s889052249', 's719437345'] | [10740.0, 10740.0] | [28.0, 28.0] | [628, 151] |
p03317 | u166306121 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K = map(int,input().split())\nA = list(map(int,input().split()))\n\n\n# if A[i] == 1:\n# return i\n# n = search(A)\n#\n\nprint((N-1) // (K-1))', 'N,K = map(int,input().split())\nA = list(map(int,input().split()))\n\n\n# if A[i] == 1:\n# return i\n# n = search(A)\n#\n\nprint(-... | ['Wrong Answer', 'Accepted'] | ['s830091308', 's290484207'] | [13812.0, 13880.0] | [41.0, 42.0] | [237, 241] |
p03317 | u166696759 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['8 3\n7 3 1 8 4 6 2 5', 'N, K = map(int,input().split())\nA = list(map(int, input().split()))\nif (N-1) % (K-1) == 0:\n\tprint((N-1)//(K-1))\nelse:\n \tprint((N-1)//(K-1)+1)'] | ['Runtime Error', 'Accepted'] | ['s582129553', 's790005143'] | [2940.0, 14008.0] | [17.0, 40.0] | [19, 142] |
p03317 | u167647458 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ["import math\n\n\ndef main():\n n, k = map(int, input().split())\n a = list(map(int, input().split()))\n print(math.ceil((n -1) // (k - 1)))\n\n \nif __name__ == '__main__':\n main()", "import math\n\n\ndef main():\n n, k = map(int, input().split())\n a = list(map(int, input().split()))\n print... | ['Wrong Answer', 'Accepted'] | ['s014141334', 's562537443'] | [13812.0, 13812.0] | [40.0, 40.0] | [186, 185] |
p03317 | u171328579 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K = map(int,input().split())\nA = list(map(int,input().split()))\n\nN -= 1\nK -= 1\nprint(N // K)\n', 'import math\n\nN,K = map(int,input().split())\nA = list(map(int,input().split()))\n\nN -= K\nK -= 1\nC = math.ceil(N/K)\n\nprint(C+1)\n'] | ['Wrong Answer', 'Accepted'] | ['s548836626', 's717118235'] | [20468.0, 20456.0] | [52.0, 49.0] | [95, 125] |
p03317 | u173329233 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['from math import floor\nnk = input()\nn, k = nk.split()\nn = int(n)\nk = int(k)\n\nan = input()\nan_list = an.split()\nmin = min(an_list)\n\nmin_ind = an_list.index(min) + 1\nafter = (n - min_ind) / (k-1)\nbefore = (min_ind - 1) / (k-1)\n\nres = floor((n-1)/(k-1))\n\n\nprint(int(res))\n', 'from math import floor\nnk ... | ['Wrong Answer', 'Runtime Error', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s201360470', 's319951557', 's526360893', 's990685692', 's654372329'] | [10420.0, 3060.0, 10548.0, 10420.0, 10420.0] | [28.0, 17.0, 29.0, 29.0, 28.0] | [269, 514, 536, 311, 200] |
p03317 | u175034939 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k = map(int,input().split())\na = list(map(int,input().split()))\n\nif n == k:\n print(1)\n exit()\n\nl = 0\nr = 0\none = False\nfor i in range(n):\n if a[i] == 1:\n one = True\n continue\n if one == False:\n l += 1\n else:\n r += 1\n\nif k >= min(l+1,r+1):\n n -= k\n ... | ['Runtime Error', 'Accepted'] | ['s350779731', 's328768601'] | [14008.0, 13812.0] | [59.0, 39.0] | [589, 117] |
p03317 | u175426149 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N, K = map(int, input().split())\nA = list(map(int, input().split()))\n\nprint(N, K, len(A))\n\nindex = A.index(1)\nprint(index)\n\nbefore_num = index\nafter_num = N - index - 1\n\nope = 0\nif N == K:\n ope = 1\nelif K > before_num or K > after_num:\n div, mod = divmod(N, K - 1)\n if mod == 0:\n ope =... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s231102110', 's692612788', 's443746595'] | [13812.0, 13812.0, 13812.0] | [42.0, 41.0, 42.0] | [1232, 1211, 155] |
p03317 | u175590965 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k = list(map(int,input().split()))\na = lsit(map(int,input().split()))\nprint((n-1+k-2)//(k-1))', 'n,k = list(map(int,input().split()))\na = list(map(int,input().split()))\nprint((n-1+k-2)//(k-1))'] | ['Runtime Error', 'Accepted'] | ['s684448402', 's122474345'] | [3060.0, 14008.0] | [17.0, 40.0] | [95, 95] |
p03317 | u177040005 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K = map(int, input().split())\nA = list(map(int, input().split()))\n\ni = A.index(1)\nans1 = ans2 = ans3 = 1000010\nif N<=K:\n print(1)\n exit()\nif len(A[:i]) < K-1:\n ans1 = -(-len(A[:i])//(K-1)) + -(-(len(A[i+1:]) - (K-len(A[:i])))//(K-1))\nif len(A[i+1:]) < K-1:\n ans2 = -(-(len(A[:i]) - (K-len(A[i+... | ['Wrong Answer', 'Accepted'] | ['s658980830', 's012404967'] | [14324.0, 2940.0] | [42.0, 17.0] | [491, 63] |
p03317 | u179169725 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['\n\n\nimport sys\nread = sys.stdin.readline\nra = range\nenu = enumerate\n\n\ndef read_ints():\n return list(map(int, read().split()))\n\n\nN, K = read_ints()\nif N == K:\n print(1)\n exit()\nA = read_ints()\nK -= 1\ni = A.index(1)\n\n# if i < K and i >= (N - K):\n# print(2)\n# exit()\n\n\n\n\nright ... | ['Wrong Answer', 'Accepted'] | ['s934474070', 's705039586'] | [13304.0, 13876.0] | [42.0, 44.0] | [601, 358] |
p03317 | u194856115 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['from math import ceil\nN, K = map(int, raw_input().split())\nA = map(int, raw_input().split())\n\nprint (int(ceil((N-1)/(K-1))))\n', 'from math import ceil\nN, K = map(int, raw_input().split())\nA = map(int, raw_input().split())\n\nprint (ceil((N-1)//(K-1)))\n', 'from math import ceil\nN, K = map(int, raw_input().spl... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s125451968', 's183538251', 's411835757', 's736613656', 's812294045'] | [2940.0, 2940.0, 2940.0, 2940.0, 4724.0] | [17.0, 17.0, 17.0, 17.0, 18.0] | [125, 121, 120, 122, 89] |
p03317 | u198905553 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k = map(int,input().split())\na = list(map(int,input().split()))\nprint((n-1) // (k-1))', 'import math\nn,k = map(int,input().split())\na = list(map(int,input().split()))\nprint(math.ceil((n-1) / (k-1)))\n\n'] | ['Wrong Answer', 'Accepted'] | ['s423088198', 's293537294'] | [13880.0, 13812.0] | [39.0, 40.0] | [87, 179] |
p03317 | u208479266 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n, c = map(int, input().split())\nimport math\nprint(math.ceil((n-1)//(c-1)))\n', 'import math\nn, c = map(int, input().split())\n\na = input()\nprint(math.ceil((n-1)//(c-1)))\n', 'n, c = map(int, input().split())\nprint((n-1)//(c-1))\n', 'import math\nN,K = map(int,input().split())\nprint(math.ceil((N-1)/(K-1)))'] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s186323749', 's657435822', 's697225310', 's465879361'] | [3060.0, 4724.0, 2940.0, 3060.0] | [17.0, 19.0, 18.0, 17.0] | [76, 89, 53, 72] |
p03317 | u217975120 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\n\nn, k = map(int, input().split())\na = list(map(int, input().split()))\nlena = len(a)\nindex = a.index(1) + 1\nlenb = lena - index\nif lena / 2 > index:\n front = math.ceil((index-1) / (k-1))\n if k == n :opt = 0\n elif k - index > 0 :opt = k - index\n else :opt = 0\n back = math.ceil((l... | ['Wrong Answer', 'Accepted'] | ['s037760579', 's967243778'] | [13812.0, 13812.0] | [40.0, 39.0] | [503, 114] |
p03317 | u225642513 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K = map(int, input().split())\ninput()\njudge = (N-1)%(K-1) == 0\nif judge:\n print(int((N-1)/(K-1))\nelse:\n print(int((N-1)//(K-1)+1)\n', 'N,K = map(int, input().split())\ninput()\njudge = (N-1)%(K-1) == 0\nif judge:\n print(int((N-1)/(K-1)))\nelse:\n print(int((N-1)//(K-1)+1))\n'] | ['Runtime Error', 'Accepted'] | ['s591555438', 's609478327'] | [2940.0, 4724.0] | [17.0, 21.0] | [138, 140] |
p03317 | u227082700 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k=map(int,input().split())\na=input().split()\nm=a.index("1")\na,b=m,n-m-1\nans=((a+1)//(k-1))+1\nb-=a%(k-1)\nans+=((b+1)//(k-1))+1\nprint(ans)', 'n,k=map(int,input().split());print(((n+2)//(k-1))+1)', 'n,k=map(int,input().split())\na=list(map(int,input().split()))\nprint(((n-2)//(k-1))+1)'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s006571402', 's058386374', 's221365188'] | [10420.0, 3060.0, 14004.0] | [26.0, 17.0, 40.0] | [138, 52, 85] |
p03317 | u228636605 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N , K = (int(i) for i in input().split())\nA = list(int(i) for i in range(input().split(),N))\n\ncount = 1\ns = K\n\nwhile s < N:\n s = s + (K - 1)\n count = count + 1\n print(s)\nprint(count)\n', 'N , K = (int(i) for i in input().split())\nA = list(int(i) for i in input().split())\n\ncount = 1\ns = K\n\nw... | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s635361556', 's715664560', 's473010613'] | [10548.0, 14008.0, 14008.0] | [25.0, 93.0, 54.0] | [193, 184, 186] |
p03317 | u239342230 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K=map(int,input().split())\nA=list(map(int,input().split()))', 'N,K=map(int,input().split())\nA=list(map(int,input().split()))\nprint((N-2)//(K-1)+1)'] | ['Wrong Answer', 'Accepted'] | ['s793271241', 's559604181'] | [13880.0, 13880.0] | [39.0, 42.0] | [61, 83] |
p03317 | u247830763 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\nn,k = map(int,input().split())\nls = list(map(int,input().split()))\na = min(ls)\ni = ls.index(a)\nl = i\nr = n - i - 1\nif r < l:\n l,r = r,l\nprint(l,r)\nif n == k:\n print("1")\nelif l < k-1:\n print(int(math.ceil((r-k+1+l)/(k-1)))+1)\nelse:\n print(int(math.ceil(l/(k-1))+math.ceil(r/(k-1)... | ['Wrong Answer', 'Accepted'] | ['s949248190', 's211570512'] | [13812.0, 13812.0] | [43.0, 41.0] | [307, 109] |
p03317 | u248670337 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k=map(int,input().split())\nA=list(map(int,input().split()))\nr=n-A.index(1)-1\nl=A.index(1)\nprint(r//(k-1)+l//(k-1) if n>k else 1)', 'n,k=map(int,input().split())\nA=list(map(int,input().split()))\nr=n-A.index(1)-1\nl=A.index(1)\nprint(min(-(-r//(k-1))-(-l//(k-1)),-(-(n-1)//(k-1))))'] | ['Wrong Answer', 'Accepted'] | ['s627952824', 's698206975'] | [14008.0, 14008.0] | [42.0, 44.0] | [130, 145] |
p03317 | u261891508 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k=map(int,input().split())\na=list(map(int,input().split()))\nichi=a.index(1) \n\nans=float("inf")\n\n\nimport math\nfor i in range(k):\n left=math.ceil((ichi-i)/(k-1)) \n right=math.ceil((n-ichi-(k-i))/(k-1)) \n print(ichi-i,left,right)\n ans=min(ans,1+left+right)\nprint(ans)\n', 'n,k=map(int,input().split())\... | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s415764770', 's794001896', 's980682445', 's471268914'] | [13880.0, 13880.0, 13880.0, 14004.0] | [290.0, 41.0, 40.0, 76.0] | [520, 561, 563, 655] |
p03317 | u264998565 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['# -*- coding: utf-8 -*-\n\nimport numpy as np\nimport sys\n\nN, K = map(int, input().split())\nA = np.array(list(map(int, input().split())), dtype=np.int)\n\narg = 0\nop_l = 0\nwhile(True):\n arg_new = arg + K - 1\n op_l += 1\n if np.any(A[arg:arg_new+1] == 1):\n last_arg = (arg, arg_new)\n bre... | ['Wrong Answer', 'Runtime Error', 'Wrong Answer', 'Runtime Error', 'Time Limit Exceeded', 'Wrong Answer', 'Accepted'] | ['s135584888', 's255538704', 's397748611', 's441193196', 's751468615', 's924773605', 's836356978'] | [23368.0, 3060.0, 23368.0, 3064.0, 1498672.0, 23396.0, 13812.0] | [929.0, 17.0, 892.0, 17.0, 2200.0, 918.0, 40.0] | [643, 158, 501, 642, 568, 596, 138] |
p03317 | u265281278 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K=map(int, input().split())\nA=input()\nif (N-1)%(K-1):\n print((N-1)//(K-1))\nelse:\n print((N-1)//(K-1)+1)', 'N,K=map(int, input().split())\nA=input()\nif (N-1)%(K-1):\n print((N-1)//(K-1)+1)\nelse:\n print((N-1)//(K-1))'] | ['Wrong Answer', 'Accepted'] | ['s841799729', 's920244066'] | [4724.0, 4724.0] | [19.0, 18.0] | [111, 111] |
p03317 | u278832126 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['from math import ceil\nN, K = map(int, input().split)\nnums = list(map(int, input().split))\nindex = nums.index(1)\nprint(ceil(index / (K - 1)) + ceil((N - index - 1) / (K - 1)))', 'import math\nN, K = map(int, input().split())\nnums = input()\nprint(math.ceil((N - 1) / (K - 1)))'] | ['Runtime Error', 'Accepted'] | ['s555639118', 's860866127'] | [3060.0, 4724.0] | [17.0, 21.0] | [174, 95] |
p03317 | u284854859 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['# your code goes here\n\nN,K = map(int,input().split())\nli = list(map(int,input().split()))\t\nif N == K:\n\tprint(1)\n\tquit()\ni = 1\nN = N-K\n\nwhile N >= K:\n\tN = N - K +1\n\ti = i + 1\n\nprint()', 'import sys\ninput = sys.stdin.readline\n\nn,k = map(int,input().split())\na = list(map(int,input().split()))\n\nr... | ['Wrong Answer', 'Accepted'] | ['s964082276', 's447773439'] | [14008.0, 14388.0] | [48.0, 42.0] | [182, 257] |
p03317 | u288087195 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\nN, K = [int(t) for t in input().split()]\nA = [int(t) for t in input().split()]\n\nidx = A.index(1)\nleft = A[:idx+1]\nright = A[idx:]\n\n\ndef get_cnt(L):\n return math.ceil((len(L) - 1) / (K-1))\n\n\nif left + 1 < K or N - right < K:\n print(get_cnt(A))\nelse:\n print(get_cnt(left) + get_cnt(r... | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s011429247', 's507125821', 's637896322'] | [13812.0, 13812.0, 13812.0] | [48.0, 54.0, 44.0] | [309, 343, 126] |
p03317 | u299869545 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n, k =map(int, input().split())\nprint( (n-1) / (k-1) + ((n-1)%(k-1) != 0))', 'n, k =map(int, input().split())\nprint( (n-1) // (k-1) + ((n-1)%(k-1) != 0))'] | ['Wrong Answer', 'Accepted'] | ['s667634806', 's842137066'] | [2940.0, 3060.0] | [17.0, 17.0] | [74, 75] |
p03317 | u303059352 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['print((int(input()) - 2) / (int(input()) - 1) + 1)', '[print((n[0] - 2) / (n[1] - 1) + 1) for n in [list(map(int, input().split()))]]', '[print(int((n[0] - 2) / (n[1] - 1) + 1)) for n in [list(map(int, input().split()))]]'] | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s926445314', 's973598532', 's574069199'] | [2940.0, 3060.0, 3060.0] | [18.0, 18.0, 20.0] | [50, 79, 84] |
p03317 | u305781333 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N, K = [int(i) for i in input().split()]\nA = [int(i) for i in input().split()]\nmin_number = min(A)\nleft = A.index(min_number)\nright = A.index(min_number)\ncount = 0\n\nwhile len(list(set(A))) > 1:\n if left > 0:\n next_left = left-K+1 if left-K+1 >= 0 else 0\n A[next_left:left+1] = [min_number]*len(A[next... | ['Wrong Answer', 'Accepted'] | ['s304255470', 's858729759'] | [146024.0, 13812.0] | [2039.0, 44.0] | [590, 121] |
p03317 | u305965165 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\nn, k = (int(i) for i in input().split()) \na = [int(i) for i in input().split()]\n\nprint( 1 + math.ceil((n-k) // (k-1)) )', 'n, k = (int(i) for i in input().split()) \na = [int(i) for i in input().split()]\n\nprint(n // k)', 'import math\nn, k = (int(i) for i in input().split()) \na = [int(i) for i i... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s623904333', 's768248305', 's382467576'] | [13812.0, 13880.0, 13812.0] | [44.0, 46.0, 46.0] | [132, 95, 131] |
p03317 | u315485238 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\nN, K = list(map(int, input().split()))\nA = list(map(int, input().split())) \n\nm = min(A)\nanswer = N\n\nfor i in range(N-K+1): \n if not k in A[i:i+K]:\n continue\n answer = min(answer,\n (1 + math.ceil(i/(K-1)) + math.ceil((N-K-i)/(K-1))))\nprint(answer)', 'N, K = list(map(int, input... | ['Runtime Error', 'Accepted'] | ['s769278567', 's059665829'] | [13812.0, 13812.0] | [44.0, 41.0] | [310, 115] |
p03317 | u325227960 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k=map(int,input().split())\nA=list(map(int,input().split()))\n\nm=A.index(1)\n\nle=m\nri=n-m\nif le//(k-1)!=0 :\n ri-=(k-1)-le%(k-1)\n\nprint(le//(k-1)+ri//(k-1))\n', 'n,k=map(int,input().split())\nA=list(map(int,input().split()))\n\n#m=A.index(1)\n\n#le=m\n#ri=n-m\n#if le//(k-1)!=0 :\n# ri-=(k-1)-le%(k-1)\n\... | ['Wrong Answer', 'Accepted'] | ['s653661049', 's415182983'] | [14008.0, 13812.0] | [41.0, 40.0] | [158, 196] |
p03317 | u328364772 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n, k = map(int, input().split())\nA = input()\nans = (n-1)//(k-1)\nprint(ans if (n-1) % (k-1) == ', 'n, k = map(int, input().split())\nA = input()\nans = (n-1)//(k-1)\nprint(ans if (n-1) % (k-1) == 0 else ans + 1)\n'] | ['Runtime Error', 'Accepted'] | ['s740520237', 's159880099'] | [2940.0, 4724.0] | [17.0, 20.0] | [94, 110] |
p03317 | u331381193 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n, k = map(int, input().split())\nx = [map(int, input().split())]\n\nfor i in range(n):\n\tl=k*i-(i-1)\n\tif i==0:\n\t\tl=k\n\tif l>=n:\n\t\tprint(i+1)\n\t\tbreak', 'n, k = map(int, input().split())\nx = list(map(int, input().split()))\n\nfor i in range(1,n+1):\n\tl=k*i-(i-1)\n\tif l>=n:\n\t\tprint(i)\n\t\tbreak'] | ['Wrong Answer', 'Accepted'] | ['s216748265', 's102374267'] | [10420.0, 13880.0] | [39.0, 50.0] | [144, 134] |
p03317 | u342563578 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N, K = map(int,input().split())\nAlist = list(map(int,input().split()))\nprint(-(-N-1//K-1))', 'N, K = map(int,input().split())\nAlist = list(map(int,input().split()))\nprint(-(-N-1//k-1))', 'N, K = map(int,input().split())\nAlist = list(map(int,input().split()))\nn = 0\nl = 0\nr = o\nfor i in range(N):\n if Alist... | ['Wrong Answer', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s044442496', 's229787875', 's356622960', 's238868232'] | [13880.0, 13880.0, 13880.0, 14004.0] | [41.0, 41.0, 40.0, 40.0] | [90, 90, 207, 94] |
p03317 | u347640436 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n, k = map(int, input())\nprint(((n - 1) + (k - 2)) // (k - 1))\n', 'n, k = map(int, input().split())\nprint(((n - 1) + (k - 2)) // (k - 1))\n'] | ['Runtime Error', 'Accepted'] | ['s270349250', 's626728912'] | [2940.0, 2940.0] | [17.0, 17.0] | [63, 71] |
p03317 | u366644013 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\nn, k = map(int, input().split())\na = input()\nprint(math.celi(n-1/k-1))', 'import math\nn, k = map(int, input().split())\na = input()\nprint(math.ceil((n-1)/(k-1)))'] | ['Runtime Error', 'Accepted'] | ['s875872848', 's888026555'] | [4724.0, 4724.0] | [18.0, 18.0] | [82, 86] |
p03317 | u366964431 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ["import numpy as np\n#import pdb\n\ntmp = list(map(int, input().strip().split(' ')))\nN = tmp[0]\nK = tmp[1]\nA = list(map(int, input().strip().split(' ')))\n\nA = np.asarray(A)\npos = np.argmin(A)\n\nleft = pos\nright = N - pos - 1\n\nst_list = [x for x in range(max(0, pos - K + 1), min(pos + 1, N))]\n\ncnt = np.inf\... | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s047147318', 's329327743', 's947191031', 's212281712'] | [25300.0, 23400.0, 24644.0, 23368.0] | [448.0, 597.0, 352.0, 174.0] | [550, 533, 567, 222] |
p03317 | u370661635 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k=map(int,input().split())\na = list(map(int,input().split()))\n\nprint((n-1)//(k-1))', 'import math\nn,k=map(int,input().split())\nprint(math.ceil((n-k)/(k-1))+1)'] | ['Wrong Answer', 'Accepted'] | ['s176208762', 's123782105'] | [14008.0, 3064.0] | [40.0, 17.0] | [84, 72] |
p03317 | u375616706 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n, k = map(int, input().split())\na = (list)(map(int, input().split()))\n\n# print(-(-(n-1)//(k-1)))\nprint((n+1 + (k - 2)) // (k-1))\n', 'n, k = map(int, input().split())\na = (list)(map(int, input().split()))\n\nif n == k:\n print(1)\nelse:\n print(n//(k+1))\n', 'n, k = map(int, input().split())\na = (list)(map(i... | ['Wrong Answer', 'Wrong Answer', 'Runtime Error', 'Accepted'] | ['s206703743', 's370253094', 's459099164', 's182111434'] | [13880.0, 13880.0, 2940.0, 13880.0] | [42.0, 42.0, 18.0, 44.0] | [130, 118, 115, 132] |
p03317 | u382639013 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N, K = list(map(int, input().split()))\nA = list(map(int, input().split()))\n\nimport math\nprint(ceil((N-1)/(K-1)))', 'N, K = list(map(int, input().split()))\nA = list(map(int, input().split()))\n\nimport math\nprint(math.ceil((N-1)/(K-1)))'] | ['Runtime Error', 'Accepted'] | ['s032680798', 's282537508'] | [20532.0, 20608.0] | [48.0, 50.0] | [112, 117] |
p03317 | u384679440 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\nN, K = map(int, input().split())\nA = list(map(int, input().split()))\nprint(math.ceil((N - 1) // (K - 1)))', 'N, K = map(int, input().split())\nA = list(map(int, input().split()))\nprint((N - 1) // (K - 1))', 'import math\nN, K = map(int, input().split())\nA = list(map(int, input().split()))\nprint(math... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s478594201', 's554400483', 's770447544'] | [13812.0, 13880.0, 13812.0] | [40.0, 39.0, 40.0] | [117, 94, 116] |
p03317 | u395816772 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k = map(int,input().split())\na = [int(i) for i in input().split()]\n\nb = a.index(1) \nif b < k-1:\n b += k-1 -b\nif b > (n-1) -(k-1):\n b -= b - (k-1)\nc,d = divmod(b,k-1)\nans = c\nrem = d\nif d != 0:\n ans +=1\ne = n-1 -b\nc,d = divmod(e,k-1)\nans += c\nif d != 0:\n ans +=1\nif rem + d <= k-1 and re... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s441697018', 's494669389', 's488000003'] | [20580.0, 20404.0, 20504.0] | [49.0, 56.0, 55.0] | [341, 318, 351] |
p03317 | u404676457 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['(n, k) = map(int, input().split())\n_ = input()\ncount = n // (k - 1)\nif n % k == 1:\n count -= 1\nprint(count)', '(n, k) = map(int, input().split())\n_ = input()\ncount = 0\n\nwhile n > k:\n n -= k - 1\n count += 1\n\ncount += 1\nprint(count)'] | ['Wrong Answer', 'Accepted'] | ['s152134287', 's090106587'] | [4280.0, 4724.0] | [18.0, 29.0] | [110, 125] |
p03317 | u405256066 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['from sys import stdin\nN,K = [int(x) for x in stdin.readline().rstrip().split()]\ndata = [int(x) for x in stdin.readline().rstrip().split()]\nleft = data.index(1)\nright = N - data.index(1) - 1\nans = (left // (K-1)) + (right // (K-1)) + 2\nprint(ans)', 'from sys import stdin\nimport math\nN,K = [int(x) for x in stdi... | ['Wrong Answer', 'Accepted'] | ['s744809893', 's281199062'] | [13880.0, 3060.0] | [46.0, 17.0] | [245, 123] |
p03317 | u408325839 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\nn, k = map(int,input().split())\ninput()\nprint((n-1)/(k-1), math.ceil((n - 1)/(k - 1)))\n', 'import math\nn, k = map(int,input().split())\ninput()\nprint(int(math.ceil((n - 1)//(k - 1))))\n', 'n, k = map(int,input().split())\nprint(n//(k-1) + 1)\n', 'import math\nn, k = map(int,input().split())\ninput()... | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s191361649', 's400562988', 's845403902', 's916664363'] | [10148.0, 10168.0, 9160.0, 10156.0] | [28.0, 27.0, 44.0, 27.0] | [99, 92, 52, 82] |
p03317 | u411302151 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['from math import ceil\n\nN, K = map(int, input().split())\nll = list(map(int, input().split()))\n\nidx = ll.index(1)\n\nl, r = idx, N-idx\nprint(l, r)\nprint(ceil((l)/(K-1))+ ceil((r-1)/(K-1)))', 'from math import ceil\n\nN, K = map(int, input().split())\nll = list(map(int, input().split()))\n\nprint(ceil((N-1) / (K-... | ['Wrong Answer', 'Accepted'] | ['s823333925', 's046408345'] | [13812.0, 13812.0] | [40.0, 41.0] | [184, 120] |
p03317 | u411858517 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N, K = map(int, input().split())\nA = list(map(int, input().split()))\nm = min(A)\nres = 0\nfor i in range(N):\n min_num = i\n if m == A[i]:\n break\n \n \nn1 = min_num \nn2 = N - min_num - 1\n\nif n1 == 0:\n res = math.ceil(n2/2)\nelif n2 == 0:\n res = math.ceil(n1/2)\nelse:\n res = m... | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s431346036', 's720518764', 's838425811'] | [13880.0, 13812.0, 13880.0] | [51.0, 43.0, 40.0] | [348, 414, 158] |
p03317 | u416011173 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['# -*- coding: utf-8 -*-\n\nimport math\n\n\nN, K = list(map(int, input().split()))\nA = list(map(int, input().split()))\n\n\nx = A.index(1)\ny = N - x - 1\nans = math.ceil(x / (K - 1)) + \\\n math.ceil((y - ((K - 1) - x % (K - 1))) / (K - 1))\n\n\nprint(ans)\n', '# -*- coding: utf-8 -*-\n\nimport math\n\n\ndef get... | ['Wrong Answer', 'Accepted'] | ['s862624249', 's779762526'] | [20472.0, 20580.0] | [54.0, 53.0] | [332, 740] |
p03317 | u428132025 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\n\nn, k = map(int, input().split())\na = [int(_) for _ in input().split()]\n\nif n == k:\n print(1)\n exit()\n\nidx = a.index(1)\nnum_l = idx\nnum_r = n - idx - 1\nprint(num_l, num_r)\n\nif num_l == 0 or num_r == 0:\n print(math.ceil(num_l / (k - 1)) + math.ceil(num_r / (k - 1)))\nelif num_l < k-... | ['Wrong Answer', 'Accepted'] | ['s080702922', 's616055501'] | [13812.0, 13812.0] | [44.0, 44.0] | [566, 114] |
p03317 | u440191278 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ["import sys\n\ndef solve(n, k, as):\n return n/(k-1)\n\ndef readQuestion():\n line = sys.stdin.readline().rstrip()\n [str_n, str_k] = line.split(' ')\n line = sys.stdin.readline().rstrip()\n as = line.split(' ')\n return (int(str_n), int(str_k), [int(a) for a in as])\n\ndef main():\n n, k, as ... | ['Runtime Error', 'Accepted'] | ['s688629283', 's743630414'] | [2940.0, 14900.0] | [17.0, 44.0] | [411, 484] |
p03317 | u450904670 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\nN,K = list(map(int, input().split()))\nA = list(map(int, input().split()))\n\nans = 1\n\nif(K-1 == 1):\n print(N - 1)\nelse:\n print(N // (K - 1))\nidx = A.index(1)\ncnt = 1\nright = idx\nleft = idx\nwhile True:\n for i in range(1, K):\n right += 1\n if(right < len(A)): \n A[right] = 1\n ... | ['Wrong Answer', 'Accepted'] | ['s455683235', 's390902886'] | [13812.0, 13812.0] | [84.0, 85.0] | [496, 439] |
p03317 | u454714837 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K = map(int,input().split())\nA = list(input())\n\nAns = N-1//(K-1)\n\nprint(Ans)', 'N,K = map(int,input().split())\nA = list(input())\nAns = 0\n\nif (N-1)%(K-1)==0:\n Ans = Ans = N//(K-1)\nelse:\n Ans = N//(K-1) + 1\n\nprint(Ans)', "N,K = map(int,input().split())\nA = list(input())\nAns = 0\n\nif N == K:\n ... | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s530787708', 's546711105', 's769053476', 's283140290'] | [8756.0, 8756.0, 9140.0, 8756.0] | [27.0, 27.0, 27.0, 30.0] | [78, 142, 281, 145] |
p03317 | u459590249 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['from math import ceil\nn,k=map(int,input().split())\nprint(ceil(n-1/k-1))', 'from math import ceil\nn,k=map(int,input().split())\nprint(ceil((n-1)/(k-1)))'] | ['Wrong Answer', 'Accepted'] | ['s305880274', 's742575865'] | [3060.0, 3060.0] | [17.0, 17.0] | [71, 75] |
p03317 | u473092610 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['\n\n\nusing namespace std;\n\nint main(){\n int n,k;\n cin >> n >> k;\n std::vector<char> a(n);\n\n for (int i =0;i<n;i++)\n cin >> a[i];\n int ans =-(-n/(k-1));\n cout << ans<<endl;\n\n\n}', 'n,k=map(int,input().split())\na=list(map(int,input().split()))\nn=n-k\nprint(-(-n//(k-1))+1)'] | ['Runtime Error', 'Accepted'] | ['s660010587', 's984346653'] | [2940.0, 14004.0] | [17.0, 39.0] | [232, 89] |
p03317 | u474270503 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N, K = map(int, input().split())\n\nA = list(map(int, input().split()))\n\nmin_A = min(A)\n\n\nind1 = A.index(1)\nlen1 = len(A) -ind1\nlen2 = ind1 + 1\nprint((len1-1)//(K-1)-1+1 + (len2-1)//(K-1)-1+1)\n', 'N, K = map(int, input().split())\n\nA = list(map(int, input().split()))\n\nmin_A = min(A)\n\n\nind1 = A.index(1)... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s362483894', 's948395085', 's068694410'] | [13880.0, 14008.0, 14008.0] | [42.0, 273.0, 159.0] | [191, 581, 563] |
p03317 | u488127128 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['3 3\n1 2 3', "def solve():\n n,k = map(int, input().split())\n if (n-1)%(k-1) != 0:\n return (n-1)//(k-1) + 1\n else:\n return (n-1)//(k-1)\n\nif __name__ == '__main__':\n print(solve())"] | ['Runtime Error', 'Accepted'] | ['s802272775', 's648118931'] | [2940.0, 3060.0] | [17.0, 17.0] | [9, 190] |
p03317 | u497883442 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k = list(map(int, input().split()))\na = list(map(int, input().split()))\nprint((n-k+1)//(n-1)+1)', 'n,k = list(map(int, input().split()))\na = list(map(int, input().split()))\nprint((n-1)//(k-1))', 'n,k = list(map(int, input().split()))\na = list(map(int, input().split()))\nc = 0\nwhile n > 0:\n if c == 0:\n n... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s080992333', 's201975735', 's635357379'] | [14008.0, 13880.0, 13880.0] | [41.0, 41.0, 49.0] | [97, 93, 155] |
p03317 | u503228842 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K =map(int,input().split())\nans = (N-1)//(K-1)\nprint(ans)', 'N,K =map(int,input().split())\nans = 1+(N-K)//(K-1)\nprint(ans)', 'N,K = map(int,input().split())\nA = list(map(int,input().split()))\nidx = A.index(1)\nimport math\nans = math.ceil((N-1)/(K-1))\nprint(ans)'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s558638576', 's851451840', 's021283346'] | [3060.0, 3060.0, 13880.0] | [17.0, 17.0, 41.0] | [59, 61, 134] |
p03317 | u507456172 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K = map(int,input().split())\nA = list(map(int,input().split()))\n\nprint((N-1)//(K-1))', 'N,K = map(int,input().split())\nA = list(map(int,input().split()))\n\nif (N-1)%(K-1) == 0:\n print((N-1)//(K-1))\nelse:\n print((N-1)//(K-1)+1)'] | ['Wrong Answer', 'Accepted'] | ['s670168951', 's650338229'] | [20480.0, 20560.0] | [54.0, 50.0] | [86, 139] |
p03317 | u513081876 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N, K = map(int, input().split())\nA = list(map(int, input().split()))\nans = 0\nmin_in = A.index(1)\n\nleft = len(A[0:min_in])\n\nright = len(A[min_in+1:])\n#print(left, right)\nif N ==K:\n ans = 1\n \nelse:\n if (min(left, right) + 1) < K:\n ans += 1\n tuyoi = len(A-K)\n \n ans ... | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s872959473', 's903658119', 's511906821'] | [14008.0, 14008.0, 13880.0] | [41.0, 41.0, 52.0] | [651, 631, 189] |
p03317 | u518042385 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,m=map(int,input().split())\nl=list(map(int,input().split()))\nmin=l[0]\nindex=0\nfor i in range(n):\n if min>l[i]:\n min=l[i]\n index=i\nindex+=1\nindex2=n-index\nsum=0\nsum+=index2//m+1\nindex3=index-1\nsum+=index3//m+1\n ', 'n,m=map(int,input().split())\nl=list(map(int,input().split()))\nif (n-1)%(m-1)==0... | ['Wrong Answer', 'Accepted'] | ['s459726902', 's222854643'] | [13880.0, 13880.0] | [50.0, 40.0] | [219, 133] |
p03317 | u520276780 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['\n\n\n\n\n\nn,k = map(int,input().split( ))\nprint((n+k-1)//(k-1))\n', '\nn,k = map(int,input().split( ))\nprint((n+k-3)//(k-1))'] | ['Wrong Answer', 'Accepted'] | ['s708049841', 's066285602'] | [3060.0, 2940.0] | [19.0, 18.0] | [215, 89] |
p03317 | u527261492 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k=map(int,input().split())\na=list(map(int,input().split()))\nidx=a.index(1)\nprint((n-idx)//(k-1)+(1 if (n-idx)%(k-1)!=0 else 0)+(idx+1)//(k-1)+(1 if (idx+1)%(k-1)!=0 else 0))\n', 'n,k=map(int,input().split())\na=list(map(int,input().split()))\ncnt=1\nn-=k\nwhile n>0:\n n-=k-1\n cnt+=1\nprint(cnt)'] | ['Wrong Answer', 'Accepted'] | ['s496939192', 's001050138'] | [14008.0, 13880.0] | [40.0, 50.0] | [176, 112] |
p03317 | u531214632 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K = map(int, input().split())\nprint(-(-(N-1))//(K-1))\n', 'import math\nN, K = map(int, input().split())\nprint( 1 + math.ceil((N-K) / (K-1)) )'] | ['Wrong Answer', 'Accepted'] | ['s342551939', 's182543790'] | [2940.0, 3060.0] | [18.0, 17.0] | [56, 82] |
p03317 | u532806301 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K = map(int, input().split())\nlist = []\nfor i in range(N):\n list.append(int(input()))\n\nprint(-(-(N-1)//(K-1)))', 'N,K = map(int, input().split())\nprint(-(-(N-1)//(K-1)))'] | ['Runtime Error', 'Accepted'] | ['s814981111', 's931667534'] | [4724.0, 3064.0] | [21.0, 17.0] | [115, 55] |
p03317 | u538739837 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k=map(int,input().split())\na=list(map(int,input().split()))\ncount=1\nn-k\nwhile(n>0):\n n-(k-1)\n count+=1\nprint(count)\n', 'n,k=map(int,input().split())\na=list(map(int,input().split()))\ncount=1\nn=n-k\nwhile(n>0):\n n=n-(k-1)\n count+=1\nprint(count)'] | ['Time Limit Exceeded', 'Accepted'] | ['s821350343', 's275169647'] | [13880.0, 14004.0] | [2104.0, 48.0] | [124, 127] |
p03317 | u545368057 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K = map(int,input().split())\nAs = list(map(int,input().split()))\nprint((N-1)//(K-1))', 'N,K = map(int, input().split())\nAs = list(map(int, input().split()))\n\nimport numpy as np \nans = np.ceil((N-1)/(K-1))\nprint(int(ans))\n'] | ['Wrong Answer', 'Accepted'] | ['s728625514', 's602028365'] | [13880.0, 16424.0] | [40.0, 173.0] | [86, 133] |
p03317 | u551373727 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N, K = map(int, input().split())\nA = list(map(int, input().split()))\n\nprint(N//K)', 'N, K = map(int, input().split())\nA = list(map(int, input().split()))\n\na = (N-2)//(K-1)+1\n\nprint(a)'] | ['Wrong Answer', 'Accepted'] | ['s400296115', 's387942392'] | [13880.0, 13880.0] | [40.0, 39.0] | [81, 98] |
p03317 | u556225812 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\nN, K = map(int, input().split())\nprint(math.ceil((N-K)/(K-1)))', 'import math\nN, K = map(int, input().split())\nprint(math.ceil((N-1)/(K-1)))'] | ['Wrong Answer', 'Accepted'] | ['s683663307', 's515123291'] | [3060.0, 3060.0] | [17.0, 17.0] | [74, 74] |
p03317 | u556487440 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['\nimport math\n\nn , k = map(int, input().split())\nb = list(map(int,input().split()))\ncnt = 1\ni = 0\nfor t in b:\n if t == 1:\n i = cnt\n break\n cnt += 1\n\nresult = math.ceil((i-1)/(k-1)) + math.ceil((n-i)/(k-1))\nif ((i-1)/(k-1) - math.floor((i-1)/(k-1))) + ((n-i)/(k-1) - math.floor((n-i)/(k... | ['Wrong Answer', 'Accepted'] | ['s493356161', 's847363394'] | [13812.0, 13812.0] | [47.0, 46.0] | [568, 668] |
p03317 | u570018655 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N, K = map(int, input().split())\nl = list(map(int, input().split()))\nindex = l.index(1) + 1\n\nans = 0\n\nif index != 1:\n p = index - K\n ans += 1\n if p < 0:\n index = K\n p += 1\n while p > 0:\n p = p - K\n ans += 1\n\nwhile index < N:\n index = index + (K - 1)\n ans += ... | ['Wrong Answer', 'Wrong Answer', 'Runtime Error', 'Accepted'] | ['s488079512', 's651448608', 's883711617', 's637023558'] | [20560.0, 20472.0, 9100.0, 13812.0] | [55.0, 52.0, 29.0, 40.0] | [398, 398, 423, 142] |
p03317 | u575653048 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\nn, k = map(int, input().split())\na = list(map(int, input().split()))\nx = a.index(1)\n#if x % (k-1) + (n-k-1) % (k-1) > k-1:\nprint(math.ceil((n-1) // (k-1)))', 'import math\nn, k = map(int, input().split())\na = list(map(int, input().split()))\nx = a.index(1)\n#if x % (k-1) + (n-k-1) % (k-1) > k-1:\npr... | ['Wrong Answer', 'Accepted'] | ['s604836694', 's402581198'] | [13812.0, 13812.0] | [41.0, 40.0] | [167, 166] |
p03317 | u576320075 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\n\n\n\na = list(map(int, input().split()))\nn -= 1\nk -= 1\nans = (n + k - 1) // k\n\nprint(ans)\n', 'import math\n\nn, k = map(int, input().split())\n\n# a = list(map(int, input().split()))\nn -= 1\nk -= 1\nans = (n + k - 1) // k\n\nprint(ans)\n'] | ['Runtime Error', 'Accepted'] | ['s815752976', 's208210919'] | [3060.0, 3060.0] | [17.0, 19.0] | [134, 134] |
p03317 | u578489732 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ["# -*- coding: utf-8 -*-\nimport sys\n# ----------------------------------------------------------------\n# Use Solve Function\n\ndef solve(lines):\n N,K = map(int, lines.pop(0).split(' '))\n A = list(map(int, lines.pop(0).split(' ')))\n min_a = min(A)\n idx = 0\n re = 0\n while( idx < N ):\n ... | ['Wrong Answer', 'Accepted'] | ['s095325684', 's154594306'] | [4272.0, 13872.0] | [19.0, 74.0] | [675, 687] |
p03317 | u578953945 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N,K=map(int,input.split())\nTMP=K\nANS=1\nif N <= K:\n ANS=1\nelse:\n TMP+=(K-1)\n ANS+=1\n if N <= K:\n break\nprint(ANS)\n', 'N,K=map(int,input.split())\nTMP=K\nANS=1\nif N =< K:\n ANS=1\nelse:\n TMP=(K-1)\n ANS+=1\n if N <= K:\n break\nprint(ANS)\n', 'N,K=map(int,input.split())\nTMP=K\nANS=1\nif N <=... | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s137842109', 's316242156', 's993477728', 's378713709'] | [2940.0, 2940.0, 2940.0, 3060.0] | [17.0, 17.0, 17.0, 28.0] | [120, 119, 119, 145] |
p03317 | u595289165 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n, k = map(int, input().split())\na = list(map(int, input().split()))\nx = a.index(1)\nleft = x\nright = n - x - 1\n\nans = n\nfor i in range(k):\n if left < i:\n continue\n a = left - i + 1\n if right - k + 2 + i < 0:\n continue\n b = right - k + 2 + i\n print(a, b)\n w = a//(k-1) + b... | ['Wrong Answer', 'Accepted'] | ['s449209194', 's412878952'] | [13880.0, 13880.0] | [110.0, 40.0] | [349, 188] |
p03317 | u597374218 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n,k=map(int,input().split())\na=len(list(map(int,input().split())))\nprint((n-k-3)//(k-1))', 'n,k=map(int,input().split())\na=len(list(map(int,input().split())))\nprint((n+k-3)//(k-1))'] | ['Wrong Answer', 'Accepted'] | ['s120436804', 's646829978'] | [13880.0, 13880.0] | [41.0, 39.0] | [88, 88] |
p03317 | u600935366 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n, k = map(int, input().split())\na = list(map(int, input().split()))\n\nprint(int((k-1)/(n-1)))', 'n, k = map(int, input().split())\na = list(map(int, input().split()))\n\nprint(int((n-1)/(k-1)))\n', 'import math\nn, k = map(int, input().split())\na = list(map(int, input().split()))\n\nprint(math.ceil((n-1)/(k-1)))'... | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s361963204', 's740905157', 's254375552'] | [13812.0, 13880.0, 13812.0] | [40.0, 40.0, 39.0] | [93, 94, 111] |
p03317 | u609061751 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import sys\nimport numpy as np\ninput = sys.stdin.readline\nN, K = [int(x) for x in input().split()]\nA = np.array([int(x) for x in input().split()],np.int64)\nans = 0\ncnt = 0\nminA = np.argmin(A)\nleftA = A[:minA]\nrightA = A[minA+1:]\nx = len(leftA)\ny = len(rightA)\nfor i in [x,y]:\n ans += i // (K-1)\n cnt... | ['Wrong Answer', 'Accepted'] | ['s081859316', 's965009498'] | [23480.0, 23440.0] | [183.0, 182.0] | [405, 407] |
p03317 | u611509859 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['import math\nn, k = map(int, input().split())\na = list(map(int, input().split()))\nprint(math.floor((n-1+(n%(k-1)))//(k-1)))', 'import math\nn, k = map(int, input().split())\na = list(map(int, input().split()))\nif (n-1) % (k-1) == 0:\n print(math.floor((n-1)/(k-1)))\nelse:\n print(math.floor((n-1)/(k-1))+1)'] | ['Wrong Answer', 'Accepted'] | ['s906300898', 's395056064'] | [13812.0, 13812.0] | [39.0, 39.0] | [122, 181] |
p03317 | u614627871 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['N = int(input())\ndsum = 0\ntmp = N\nwhile tmp > 0:\n dsum += tmp % 10\n tmp /= 10\n tmp = int(tmp)\nif N % dsum != 0:\n print ("No")\nelse:\n print ("Yes")', 'import math\ndef main():\n line_input = input().split()\n n = int(line_input[0])\n k = int(line_input[1])\n nums = input().split()\n pri... | ['Runtime Error', 'Accepted'] | ['s059201264', 's712568473'] | [3060.0, 10420.0] | [18.0, 26.0] | [153, 186] |
p03317 | u615710615 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['#!/usr/bin/env python\n# -*- coding:utf-8 -*-\n\nN,K = map(int,input().split(" "))\nA = list(map(int, input().split(" ")))\n\nF=0\nfor i in A:\n if i==1:\n X=F \n Y=N-(F+1)\n break;\n F=F+1\n\nqX=X//(K-1)\nqY=Y//(K-1)\n\nmodX=X%(K-1)\nmodY=Y%(K-1)\n\nprint(F,qX,qY,modX,modY)\nif modX>0:\n ... | ['Wrong Answer', 'Accepted'] | ['s439233542', 's783592463'] | [13880.0, 14008.0] | [46.0, 49.0] | [388, 272] |
p03317 | u618512227 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['n , k = map(int, input().split())\nif k == 2:\n print(n-1)\nelif k == n-1:\n print(2)\nelif n%2 != 0 k%2 == 0 and (n-k)%(k-1) != 0:\n \tprint(n//(k-1) + 1)\nelse:\n print(n//(k-1))', 'n , k = map(int, input().split())\nif k == 2:\n print(n-1)\nelif k == n-1:\n print(2)\nelif (n-k)%(k-1) == 0:\n pri... | ['Runtime Error', 'Accepted'] | ['s809180263', 's429089083'] | [2940.0, 3060.0] | [17.0, 23.0] | [181, 171] |
p03317 | u622277165 | 2,000 | 1,048,576 | There is a sequence of length N: A_1, A_2, ..., A_N. Initially, this sequence is a permutation of 1, 2, ..., N. On this sequence, Snuke can perform the following operation: * Choose K consecutive elements in the sequence. Then, replace the value of each chosen element with the minimum value among the chosen element... | ['# -*- coding:utf-8 -*-\nn, k = list(map(int, input().split()))\nnums = list(map(int, input().split()))\none_index = nums.index(1)\nmin = n\nfor i in range(k):\n left = one_index - i\n right = len(nums[one_index+1:]) - (k - i)\n if left + right > n-1:\n break\n else:\n min_tmp = (-(-left//(k-... | ['Wrong Answer', 'Accepted'] | ['s457024634', 's470391865'] | [13812.0, 13812.0] | [2104.0, 40.0] | [394, 211] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.