question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1>n, t = list(map(int,input().split()))</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>for _ in range(t):</line-5>
<line-6> g[0][0] += 1.0</line-6>
<line-7> for i in range(n):</line-7>
<line-8> for j in range(i+1):</line-8>
<line-9> spill = max(0, g[i][j] - 1.0)</line-9>
<line-10> g[i][j] -= spill</line-10>
<line-11> if i < n - 1:</line-11>
<line-12> g[i + 1][j] += spill / 2</line-12>
<line-13> g[i + 1][j + 1] += spill / 2</line-13>
<line-14> if g[n-1][0] == 1.0:</line-14>
<line-15> break</line-15>
<line-16></line-16>
<line-17>cnt = 0</line-17>
<line-18>for i in range(n):</line-18>
<line-19> for j in range(i + 1):</line-19>
<line-20> if g[i][j] == 1.0:</line-20>
<line-22>print(cnt)</line-22>
|
{"code": "<line-2>g = [[0.0] * i for i in range(1,n+1)]</line-2>\n<line-21> cnt += 1</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>if n <= 1:</line-3>
<line-4> print(-1)</line-4>
<line-5> return</line-5>
<line-6>dx = [1e9, -1e9]</line-6>
<line-7>dy = [1e9, -1e9]</line-7>
<line-8>for x, y in points:</line-8>
<line-9> dx[0] = min(dx[0], x)</line-9>
<line-10> dx[1] = max(dx[1], x)</line-10>
<line-11> dy[0] = min(dy[0], y)</line-11>
<line-12> dy[1] = max(dy[1], y)</line-12>
<line-13>area = (dx[1] - dx[0]) * (dy[1] - dy[0])</line-13>
<line-14>if area:</line-14>
<line-15> print(area)</line-15>
<line-17> print(-1)</line-17>
|
{"code": "<line-2>points = [[int(x) for x in input().split()] for _ in range(n)]</line-2>\n<line-16>else:</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>'''input</line-1>
<line-3>4</line-3>
<line-4>2</line-4>
<line-5>'''</line-5>
<line-6></line-6>
<line-7>def list_input():</line-7>
<line-8> return list(map(int,input().split()))</line-8>
<line-9>def map_input():</line-9>
<line-10> return map(int,input().split())</line-10>
<line-11>def map_string():</line-11>
<line-12> return input().split()</line-12>
<line-13> </line-13>
<line-14>def f(n,a,b,left,cnta = 4,cntb = 2):</line-14>
<line-15> if(cnta == 0 and cntb == 0): return 0</line-15>
<line-16> if(cnta < 0 or cntb < 0): return 100000000000000000000</line-16>
<line-17> if a <= left and cnta and b <= left and cntb:</line-17>
<line-18> return min(f(n,a,b,left-a,cnta-1,cntb),f(n,a,b,left-b,cnta,cntb-1))</line-18>
<line-19> if a <= left and cnta:</line-19>
<line-20> return f(n,a,b,left-a,cnta-1,cntb)</line-20>
<line-21> if b <= left and cntb:</line-21>
<line-22> return f(n,a,b,left-b,cnta,cntb-1)</line-22>
<line-23> return 1+min(f(n,a,b,n-a,cnta-1,cntb),f(n,a,b,n-b,cnta,cntb-1)) </line-23>
<line-24></line-24>
<line-25>n = int(input())</line-25>
<line-26>a = int(input())</line-26>
<line-28>print(f(n,a,b,0))</line-28>
|
{"code": "<line-2>6</line-2>\n<line-27>b = int(input())</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>p = input()</line-3>
<line-4>m = 0</line-4>
<line-5>suc = True</line-5>
<line-6>for i in range(n-1):</line-6>
<line-7> m = max(m,a[i])</line-7>
<line-8> if p[i] == '0' and m>(i+1):</line-8>
<line-9> suc = False</line-9>
<line-10> break</line-10>
<line-11>if suc:</line-11>
<line-12> print('YES')</line-12>
<line-14> print('NO')</line-14>
|
{"code": "<line-2>a = list(map(int,input().split()))</line-2>\n<line-13>else:</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>seat = input()</line-1>
<line-3>col = seat[-1]</line-3>
<line-4>row = int(seat[:-1])</line-4>
<line-5>row -= 1</line-5>
<line-6></line-6>
<line-7>blocks_to_serve = row // 4</line-7>
<line-8>time = (6 * 2 + 4) * blocks_to_serve</line-8>
<line-9></line-9>
<line-10>if row % 2 == 1:</line-10>
<line-11> time += 6 + 1</line-11>
<line-12></line-12>
<line-14></line-14>
<line-15>print(time)</line-15>
|
{"code": "<line-2>time_to = {'a': 4, 'f': 1, 'b': 5, 'e': 2, 'c': 6, 'd': 3}</line-2>\n<line-13>time += time_to[col]</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>n, bx = list(map(int, input().split()))</line-1>
<line-3>x = 0</line-3>
<line-4>for i in range(n):</line-4>
<line-5> x *= bx</line-5>
<line-6> x += x1[i]</line-6>
<line-7></line-7>
<line-8>n, by = list(map(int, input().split()))</line-8>
<line-9>y1 = list(map(int, input().split()))</line-9>
<line-10>y = 0</line-10>
<line-11>for i in range(n):</line-11>
<line-12> y *= by</line-12>
<line-13> y += y1[i]</line-13>
<line-14></line-14>
<line-15>if x == y:</line-15>
<line-16> print('=')</line-16>
<line-17>elif x < y:</line-17>
<line-18> print('<')</line-18>
<line-20> print('>')</line-20>
|
{"code": "<line-2>x1 = list(map(int, input().split()))</line-2>\n<line-19>else:</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>from math import *</line-1>
<line-3>if n==3:</line-3>
<line-4> li=list(map(int,input().split()))</line-4>
<line-5> ans=0</line-5>
<line-6> flag=0</line-6>
<line-7> for i in li:</line-7>
<line-8> ans^=i</line-8>
<line-9> if ans==0:</line-9>
<line-10> print("BitAryo")</line-10>
<line-11> else:</line-11>
<line-12> print("BitLGM")</line-12>
<line-13>elif n==2:</line-13>
<line-14> li=list(map(int,input().split()))</line-14>
<line-15> li.sort()</line-15>
<line-16> phi=(1+sqrt(5))/2</line-16>
<line-17> ch=[0]*(785)</line-17>
<line-18> for i in range(300):</line-18>
<line-19> a=floor(phi*i)</line-19>
<line-20> b=floor((phi**2)*i)</line-20>
<line-21> ch[a]=b</line-21>
<line-22> ch[b]=a</line-22>
<line-23> if ch[li[0]]==li[1]:</line-23>
<line-24> print("BitAryo")</line-24>
<line-25> else:</line-25>
<line-26> print("BitLGM")</line-26>
<line-27>else:</line-27>
<line-28> li=int(input())</line-28>
<line-29> if li==0:</line-29>
<line-30> print("BitAryo")</line-30>
<line-32> print("BitLGM")</line-32>
|
{"code": "<line-2>n=int(input())</line-2>\n<line-31> else:</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>n,k=map(int,input().split())</line-1>
<line-3>pf=[]</line-3>
<line-4>needed=[]</line-4>
<line-5>for i in range(2,40000):</line-5>
<line-6> if k%i==0:</line-6>
<line-7> pf.append(i)</line-7>
<line-8> c=0</line-8>
<line-9> while k%i==0:</line-9>
<line-10> k//=i</line-10>
<line-11> c+=1</line-11>
<line-12> needed.append(c)</line-12>
<line-13>if k>1:</line-13>
<line-14> pf.append(k)</line-14>
<line-15> needed.append(1)</line-15>
<line-16>pfl=len(pf)</line-16>
<line-17>cnt=[[0]*n for i in range(pfl)]</line-17>
<line-18>for i in range(n):</line-18>
<line-19> for j in range(len(pf)):</line-19>
<line-20> c=0</line-20>
<line-21> while l[i]%pf[j]==0:</line-21>
<line-22> c+=1</line-22>
<line-23> l[i]//=pf[j]</line-23>
<line-24> cnt[j][i]=c</line-24>
<line-25>have=[sum(i) for i in cnt]</line-25>
<line-26>pos=n</line-26>
<line-27>def ok():</line-27>
<line-28> for i in range(len(pf)):</line-28>
<line-29> if have[i]<needed[i]:</line-29>
<line-30> return False</line-30>
<line-31> return True</line-31>
<line-32>if not ok():</line-32>
<line-33> print(0)</line-33>
<line-34> quit()</line-34>
<line-35>for i in range(n-1,0,-1):</line-35>
<line-36> for j in range(len(pf)):</line-36>
<line-37> have[j]-=cnt[j][i]</line-37>
<line-38> if not ok():</line-38>
<line-39> for j in range(len(pf)):</line-39>
<line-40> have[j]+=cnt[j][i]</line-40>
<line-41> break</line-41>
<line-42> pos=i</line-42>
<line-43>ans=n-pos+1</line-43>
<line-44>for x in range(n-1):</line-44>
<line-45> for j in range(len(pf)):</line-45>
<line-46> have[j]-=cnt[j][x]</line-46>
<line-47> if pos==(x+1):</line-47>
<line-48> for j in range(len(pf)):</line-48>
<line-49> have[j]+=cnt[j][pos]</line-49>
<line-50> pos+=1</line-50>
<line-51> while pos<n:</line-51>
<line-52> if ok():</line-52>
<line-53> break</line-53>
<line-54> else:</line-54>
<line-55> for i in range(len(pf)):</line-55>
<line-56> have[i]+=cnt[i][pos]</line-56>
<line-57> pos+=1</line-57>
<line-58> if ok():</line-58>
<line-59> ans+=n-pos+1</line-59>
<line-60> else:</line-60>
<line-62>print(ans)</line-62>
|
{"code": "<line-2>l=list(map(int,input().split()))</line-2>\n<line-61>\t\tbreak</line-61>", "lines": [2, 61]}
#### 0
|
<line-1>alpha = [chr(ord('a')+i) for i in range(26)]</line-1>
<line-3>s = input()</line-3>
<line-5></line-5>
<line-6>print('YES' if max(arr) <= k else 'NO')</line-6>
|
{"code": "<line-2>n,k = list(map(int,input().split()))</line-2>\n<line-4>arr = [s.count(alpha[i]) for i in range(26)]</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>mn = min(A)</line-3>
<line-4></line-4>
<line-5>I = [i for i in range(len(A)) if A[i] == mn]</line-5>
<line-7>print(mindiff)</line-7>
|
{"code": "<line-2>A = [int(x) for x in input().split()]</line-2>\n<line-6>mindiff = min(I[i]-I[i-1] for i in range(1,len(I)))</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>from fractions import gcd</line-1>
<line-2></line-2>
<line-4>per = w*b//gcd(w,b)</line-4>
<line-5>can = (t//per+1)*min(w,b)-1</line-5>
<line-6>if t%per<min(w,b):</line-6>
<line-7> can-=min(w,b)</line-7>
<line-8> can+=t%per+1</line-8>
<line-9>g = gcd(can,t)</line-9>
<line-10>can//=g</line-10>
<line-12>print(str(can)+"/"+str(t))</line-12>
|
{"code": "<line-3>t,w,b = map(int,input().split())</line-3>\n<line-11>t//=g</line-11>", "lines": [3, 11]}
#### 0
|
<line-1>x, y, z = map(int, input().split())</line-1>
<line-3> if x == y:</line-3>
<line-4> print('0')</line-4>
<line-5> elif x > y:</line-5>
<line-6> print('+')</line-6>
<line-7> else:</line-7>
<line-8> print('-')</line-8>
<line-9>else:</line-9>
<line-10> if x > y + z:</line-10>
<line-11> print('+') </line-11>
<line-12> elif x + z < y:</line-12>
<line-13> print('-')</line-13>
<line-15> print('?')</line-15>
|
{"code": "<line-2>if z == 0:</line-2>\n<line-14> else:</line-14>", "lines": [2, 14]}
#### 0
|
<line-1># </line-1>
<line-3></line-3>
<line-4>sys.setrecursionlimit(1000000)</line-4>
<line-5>def getIntList():</line-5>
<line-6> return list(map(int, input().split())) </line-6>
<line-7></line-7>
<line-8>try :</line-8>
<line-9> #raise ModuleNotFoundError</line-9>
<line-10> import numpy</line-10>
<line-11> def dprint(*args, **kwargs):</line-11>
<line-12> print(*args, **kwargs, file=sys.stderr)</line-12>
<line-13> dprint('debug mode')</line-13>
<line-14>except Exception:</line-14>
<line-15> def dprint(*args, **kwargs):</line-15>
<line-16> pass</line-16>
<line-17></line-17>
<line-18></line-18>
<line-19></line-19>
<line-20>inId = 0</line-20>
<line-21>outId = 0</line-21>
<line-22>if inId>0:</line-22>
<line-23> dprint('use input', inId)</line-23>
<line-24> sys.stdin = open('input'+ str(inId) + '.txt', 'r') #标准输出重定向至文件</line-24>
<line-25>if outId>0:</line-25>
<line-26> dprint('use output', outId)</line-26>
<line-27> sys.stdout = open('stdout'+ str(outId) + '.txt', 'w') #标准输出重定向至文件</line-27>
<line-28> atexit.register(lambda :sys.stdout.close()) #idle 中不会执行 atexit</line-28>
<line-29> </line-29>
<line-30>N, = getIntList()</line-30>
<line-31>#print(N)</line-31>
<line-32>S = input()</line-32>
<line-33></line-33>
<line-34>X, Y = getIntList()</line-34>
<line-35></line-35>
<line-36>dd = ( (0,1), (0,-1), (-1,0), (1,0))</line-36>
<line-37>pp = 'UDLR'</line-37>
<line-38>zz = {}</line-38>
<line-39>for i in range(4):</line-39>
<line-40> zz[ pp[i]] = dd[i]</line-40>
<line-41></line-41>
<line-42></line-42>
<line-43>if abs(X) + abs(Y) >N:</line-43>
<line-44> print(-1)</line-44>
<line-45> return</line-45>
<line-46></line-46>
<line-47>if abs(X+Y-N)%2==1:</line-47>
<line-48> print(-1)</line-48>
<line-49> return</line-49>
<line-50> </line-50>
<line-51>fromLeft = [None for i in range(N)]</line-51>
<line-52>fromRight = fromLeft.copy()</line-52>
<line-53></line-53>
<line-54>x0 = 0</line-54>
<line-55>y0 = 0</line-55>
<line-56>for i in range(N):</line-56>
<line-57> x = S[i]</line-57>
<line-58> fromLeft[i] = (x0,y0)</line-58>
<line-59> g = zz[x]</line-59>
<line-60> x0+= g[0]</line-60>
<line-61> y0+= g[1]</line-61>
<line-62></line-62>
<line-63>if x0==X and y0==Y:</line-63>
<line-64> print(0)</line-64>
<line-65> return</line-65>
<line-66></line-66>
<line-67>x0 = 0</line-67>
<line-68>y0 = 0</line-68>
<line-69>for i in range(N-1,-1,-1):</line-69>
<line-70> x = S[i]</line-70>
<line-71> fromRight[i] = (x0,y0)</line-71>
<line-72> g = zz[x]</line-72>
<line-73> x0+= g[0]</line-73>
<line-74> y0+= g[1]</line-74>
<line-75></line-75>
<line-76></line-76>
<line-77>up = N</line-77>
<line-78>down = 0</line-78>
<line-79>dprint(fromLeft)</line-79>
<line-80>dprint(fromRight)</line-80>
<line-81>while down+1<up:</line-81>
<line-82> mid = (up+down)//2</line-82>
<line-83> dprint('mid', mid)</line-83>
<line-84> ok = False</line-84>
<line-85> for i in range(N-mid + 1):</line-85>
<line-86> tx = fromLeft[i][0] + fromRight[i+mid-1][0]</line-86>
<line-87> ty = fromLeft[i][1] + fromRight[i+mid-1][1]</line-87>
<line-88> gg = abs(X-tx) + abs(Y- ty)</line-88>
<line-89> if gg <= mid:</line-89>
<line-90> ok = True</line-90>
<line-91> break</line-91>
<line-92> if ok:</line-92>
<line-93> up = mid</line-93>
<line-94> else:</line-94>
<line-96> </line-96>
<line-97>print(up)</line-97>
<line-98></line-98>
|
{"code": "<line-2>import collections, atexit, math, sys, bisect </line-2>\n<line-95> down = mid</line-95>", "lines": [2, 95]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n,x=map(int,input().split())</line-3>
<line-4> s=input()</line-4>
<line-5> L=[0]</line-5>
<line-6> for i in s:</line-6>
<line-7> if i=='0':L.append(L[-1]+1)</line-7>
<line-8> else:L.append(L[-1]-1)</line-8>
<line-9> L.pop(0)</line-9>
<line-10> k=L[-1]</line-10>
<line-11> c=0</line-11>
<line-12> if x==0:c+=1</line-12>
<line-13> if k>0:</line-13>
<line-14> for i in L:</line-14>
<line-15> if i%k==x%k and i<=x:c+=1</line-15>
<line-16> print(c)</line-16>
<line-17> elif k<0:</line-17>
<line-18> for i in L:</line-18>
<line-19> if i%k==x%k and i>=x:c+=1</line-19>
<line-20> print(c)</line-20>
<line-21> else:</line-21>
<line-22> for i in L:</line-22>
<line-24> print(c)</line-24>
|
{"code": "<line-2>for i in ' '*t:</line-2>\n<line-23> if i==x:c=-1</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>s = input().split()</line-1>
<line-3>s = s[0]</line-3>
<line-4>if s.count('0') < k:</line-4>
<line-5> if s.count('0') > 0:</line-5>
<line-6> print(len(s) - 1)</line-6>
<line-7> else:</line-7>
<line-8> print(len(s))</line-8>
<line-9> return</line-9>
<line-10>have = 0</line-10>
<line-11>its = 0</line-11>
<line-12>for i in range(len(s) - 1, -1, -1):</line-12>
<line-13> its += 1</line-13>
<line-14> if s[i] == '0':</line-14>
<line-15> have += 1</line-15>
<line-16> if have == k:</line-16>
<line-18> return</line-18>
|
{"code": "<line-2>k = int(s[1])</line-2>\n<line-17> print(its - have)</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>n, m, k, x, y = list(map(int, input().split()))</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>onebig = (2*n-2)*m or m</line-5>
<line-6></line-6>
<line-7>oo = k // onebig</line-7>
<line-8></line-8>
<line-9>for i in range(n):</line-9>
<line-10> for j in range(m):</line-10>
<line-11> if i == 0 or i == n-1:</line-11>
<line-12> ans[i][j] += oo</line-12>
<line-13> k -= oo</line-13>
<line-14> else:</line-14>
<line-15> ans[i][j] += 2*oo</line-15>
<line-16> k -= 2*oo</line-16>
<line-17></line-17>
<line-18>from itertools import chain</line-18>
<line-19></line-19>
<line-20>for i in chain(list(range(n)), list(range(n-2, 0, -1))):</line-20>
<line-21> if not k:</line-21>
<line-22> break</line-22>
<line-23> for j in range(m):</line-23>
<line-24> if not k:</line-24>
<line-25> break</line-25>
<line-26> ans[i][j] += 1</line-26>
<line-27> k -= 1</line-27>
<line-28></line-28>
<line-29>_max = max(list(map(max, ans)))</line-29>
<line-30>_min = min(list(map(min, ans)))</line-30>
<line-32></line-32>
<line-33></line-33>
<line-34>print(_max, _min, _ans)</line-34>
|
{"code": "<line-3>ans = [[0] * m for x in range(n)]</line-3>\n<line-31>_ans = ans[x-1][y-1]</line-31>", "lines": [3, 31]}
#### 0
|
<line-1>turns = int(input())</line-1>
<line-3>s1 = input()</line-3>
<line-4>s2 = input()</line-4>
<line-5></line-5>
<line-6>d0 = dict()</line-6>
<line-7>d1 = dict()</line-7>
<line-8>d2 = dict()</line-8>
<line-9></line-9>
<line-10>alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'</line-10>
<line-11>for char in alphabet:</line-11>
<line-12> d0[char] = 0</line-12>
<line-13> d1[char] = 0</line-13>
<line-14> d2[char] = 0</line-14>
<line-15></line-15>
<line-16>for char in s0:</line-16>
<line-17> d0[char] += 1</line-17>
<line-18>for char in s1:</line-18>
<line-19> d1[char] += 1</line-19>
<line-20>for char in s2:</line-20>
<line-21> d2[char] += 1 </line-21>
<line-22></line-22>
<line-23>m0 = max([d0[char] for char in alphabet])</line-23>
<line-24>m1 = max([d1[char] for char in alphabet])</line-24>
<line-25>m2 = max([d2[char] for char in alphabet])</line-25>
<line-26></line-26>
<line-27>l0 = len(s0)</line-27>
<line-28>l1 = len(s1)</line-28>
<line-29>l2 = len(s2)</line-29>
<line-30></line-30>
<line-31>if turns == 1 and m0 == l0:</line-31>
<line-32> score0 = m0 - 1</line-32>
<line-33>else:</line-33>
<line-34> score0 = min(l0,m0+turns)</line-34>
<line-35></line-35>
<line-36>if turns == 1 and m1 == l1:</line-36>
<line-37> score1 = m1 - 1</line-37>
<line-38>else:</line-38>
<line-39> score1 = min(l1,m1+turns)</line-39>
<line-40></line-40>
<line-41>if turns == 1 and m2 == l2:</line-41>
<line-42> score2 = m2 - 1</line-42>
<line-43>else:</line-43>
<line-44> score2 = min(l2,m2+turns)</line-44>
<line-45> </line-45>
<line-46>scores = [score0,score1,score2]</line-46>
<line-47>bestscore = max(scores)</line-47>
<line-48></line-48>
<line-49>winnerlist = [i for i in range(3) if scores[i] == bestscore]</line-49>
<line-50>if len(winnerlist) > 1:</line-50>
<line-51> print('Draw')</line-51>
<line-53> print(['Kuro','Shiro','Katie'][winnerlist[0]])</line-53>
|
{"code": "<line-2>s0 = input()</line-2>\n<line-52>else:</line-52>", "lines": [2, 52]}
#### 0
|
<line-1>read = lambda: map(int, input().split())</line-1>
<line-3>cur = 0</line-3>
<line-4>cnt = 0</line-4>
<line-5>while cur < c:</line-5>
<line-6> cur = max(0, cur - l)</line-6>
<line-7> cur += min(v1, v0 + a * cnt)</line-7>
<line-9>print(cnt)</line-9>
|
{"code": "<line-2>c, v0, v1, a, l = read()</line-2>\n<line-8> cnt += 1</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>import math</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>def prime(p):</line-5>
<line-6> if p == 1:</line-6>
<line-7> return False</line-7>
<line-8> fl=True</line-8>
<line-9> for i in range(2,math.ceil(p**0.5) + 1):</line-9>
<line-10> if p % i == 0:</line-10>
<line-11> fl=False</line-11>
<line-12> return fl</line-12>
<line-13></line-13>
<line-14>def sum_of_primes(k):</line-14>
<line-15> fl=True</line-15>
<line-16> for i in range((k // 2) + 1):</line-16>
<line-17> if prime(i) and prime(k-i):</line-17>
<line-18> fl=True</line-18>
<line-19> break</line-19>
<line-20> return fl</line-20>
<line-21></line-21>
<line-22>if prime(n):</line-22>
<line-23> print(1)</line-23>
<line-24> print(n)</line-24>
<line-25>else:</line-25>
<line-26> if prime(n-2):</line-26>
<line-27> print(2)</line-27>
<line-28> print(2 , n-2)</line-28>
<line-29> else:</line-29>
<line-30> l=1</line-30>
<line-31> for i in range(2, (n // 3) + 1):</line-31>
<line-32> if prime(i) and sum_of_primes(n - i):</line-32>
<line-33> l=i</line-33>
<line-34> break</line-34>
<line-35> print(3)</line-35>
<line-36> r=1</line-36>
<line-37> for k in range((n-l) // 2):</line-37>
<line-38> if prime(k) and prime(n-l-k):</line-38>
<line-39> r=k</line-39>
<line-41> print(l,r,n-l-r)</line-41>
<line-42></line-42>
<line-43> </line-43>
|
{"code": "<line-3>n=int(input())</line-3>\n<line-40> break</line-40>", "lines": [3, 40]}
#### 0
|
<line-1>n, m = list(map(int, input().split()))</line-1>
<line-3>ans = 0</line-3>
<line-4>for i in range(n):</line-4>
<line-5> s = input()</line-5>
<line-6> ans += s.count('*')</line-6>
<line-7> p.append(s)</line-7>
<line-8>dp = []</line-8>
<line-9>for i in range(n):</line-9>
<line-10> dp.append([0] * m)</line-10>
<line-11>for i in range(n):</line-11>
<line-12> col = p[i].count('*')</line-12>
<line-13> for t in range(m):</line-13>
<line-14> dp[i][t] = col</line-14>
<line-15>for i in range(m):</line-15>
<line-16> col = 0</line-16>
<line-17> for t in range(n):</line-17>
<line-18> if p[t][i] == '*':</line-18>
<line-19> col += 1</line-19>
<line-20> for t in range(n):</line-20>
<line-21> dp[t][i] += col</line-21>
<line-22>f = False</line-22>
<line-23>for i in range(n):</line-23>
<line-24> for t in range(m):</line-24>
<line-25> if dp[i][t] - int(p[i][t] == '*') == ans:</line-25>
<line-26> f = True</line-26>
<line-27> print('YES')</line-27>
<line-28> print(i + 1, t + 1)</line-28>
<line-29> break</line-29>
<line-30> if f:</line-30>
<line-31> break</line-31>
<line-33> print('NO')</line-33>
|
{"code": "<line-2>p = []</line-2>\n<line-32>if not f:</line-32>", "lines": [2, 32]}
#### 0
|
<line-2></line-2>
<line-3>k = n%m</line-3>
<line-4>print(min(k*b, (m - k)*a))</line-4>
|
{"code": "<line-1>n, m, a, b = list(map(int, input().split()))</line-1>", "lines": [1]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>res = 0</line-3>
<line-4>new_a = []</line-4>
<line-5>for i in range(n):</line-5>
<line-6> if a[i] % 2 == 0:</line-6>
<line-7> if a[i] > 0:</line-7>
<line-8> res += a[i]</line-8>
<line-9> else:</line-9>
<line-10> new_a.append(a[i])</line-10>
<line-11>a = new_a</line-11>
<line-12>a.sort()</line-12>
<line-13>res += a[-1]</line-13>
<line-14>a.pop()</line-14>
<line-15>while len(a) > 1:</line-15>
<line-16> if a[-1] + a[-2] > 0:</line-16>
<line-17> res += a[-1] + a[-2]</line-17>
<line-18> a.pop()</line-18>
<line-19> a.pop()</line-19>
<line-20> else:</line-20>
<line-22>print(res)</line-22>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-21> break</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>from math import factorial</line-1>
<line-2></line-2>
<line-3></line-3>
<line-5> if n == 1:</line-5>
<line-6> yield [0]</line-6>
<line-7> yield [1]</line-7>
<line-8> else:</line-8>
<line-9> for p in lol(n - 1):</line-9>
<line-10> p.append(0)</line-10>
<line-11> yield p</line-11>
<line-12> p[-1] = 1</line-12>
<line-13> yield p</line-13>
<line-14> p.pop()</line-14>
<line-15></line-15>
<line-16></line-16>
<line-17>def sp(g1, g2, g3, f):</line-17>
<line-18> if g1 == 0:</line-18>
<line-19> if g2 == g3:</line-19>
<line-20> return 2</line-20>
<line-21> elif abs(g2 - g3) == 1:</line-21>
<line-22> return 1</line-22>
<line-23> else:</line-23>
<line-24> return 0</line-24>
<line-25> elif g2 == 0:</line-25>
<line-26> if g1 == g3:</line-26>
<line-27> return 2</line-27>
<line-28> elif abs(g1 - g3) == 1:</line-28>
<line-29> return 1</line-29>
<line-30> else:</line-30>
<line-31> return 0</line-31>
<line-32> elif g3 == 0:</line-32>
<line-33> if g2 == g1:</line-33>
<line-34> return 2</line-34>
<line-35> elif abs(g2 - g1) == 1:</line-35>
<line-36> return 1</line-36>
<line-37> else:</line-37>
<line-38> return 0</line-38>
<line-39> else:</line-39>
<line-40> if f == 1:</line-40>
<line-41> b = sp(g1, g2 - 1, g3, 2)</line-41>
<line-42> c = sp(g1, g2, g3 - 1, 3)</line-42>
<line-43> return b + c</line-43>
<line-44> elif f == 2:</line-44>
<line-45> a = sp(g1 - 1, g2, g3, 1)</line-45>
<line-46> c = sp(g1, g2, g3 - 1, 3)</line-46>
<line-47> return a + c</line-47>
<line-48> elif f == 3:</line-48>
<line-49> a = sp(g1 - 1, g2, g3, 1)</line-49>
<line-50> b = sp(g1, g2 - 1, g3, 2)</line-50>
<line-51> return a + b</line-51>
<line-52> else:</line-52>
<line-53> a = sp(g1 - 1, g2, g3, 1)</line-53>
<line-54> b = sp(g1, g2 - 1, g3, 2)</line-54>
<line-55> c = sp(g1, g2, g3 - 1, 3)</line-55>
<line-56> return a + b + c</line-56>
<line-57></line-57>
<line-58></line-58>
<line-59>n, T = map(int, input().split())</line-59>
<line-60>S = []</line-60>
<line-61>cnt = 0</line-61>
<line-62>M = 10 ** 9 + 7</line-62>
<line-63>for i in range(n):</line-63>
<line-64> S.append(list(map(int, input().split())))</line-64>
<line-65>for p in lol(n):</line-65>
<line-66> d = 0</line-66>
<line-67> g1, g2, g3 = 0, 0, 0</line-67>
<line-68> for i in range(n):</line-68>
<line-69> if p[i]:</line-69>
<line-70> d += S[i][0]</line-70>
<line-71> if S[i][1] == 1:</line-71>
<line-72> g1 += 1</line-72>
<line-73> elif S[i][1] == 2:</line-73>
<line-74> g2 += 1</line-74>
<line-75> elif S[i][1] == 3:</line-75>
<line-76> g3 += 1</line-76>
<line-77> if d == T:</line-77>
<line-78> cnt += factorial(g1) * factorial(g2) * factorial(g3) * sp(g1, g2, g3, 0)</line-78>
<line-80>print(cnt)</line-80>
|
{"code": "<line-4>def lol(n):</line-4>\n<line-79> cnt %= M</line-79>", "lines": [4, 79]}
#### 0
|
<line-1>big = 100010</line-1>
<line-3> mu = [1]*big</line-3>
<line-4> mu[0] = 0</line-4>
<line-5> P = [True]*big</line-5>
<line-6> P[0] = P[1] = False</line-6>
<line-7> for i in range(2,big):</line-7>
<line-8> if P[i]:</line-8>
<line-9> j = i</line-9>
<line-10> while j<big:</line-10>
<line-11> P[j] = False</line-11>
<line-12> mu[j] *= -1</line-12>
<line-13> j += i</line-13>
<line-14> j = i*i</line-14>
<line-15> while j<big:</line-15>
<line-16> mu[j] = 0</line-16>
<line-17> j += i*i</line-17>
<line-18> return mu</line-18>
<line-19></line-19>
<line-20>m = int(input())</line-20>
<line-21>mu = gen_mu()</line-21>
<line-22></line-22>
<line-23>MOD = 10**9+7</line-23>
<line-24>def mod_inv(x):</line-24>
<line-25> return pow(x, MOD-2, MOD)</line-25>
<line-26></line-26>
<line-27>s = 1</line-27>
<line-28>for i in range(2,big):</line-28>
<line-29> # p is probabilty that i | a random number [1,m]</line-29>
<line-30> p = (m//i)*mod_inv(m)</line-30>
<line-32>print(s%MOD)</line-32>
|
{"code": "<line-2>def gen_mu():</line-2>\n<line-31> s += (-mu[i])*(p)*mod_inv(1-p)</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>from math import sqrt</line-1>
<line-3>l, r, x, y = list(map(int, input().split()))</line-3>
<line-4>if y % x != 0:</line-4>
<line-5> print(0)</line-5>
<line-6> return</line-6>
<line-7>lo = (l + x - 1) // x</line-7>
<line-8>hi = r // x</line-8>
<line-9>p = y // x</line-9>
<line-10>s = 0</line-10>
<line-11></line-11>
<line-12>k1 = 1</line-12>
<line-13>while k1 * k1 <= p:</line-13>
<line-14> k2 = p // k1</line-14>
<line-15> if lo <= k1 <= hi and lo <= k2 <= hi and gcd(k1, k2) == 1 and k1 * k2 == p:</line-15>
<line-16> s += 1 + (k1 != k2)</line-16>
<line-18>print(s)</line-18>
|
{"code": "<line-2>from fractions import gcd</line-2>\n<line-17> k1 += 1</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>from math import gcd</line-1>
<line-3>if b < a:</line-3>
<line-4> a, b = b, a</line-4>
<line-5>if a == b:</line-5>
<line-6> print(0)</line-6>
<line-7> return</line-7>
<line-8>c = b - a</line-8>
<line-9>i = 1</line-9>
<line-10>ans = a * b // gcd(a, b)</line-10>
<line-11></line-11>
<line-12>def get(x):</line-12>
<line-13> A = (a + x - 1) // x * x</line-13>
<line-14> B = A - a + b</line-14>
<line-15> return A * B // gcd(A, B), A</line-15>
<line-16></line-16>
<line-17>r = 0</line-17>
<line-18>while i * i <= c:</line-18>
<line-19> if c % i == 0:</line-19>
<line-20> A, AA = get(i)</line-20>
<line-21> B, BB = get(c // i)</line-21>
<line-22> if A < ans:</line-22>
<line-23> ans = A</line-23>
<line-24> r = AA - a</line-24>
<line-25> if B < ans:</line-25>
<line-26> ans = B</line-26>
<line-27> r = BB - a</line-27>
<line-28> if A == ans:</line-28>
<line-29> r = min(r, AA - a)</line-29>
<line-30> if B == ans:</line-30>
<line-31> r = min(r, BB - a)</line-31>
<line-33>print(r)</line-33>
|
{"code": "<line-2>a, b = list(map(int, input().split()))</line-2>\n<line-32> i += 1</line-32>", "lines": [2, 32]}
#### 0
|
<line-1>n, k = list(map(int, input().split()))</line-1>
<line-3>s = sum(a)</line-3>
<line-4>ans = 0</line-4>
<line-5>c = k - 0.5</line-5>
<line-6>while s / n < c:</line-6>
<line-7> s += k</line-7>
<line-8> n += 1</line-8>
<line-10>print(ans)</line-10>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-9> ans += 1</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>pos=0</line-3>
<line-4>neg=0</line-4>
<line-5>for a in ar:</line-5>
<line-6> if(a>0):pos+=1</line-6>
<line-7> elif a<0:neg+=1</line-7>
<line-8>if(pos*2>=n):</line-8>
<line-9> print(1)</line-9>
<line-10>elif neg*2>=n:</line-10>
<line-11> print(-1)</line-11>
<line-13> print(0)</line-13>
|
{"code": "<line-2>ar=list(map(int,input().split()))</line-2>\n<line-12>else:</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>from sys import stdin as cin</line-1>
<line-3></line-3>
<line-4>def main():</line-4>
<line-5> n = int(cin.readline())</line-5>
<line-6> o = 0</line-6>
<line-7> for x in range(9, 0, -1):</line-7>
<line-8> if 10 ** x // 2 <= n:</line-8>
<line-9> ##print(x)</line-9>
<line-10> for i in range(9):</line-10>
<line-11> q = 10 ** x * (i + 1) // 2 - 1</line-11>
<line-12> if q <= n:</line-12>
<line-13> o += min(q, n - q)</line-13>
<line-14> print(o)</line-14>
<line-15> return</line-15>
<line-17></line-17>
<line-18>main()</line-18>
|
{"code": "<line-2>from sys import stdout as cout</line-2>\n<line-16> print(n * (n - 1) // 2)</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>a,b=list(map(int,input().split()))</line-1>
<line-3>e=a*b</line-3>
<line-4>f=c*d</line-4>
<line-5>n=0</line-5>
<line-6>while e%2==0:e=e//2</line-6>
<line-7>while e%3==0:e=e//3</line-7>
<line-8>while f%2==0:f=f//2</line-8>
<line-9>while f%3==0:f=f//3</line-9>
<line-10>if e!=f:print("-1")</line-10>
<line-11>else:</line-11>
<line-12> i=0</line-12>
<line-13> j=0</line-13>
<line-14> e=a*b</line-14>
<line-15> f=c*d</line-15>
<line-16> while e%3==0:</line-16>
<line-17> e=e//3</line-17>
<line-18> i+=1</line-18>
<line-19> while f%3==0:</line-19>
<line-20> f=f//3</line-20>
<line-21> j+=1</line-21>
<line-22> k=i-j</line-22>
<line-23> if k>0:</line-23>
<line-24> for i in range(k):</line-24>
<line-25> n+=1</line-25>
<line-26> if a%3==0:a=a*2//3</line-26>
<line-27> else:b=b*2//3</line-27>
<line-28> else:</line-28>
<line-29> for i in range(0-k):</line-29>
<line-30> n+=1</line-30>
<line-31> if c%3==0:c=c*2//3</line-31>
<line-32> else:d=d*2//3</line-32>
<line-33> e=a*b</line-33>
<line-34> f=c*d</line-34>
<line-35> i=0</line-35>
<line-36> j=0</line-36>
<line-37> while e%2==0:</line-37>
<line-38> e=e//2</line-38>
<line-39> i+=1</line-39>
<line-40> while f%2==0:</line-40>
<line-41> f=f//2</line-41>
<line-42> j+=1</line-42>
<line-43> k=i-j</line-43>
<line-44> if k>0:</line-44>
<line-45> for i in range(k):</line-45>
<line-46> n+=1</line-46>
<line-47> if a%2==0:a=a//2</line-47>
<line-48> else:b=b//2</line-48>
<line-49> else:</line-49>
<line-50> for i in range(0-k):</line-50>
<line-51> n+=1</line-51>
<line-52> if c%2==0:c=c//2</line-52>
<line-53> else:d=d//2</line-53>
<line-54> print(n)</line-54>
<line-56> print(c,d)</line-56>
|
{"code": "<line-2>c,d=list(map(int,input().split()))</line-2>\n<line-55> print(a,b)</line-55>", "lines": [2, 55]}
#### 0
|
<line-1>a, b, x, y = map(int, input().split())</line-1>
<line-3> if b >= y:</line-3>
<line-4> print('Vasiliy')</line-4>
<line-5> else:</line-5>
<line-6> z = y - b</line-6>
<line-7> t = max(x - z, 0)</line-7>
<line-8> if a - z <= t:</line-8>
<line-9> print('Polycarp')</line-9>
<line-10> else:</line-10>
<line-11> print('Vasiliy')</line-11>
<line-12>else:</line-12>
<line-13> if b <= y:</line-13>
<line-14> print('Polycarp')</line-14>
<line-15> else:</line-15>
<line-16> z = x - a</line-16>
<line-17> t = max(y - z, 0)</line-17>
<line-18> if b - z <= t:</line-18>
<line-19> print('Polycarp')</line-19>
<line-21> print('Vasiliy')</line-21>
|
{"code": "<line-2>if a >= x:</line-2>\n<line-20> else:</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>import sys</line-1>
<line-3>a, b = list(map(int, input().split()))</line-3>
<line-4>a -= 1</line-4>
<line-5>b -= 1</line-5>
<line-6>ctr = 1</line-6>
<line-7>for i in range(arr[a] - 1):</line-7>
<line-8> b += 1</line-8>
<line-9> if (b == 7):</line-9>
<line-10> b = 0</line-10>
<line-12>print(ctr)</line-12>
<line-13> </line-13>
|
{"code": "<line-2>arr = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]</line-2>\n<line-11> ctr += 1</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>def zero(strx):</line-1>
<line-3> str2 = list(strx)</line-3>
<line-4> for i in range(1, len(str2)):</line-4>
<line-5> str3 = str2[:]</line-5>
<line-6> str3[i] = '0'</line-6>
<line-7> k.append(''.join(str3))</line-7>
<line-8> return k</line-8>
<line-9>a = []</line-9>
<line-10>for i in range(1, 64):</line-10>
<line-11> a += zero('1'*i)</line-11>
<line-12></line-12>
<line-13>ct = 0</line-13>
<line-14>x, y = list(map(int, input().split(' ')))</line-14>
<line-15>for i in a:</line-15>
<line-16> if x <= int(i, 2) <= y:</line-16>
<line-18>print(ct)</line-18>
|
{"code": "<line-2> k = []</line-2>\n<line-17> ct+=1</line-17>", "lines": [2, 17]}
#### 0
|
<line-2>print(max((i+1)*(n-i)for i in range(n)))</line-2>
|
{"code": "<line-1>n=int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>fact = [ 1 ]</line-1>
<line-3> fact.append( fact[ i - 1 ] * i )</line-3>
<line-4></line-4>
<line-5>from collections import defaultdict</line-5>
<line-6></line-6>
<line-7>N, K, S = list(map( int, input().split() ))</line-7>
<line-8>A = list( map( int, input().split() ) )</line-8>
<line-9></line-9>
<line-10>ldp = [ [ defaultdict( int ) for i in range( K + 1 ) ] for j in range( 2 ) ]</line-10>
<line-11>ldp[ 0 ][ 0 ][ 0 ] = 1</line-11>
<line-12>for i in range( N // 2 ):</line-12>
<line-13> for j in range( K + 1 ):</line-13>
<line-14> ldp[ ~ i & 1 ][ j ].clear()</line-14>
<line-15> for j in range( K + 1 ):</line-15>
<line-16> for key in ldp[ i & 1 ][ j ]:</line-16>
<line-17> ldp[ ~ i & 1 ][ j ][ key ] += ldp[ i & 1 ][ j ][ key ] # toranai</line-17>
<line-18> ldp[ ~ i & 1 ][ j ][ key + A[ i ] ] += ldp[ i & 1 ][ j ][ key ] # toru</line-18>
<line-19> if j + 1 <= K and A[ i ] <= 18:</line-19>
<line-20> ldp[ ~ i & 1 ][ j + 1 ][ key + fact[ A[ i ] ] ] += ldp[ i & 1 ][ j ][ key ] # kaijyou totte toru</line-20>
<line-21></line-21>
<line-22>rdp = [ [ defaultdict( int ) for i in range( K + 1 ) ] for j in range( 2 ) ]</line-22>
<line-23>rdp[ 0 ][ 0 ][ 0 ] = 1</line-23>
<line-24>for i in range( N - N // 2 ):</line-24>
<line-25> for j in range( K + 1 ):</line-25>
<line-26> rdp[ ~ i & 1 ][ j ].clear()</line-26>
<line-27> for j in range( K + 1 ):</line-27>
<line-28> for key in rdp[ i & 1 ][ j ]:</line-28>
<line-29> rdp[ ~ i & 1 ][ j ][ key ] += rdp[ i & 1 ][ j ][ key ]</line-29>
<line-30> rdp[ ~ i & 1 ][ j ][ key + A[ N // 2 + i ] ] += rdp[ i & 1 ][ j ][ key ]</line-30>
<line-31> if j + 1 <= K and A[ N // 2 + i ] <= 18:</line-31>
<line-32> rdp[ ~ i & 1 ][ j + 1 ][ key + fact[ A[ N // 2 + i ] ] ] += rdp[ i & 1 ][ j ][ key ]</line-32>
<line-33></line-33>
<line-34>ans = 0</line-34>
<line-35>for i in range( K + 1 ):</line-35>
<line-36> for key in ldp[ N // 2 & 1 ][ i ]:</line-36>
<line-37> for j in range( 0, K - i + 1, 1 ):</line-37>
<line-39></line-39>
<line-40>print( ans )</line-40>
|
{"code": "<line-2>for i in range( 1, 20, 1 ):</line-2>\n<line-38> ans += ldp[ N // 2 & 1 ][ i ][ key ] * rdp[ N - N // 2 & 1 ][ j ][ S - key ]</line-38>", "lines": [2, 38]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> n,k = list(map(int,input().split()))</line-3>
<line-4> a = list(map(int,input().split()))</line-4>
<line-5> for i in range(60, -1, -1):</line-5>
<line-6> m = k ** i</line-6>
<line-7> for j in range(n):</line-7>
<line-8> if a[j] >= m:</line-8>
<line-9> a[j] -= m</line-9>
<line-10> break</line-10>
<line-11> if all(i == 0 for i in a):</line-11>
<line-12> print('YES')</line-12>
<line-14> print('NO')</line-14>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-13> else:</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>a, b, c = map(int, input().split())</line-1>
<line-3>p = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]</line-3>
<line-4>t = [{} for i in range(101)]</line-4>
<line-5>ans = {}</line-5>
<line-6>for i in p:</line-6>
<line-7> j = i</line-7>
<line-8> m = 1</line-8>
<line-9> while j < 101:</line-9>
<line-10> for k in range(j, 101, j):</line-10>
<line-11> t[k][i] = m</line-11>
<line-12> j = j * i</line-12>
<line-13> m += 1</line-13>
<line-14>s = 0</line-14>
<line-15>for i in range(1, a + 1):</line-15>
<line-16> for j in range(1, b + 1):</line-16>
<line-17> q = {}</line-17>
<line-18> for x in t[i].keys() | t[j].keys():</line-18>
<line-19> q[x] = t[i].get(x, 0) + t[j].get(x, 0)</line-19>
<line-20> ij = i * j</line-20>
<line-21> for k in range(1, c + 1):</line-21>
<line-22> ijk = ij * k</line-22>
<line-23> if ijk in ans: s += ans[ijk]</line-23>
<line-24> else:</line-24>
<line-25> y = 1</line-25>
<line-26> for x in q.keys() | t[k].keys():</line-26>
<line-27> y = y * (q.get(x, 0) + t[k].get(x, 0) + 1)</line-27>
<line-28> ans[ijk] = y</line-28>
<line-30></line-30>
<line-31>print(s)</line-31>
|
{"code": "<line-2>d = 1073741824</line-2>\n<line-29> s += y</line-29>", "lines": [2, 29]}
#### 0
|
<line-1>a, b, c, d = input(), input(), input(), input()</line-1>
<line-3>x = "X"</line-3>
<line-4>for i in range(4):</line-4>
<line-5> if a[i] == x:</line-5>
<line-6> a = a[:i] + a[i + 1:]</line-6>
<line-7> break</line-7>
<line-8>c = c + d[::-1]</line-8>
<line-9></line-9>
<line-10>for i in range(4):</line-10>
<line-11> if c[i] == x:</line-11>
<line-12> c = c[:i] + c[i + 1:]</line-12>
<line-13> break</line-13>
<line-14>flag = False</line-14>
<line-15>for i in range(4):</line-15>
<line-16> if a == c:</line-16>
<line-17> flag = True</line-17>
<line-18> c = c[1:] + c[0]</line-18>
<line-19>if flag:</line-19>
<line-20> print("YES")</line-20>
<line-22> print("NO")</line-22>
|
{"code": "<line-2>a = a + b[::-1]</line-2>\n<line-21>else:</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>pw=[1]</line-3>
<line-4>last=1</line-4>
<line-5>for i in range(70):</line-5>
<line-6> if (last>1e19):</line-6>
<line-7> break</line-7>
<line-8> pw.append(last*n)</line-8>
<line-9> last=last*n</line-9>
<line-10>dp=[1e19]*100</line-10>
<line-11>for i in range(100):</line-11>
<line-12> dp[i]=[1e19]*100</line-12>
<line-13>dp[len(s)][0]=0</line-13>
<line-14>for i in range(len(s),-1,-1):</line-14>
<line-15> for power in range(0,len(pw)):</line-15>
<line-16> cur=''</line-16>
<line-17> for j in range(i-1,-1,-1):</line-17>
<line-18> cur=s[j]+cur</line-18>
<line-19> if (int(cur)>n or int(cur)*pw[power]>1e19):</line-19>
<line-20> break;</line-20>
<line-21> if ((cur[0]!='0' or len(cur)==1) and int(cur)<n):</line-21>
<line-23>print(min(dp[0]))</line-23>
|
{"code": "<line-2>s=input()</line-2>\n<line-22> dp[j][power+1]=min(dp[j][power+1],dp[i][power]+int(cur)*pw[power])</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>i = 0</line-3>
<line-4>a = 0</line-4>
<line-5>while i < n and L[i] > a:</line-5>
<line-6> a = L[i]</line-6>
<line-7> i += 1</line-7>
<line-8>while i < n and L[i] == a:</line-8>
<line-9> i += 1</line-9>
<line-10>while i < n and L[i] < a:</line-10>
<line-11> a = L[i]</line-11>
<line-12> i += 1</line-12>
<line-13>if i == n:</line-13>
<line-14> print("YES")</line-14>
<line-16> print("NO")</line-16>
|
{"code": "<line-2>L = list(map(int, input().split()))</line-2>\n<line-15>else:</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>def gg(n,lol):</line-1>
<line-3> cur = 1</line-3>
<line-4> lol2 = lol</line-4>
<line-5> while(2*lol+1<=n):</line-5>
<line-6> cur *= 2</line-6>
<line-7> ans += cur</line-7>
<line-8> lol = 2*lol+1</line-8>
<line-9> lol2 *= 2</line-9>
<line-10> if lol2*2 <= n:</line-10>
<line-11> ans += n-lol2*2+1 </line-11>
<line-12> return ans</line-12>
<line-13></line-13>
<line-14>n,k = list(map(int,input().split()))</line-14>
<line-15>low = 1</line-15>
<line-16>high = n//2</line-16>
<line-17>res = 1</line-17>
<line-18>while low <= high:</line-18>
<line-19> mid = (low+high)//2</line-19>
<line-20> if gg(n,mid) >= k:</line-20>
<line-21> res = mid</line-21>
<line-22> low = mid+1</line-22>
<line-23> else:</line-23>
<line-24> high = mid-1</line-24>
<line-25>if n == k:</line-25>
<line-26> print(1)</line-26>
<line-27>elif(gg(n,res)-1-gg(n,res*2) >= k):</line-27>
<line-28> print(res*2+1)</line-28>
<line-30> print(res*2) </line-30>
|
{"code": "<line-2>\tans = 0</line-2>\n<line-29>else:</line-29>", "lines": [2, 29]}
#### 0
|
<line-1>def INV(a, m) :</line-1>
<line-3> y = 0</line-3>
<line-4> x = 1 </line-4>
<line-5> if (m == 1) :</line-5>
<line-6> return 0 </line-6>
<line-7> while (a > 1) : </line-7>
<line-8> q = a // m </line-8>
<line-9> t = m </line-9>
<line-10> m = a % m</line-10>
<line-11> a = t</line-11>
<line-12> t = y </line-12>
<line-13> y = x - q * y</line-13>
<line-14> x = t</line-14>
<line-15> if (x < 0) :</line-15>
<line-16> x = x + m0 </line-16>
<line-17> return x</line-17>
<line-18>def GCD(a, b):</line-18>
<line-19> if a == 0: return b</line-19>
<line-20> return GCD(b%a,a)</line-20>
<line-21>def solve():</line-21>
<line-22> n, m, x, y, vx, vy = list(map(int, input().split()))</line-22>
<line-23> if vx == 0:</line-23>
<line-24> if x != 0 and x != n:</line-24>
<line-25> print("-1")</line-25>
<line-26> return 0</line-26>
<line-27> ans = [0,0]</line-27>
<line-28> ans[0] = x</line-28>
<line-29> if vy < 0: ans[1] = 0</line-29>
<line-30> else: ans[1] = m</line-30>
<line-31> print(ans[0],ans[1])</line-31>
<line-32> return 0</line-32>
<line-33> if vy == 0:</line-33>
<line-34> if y != 0 and y != m:</line-34>
<line-35> print("-1")</line-35>
<line-36> return 0</line-36>
<line-37> ans = [0,0]</line-37>
<line-38> ans[1] = y</line-38>
<line-39> if vx < 0: ans[0] = 0</line-39>
<line-40> else: ans[0] = n</line-40>
<line-41> print(ans[0],ans[1])</line-41>
<line-42> return 0</line-42>
<line-43> if vx == -1 and x == 0: vx = 1</line-43>
<line-44> if vx == 1 and x == n: vx = -1</line-44>
<line-45> if vy == -1 and y == 0: vy = 1</line-45>
<line-46> if vy == 1 and y == m: vy = -1</line-46>
<line-47> g = GCD(n,m)</line-47>
<line-48> m1 = n</line-48>
<line-49> m2 = m</line-49>
<line-50> a1 = -1 * vx * x % m1</line-50>
<line-51> a2 = -1 * vy * y % m2</line-51>
<line-52> if a1 % g != a2 % g:</line-52>
<line-53> print("-1")</line-53>
<line-54> return 0</line-54>
<line-55> if GCD(m1//g,m2) == 1:</line-55>
<line-56> m1 = m1 // g</line-56>
<line-57> else:</line-57>
<line-58> m2 = m2 // g</line-58>
<line-59> m1_bar = INV(m2,m1)</line-59>
<line-60> m2_bar = INV(m1,m2)</line-60>
<line-61> k = (a1 * m1_bar*m2 + a2 * m2_bar*m1) % (m1*m2)</line-61>
<line-62> rowtouch = ((k+m-1)//m) % 2</line-62>
<line-63> coltouch = ((k+n-1)//n) % 2</line-63>
<line-64> ans = [0,0]</line-64>
<line-65> if vx == 1: ans[0] = 0</line-65>
<line-66> else: ans[0] = n</line-66>
<line-67> if vy == 1: ans[1] = 0</line-67>
<line-68> else: ans[1] = m</line-68>
<line-69> if rowtouch == 1: ans[1] = m-ans[1]</line-69>
<line-70> if coltouch == 1: ans[0] = n-ans[0]</line-70>
<line-71> print(ans[0],ans[1])</line-71>
<line-73>solve()</line-73>
|
{"code": "<line-2> m0 = m</line-2>\n<line-72> return 0</line-72>", "lines": [2, 72]}
#### 0
|
<line-1>a, b = [int(i) for i in input().split()]</line-1>
<line-3>e, f = [int(i) for i in input().split()]</line-3>
<line-4>if c+e <=a and max(d,f) <=b:</line-4>
<line-5> print("YES")</line-5>
<line-6>elif c+e <=b and max(d,f) <=a:</line-6>
<line-7> print("YES")</line-7>
<line-8>elif c+f <=a and max(d,e) <=b:</line-8>
<line-9> print("YES")</line-9>
<line-10>elif c+f <=b and max(d,e) <=a:</line-10>
<line-11> print("YES")</line-11>
<line-12>elif d+e <=a and max(c,f) <=b:</line-12>
<line-13> print("YES")</line-13>
<line-14>elif d+e <=b and max(c,f) <=a:</line-14>
<line-15> print("YES")</line-15>
<line-16>elif d+f <=a and max(c,e) <=b:</line-16>
<line-17> print("YES")</line-17>
<line-18>elif d+f <=b and max(c,e) <=a:</line-18>
<line-19> print("YES")</line-19>
<line-21> print("NO")</line-21>
|
{"code": "<line-2>c, d = [int(i) for i in input().split()]</line-2>\n<line-20>else:</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>def main():</line-1>
<line-3> a = set(map(int, input().split()))</line-3>
<line-4> if abs(b1) > l:</line-4>
<line-5> print(0)</line-5>
<line-6> else:</line-6>
<line-7> if b1 == 0:</line-7>
<line-8> if 0 in a:</line-8>
<line-9> print(0)</line-9>
<line-10> else:</line-10>
<line-11> print("inf")</line-11>
<line-12> elif q == 0:</line-12>
<line-13> if 0 not in a:</line-13>
<line-14> print("inf")</line-14>
<line-15> elif b1 in a:</line-15>
<line-16> print(0)</line-16>
<line-17> else:</line-17>
<line-18> print(1)</line-18>
<line-19> elif q == 1:</line-19>
<line-20> if b1 in a:</line-20>
<line-21> print(0)</line-21>
<line-22> else:</line-22>
<line-23> print("inf")</line-23>
<line-24> elif q == -1:</line-24>
<line-25> if (b1 in a) and ((-b1) in a):</line-25>
<line-26> print(0)</line-26>
<line-27> else:</line-27>
<line-28> print("inf")</line-28>
<line-29> else:</line-29>
<line-30> ans = 0</line-30>
<line-31> b = b1</line-31>
<line-32> for i in range(100):</line-32>
<line-33> if b in a:</line-33>
<line-34> b *= q</line-34>
<line-35> if abs(b) > l:</line-35>
<line-36> break</line-36>
<line-37> continue</line-37>
<line-38> ans += 1</line-38>
<line-39> b *= q</line-39>
<line-40> if abs(b) > l:</line-40>
<line-41> break</line-41>
<line-42> print(ans)</line-42>
<line-43></line-43>
<line-44>def __starting_point():</line-44>
<line-46></line-46>
<line-47>__starting_point()</line-47>
|
{"code": "<line-2> (b1, q, l, m) = list(map(int, input().split()))</line-2>\n<line-45> main()</line-45>", "lines": [2, 45]}
#### 0
|
<line-1>3</line-1>
<line-2></line-2>
<line-4>import sys</line-4>
<line-5>def return:</line-5>
<line-6> print(-1)</line-6>
<line-7> return</line-7>
<line-8></line-8>
<line-9>n, m = readln()</line-9>
<line-10>mon = [list(input()) for _ in range(n)]</line-10>
<line-11>hor = [i for i in range(n) if mon[i] != ['.'] * m]</line-11>
<line-12>rmon = list(zip(*mon))</line-12>
<line-13>ver = [j for j in range(m) if rmon[j] != ('.',) * n]</line-13>
<line-14>mini = hor[0]</line-14>
<line-15>maxi = hor[-1]</line-15>
<line-16>minj = ver[0]</line-16>
<line-17>maxj = ver[-1]</line-17>
<line-18>cnt_in = len([1 for i in range(mini + 1, maxi) for j in range(minj + 1, maxj) if mon[i][j] == 'w'])</line-18>
<line-19>cnt_l = len([1 for i in range(mini + 1, maxi) if mon[i][minj] == 'w'])</line-19>
<line-20>cnt_r = len([1 for i in range(mini + 1, maxi) if mon[i][maxj] == 'w'])</line-20>
<line-21>cnt_d = len([1 for j in range(minj + 1, maxj) if mon[mini][j] == 'w'])</line-21>
<line-22>cnt_u = len([1 for j in range(minj + 1, maxj) if mon[maxi][j] == 'w'])</line-22>
<line-23>if cnt_in:</line-23>
<line-24> return</line-24>
<line-25>if maxi - mini < maxj - minj:</line-25>
<line-26> k = maxj - minj + 1</line-26>
<line-27> if maxi == mini and cnt_d:</line-27>
<line-28> if mini >= k - 1:</line-28>
<line-29> mini -= k - 1</line-29>
<line-30> elif maxi + k - 1 < n:</line-30>
<line-31> maxi += k - 1</line-31>
<line-32> else:</line-32>
<line-33> return</line-33>
<line-34> else:</line-34>
<line-35> if not cnt_d:</line-35>
<line-36> mini = max(0, maxi - k + 1)</line-36>
<line-37> if maxi - maxi + 1 != k and not cnt_u:</line-37>
<line-38> maxi = min(mini + k - 1, n - 1)</line-38>
<line-39> if maxi - mini + 1 != k:</line-39>
<line-40> return</line-40>
<line-41>else:</line-41>
<line-42> k = maxi - mini + 1</line-42>
<line-43> if maxj == minj and cnt_l:</line-43>
<line-44> if minj >= k - 1:</line-44>
<line-45> minj -= k - 1</line-45>
<line-46> elif maxj + k - 1 < m:</line-46>
<line-47> maxj += k - 1</line-47>
<line-48> else:</line-48>
<line-49> return</line-49>
<line-50> else:</line-50>
<line-51> if not cnt_l:</line-51>
<line-52> minj = max(0, maxj - k + 1)</line-52>
<line-53> if maxj - minj + 1 != k and not cnt_r:</line-53>
<line-54> maxj = min(minj + k - 1, m - 1)</line-54>
<line-55> if maxj - minj + 1 != k:</line-55>
<line-56> return</line-56>
<line-57>for i in range(mini, maxi + 1):</line-57>
<line-58> if mon[i][minj] == '.':</line-58>
<line-59> mon[i][minj] = '+'</line-59>
<line-60>for i in range(mini, maxi + 1):</line-60>
<line-61> if mon[i][maxj] == '.':</line-61>
<line-62> mon[i][maxj] = '+'</line-62>
<line-63>for j in range(minj, maxj + 1):</line-63>
<line-64> if mon[mini][j] == '.':</line-64>
<line-65> mon[mini][j] = '+'</line-65>
<line-66>for j in range(minj, maxj + 1):</line-66>
<line-67> if mon[maxi][j] == '.':</line-67>
<line-69>print('\n'.join([''.join(row) for row in mon]))</line-69>
|
{"code": "<line-3>def readln(): return list(map(int, input().split()))</line-3>\n<line-68> mon[maxi][j] = '+'</line-68>", "lines": [3, 68]}
#### 0
|
<line-1>def egcd(a, b):</line-1>
<line-3> while a != 0:</line-3>
<line-4> q, r = b//a, b%a</line-4>
<line-5> m, n = x-u*q, y-v*q</line-5>
<line-6> b,a, x,y, u,v = a,r, u,v, m,n</line-6>
<line-7> gcd = b</line-7>
<line-8> return gcd, x, y</line-8>
<line-9></line-9>
<line-10></line-10>
<line-11>import math</line-11>
<line-12>n=int(input())</line-12>
<line-13>a=int(input())</line-13>
<line-14>b=int(input())</line-14>
<line-15>gcd,x,y=(egcd(a,b))</line-15>
<line-16></line-16>
<line-17></line-17>
<line-18>status=0</line-18>
<line-19>if((n%gcd)!=0):</line-19>
<line-20> print("NO")</line-20>
<line-21> #print("point1")</line-21>
<line-22></line-22>
<line-23>else:</line-23>
<line-24> multiply=n/gcd</line-24>
<line-25> x1=int(multiply*x)</line-25>
<line-26> y1=int(multiply*y)</line-26>
<line-27> #print("gcd and soln to n")</line-27>
<line-28> #print(gcd,x1,y1)</line-28>
<line-29> d1=b/gcd</line-29>
<line-30> d2=a/gcd</line-30>
<line-31> rangemin= int(math.ceil(-x1/d1))</line-31>
<line-32> rangemax= int(y1//d2)</line-32>
<line-33> #print("rangemin and rangemax")</line-33>
<line-34> #print(rangemin,rangemax)</line-34>
<line-35> if(rangemin>rangemax):</line-35>
<line-36> print("NO")</line-36>
<line-37> #print("point2")</line-37>
<line-38> else:</line-38>
<line-39> #print("YES")</line-39>
<line-40> #solx=x1+rangemin*d1</line-40>
<line-41> #soly=y1-rangemin*d2</line-41>
<line-42> m=rangemin</line-42>
<line-43> while(m<=rangemax):</line-43>
<line-44> solx=x1+m*d1</line-44>
<line-45> soly=y1-m*d2</line-45>
<line-46> if(solx>=0 and soly>=0):</line-46>
<line-47> print("YES")</line-47>
<line-48> status=1</line-48>
<line-49> print(str(int(solx))+" "+str(int(soly)))</line-49>
<line-50> break</line-50>
<line-51> m=m+1</line-51>
<line-52></line-52>
<line-53> if(status==0):</line-53>
<line-55> #print("point3")</line-55>
<line-56> </line-56>
<line-57> </line-57>
|
{"code": "<line-2> x,y, u,v = 0,1, 1,0</line-2>\n<line-54> print(\"NO\")</line-54>", "lines": [2, 54]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3> print('zero')</line-3>
<line-4>elif n == 1:</line-4>
<line-5> print('one')</line-5>
<line-6>elif n == 2:</line-6>
<line-7> print('two')</line-7>
<line-8>elif n == 3:</line-8>
<line-9> print('three')</line-9>
<line-10>elif n == 4:</line-10>
<line-11> print('four')</line-11>
<line-12>elif n == 5:</line-12>
<line-13> print('five')</line-13>
<line-14>elif n == 6:</line-14>
<line-15> print('six')</line-15>
<line-16>elif n == 7:</line-16>
<line-17> print('seven')</line-17>
<line-18>elif n == 8:</line-18>
<line-19> print('eight')</line-19>
<line-20>elif n == 9:</line-20>
<line-21> print('nine')</line-21>
<line-22>elif n == 10:</line-22>
<line-23> print('ten')</line-23>
<line-24>elif n == 11:</line-24>
<line-25> print('eleven')</line-25>
<line-26>elif n == 12:</line-26>
<line-27> print('twelve')</line-27>
<line-28>elif n == 13:</line-28>
<line-29> print('thirteen')</line-29>
<line-30>elif n == 14:</line-30>
<line-31> print('fourteen')</line-31>
<line-32>elif n == 15:</line-32>
<line-33> print('fifteen')</line-33>
<line-34>elif n == 16:</line-34>
<line-35> print('sixteen')</line-35>
<line-36>elif n == 17:</line-36>
<line-37> print('seventeen')</line-37>
<line-38>elif n == 18:</line-38>
<line-39> print('eighteen')</line-39>
<line-40>elif n == 19:</line-40>
<line-41> print('nineteen')</line-41>
<line-42>else:</line-42>
<line-43> if n // 10 == 2:</line-43>
<line-44> res = 'twenty'</line-44>
<line-45> elif n // 10 == 3:</line-45>
<line-46> res = 'thirty'</line-46>
<line-47> elif n // 10 == 4:</line-47>
<line-48> res = 'forty'</line-48>
<line-49> elif n // 10 == 5:</line-49>
<line-50> res = 'fifty'</line-50>
<line-51> elif n // 10 == 6:</line-51>
<line-52> res = 'sixty'</line-52>
<line-53> elif n // 10 == 7:</line-53>
<line-54> res = 'seventy'</line-54>
<line-55> elif n // 10 == 8:</line-55>
<line-56> res = 'eighty'</line-56>
<line-57> elif n // 10 == 9:</line-57>
<line-58> res = 'ninety'</line-58>
<line-59></line-59>
<line-60> if n % 10 == 1:</line-60>
<line-61> res += '-one'</line-61>
<line-62> elif n % 10 == 2:</line-62>
<line-63> res += '-two'</line-63>
<line-64> elif n % 10 == 3:</line-64>
<line-65> res += '-three'</line-65>
<line-66> elif n % 10 == 4:</line-66>
<line-67> res += '-four'</line-67>
<line-68> elif n % 10 == 5:</line-68>
<line-69> res += '-five'</line-69>
<line-70> elif n % 10 == 6:</line-70>
<line-71> res += '-six'</line-71>
<line-72> elif n % 10 == 7:</line-72>
<line-73> res += '-seven'</line-73>
<line-74> elif n % 10 == 8:</line-74>
<line-75> res += '-eight'</line-75>
<line-76> elif n % 10 == 9:</line-76>
<line-78></line-78>
<line-79> print(res)</line-79>
|
{"code": "<line-2>if n == 0:</line-2>\n<line-77>\t\tres += '-nine'</line-77>", "lines": [2, 77]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>mx = 1</line-3>
<line-4>p = 1</line-4>
<line-5>for i in range(1, n + 2):</line-5>
<line-6> if a[i] == a[i - 1] + 1:</line-6>
<line-7> p += 1</line-7>
<line-8> mx = max(p, mx)</line-8>
<line-9> else:</line-9>
<line-11>print(max(0, mx - 2))</line-11>
|
{"code": "<line-2>a = [0] + list(map(int, input().split())) + [1001]</line-2>\n<line-10> p = 1</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>def main():</line-1>
<line-3> a = list(int(x) for x in input().split())</line-3>
<line-4> s = sum(a)</line-4>
<line-5> t = 0</line-5>
<line-6> for i in range(n):</line-6>
<line-7> t += a[i]</line-7>
<line-8> if 2 * t >= s:</line-8>
<line-9> print(i + 1)</line-9>
<line-11></line-11>
<line-12>main()</line-12>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-10> return</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>for i in range(n):</line-3>
<line-4> for j in range(n):</line-4>
<line-5> graph[0][(i,j)]=[(k,j) for k in range(n)]+[(i,k) for k in range(n)]</line-5>
<line-6> graph[0][(i,j)].remove((i,j))</line-6>
<line-7> graph[0][(i,j)].remove((i,j))</line-7>
<line-8> graph[1][(i,j)]=[]</line-8>
<line-9> for k in range(n):</line-9>
<line-10> for l in range(n):</line-10>
<line-11> if abs(k-i)==abs(l-j)!=0:</line-11>
<line-12> graph[1][(i,j)].append((k,l))</line-12>
<line-13> graph[2][(i,j)]=[]</line-13>
<line-14> for k in range(n):</line-14>
<line-15> for l in range(n):</line-15>
<line-16> if {abs(k-i),abs(l-j)}=={1,2}:</line-16>
<line-17> graph[2][(i,j)].append((k,l)) </line-17>
<line-18></line-18>
<line-19>dists=[[{},{},{}],[{},{},{}],[{},{},{}]]</line-19>
<line-20>for i in range(n):</line-20>
<line-21> for j in range(n):</line-21>
<line-22> for k in range(3):</line-22>
<line-23> dists[k][k][(i,j,i,j)]=0</line-23>
<line-24>for i in range(n):</line-24>
<line-25> for j in range(n):</line-25>
<line-26> for k in range(3):</line-26>
<line-27> layers=[[(i,j,k,0)],[],[],[],[]]</line-27>
<line-28> for l in range(4):</line-28>
<line-29> for guy in layers[l]:</line-29>
<line-30> for m in range(3):</line-30>
<line-31> if m!=guy[2]:</line-31>
<line-32> if (i,j,guy[0],guy[1]) not in dists[k][m]:</line-32>
<line-33> layers[l+1].append((guy[0],guy[1],m,guy[3]+1))</line-33>
<line-34> dists[k][m][(i,j,guy[0],guy[1])]=1000*(l+1)+guy[3]+1</line-34>
<line-35> for boi in graph[guy[2]][(guy[0],guy[1])]:</line-35>
<line-36> if (i,j,boi[0],boi[1]) not in dists[k][guy[2]]:</line-36>
<line-37> layers[l+1].append((boi[0],boi[1],guy[2],guy[3]))</line-37>
<line-38> dists[k][guy[2]][(i,j,boi[0],boi[1])]=1000*(l+1)+guy[3]</line-38>
<line-39> elif 1000*(l+1)+guy[3]<dists[k][guy[2]][(i,j,boi[0],boi[1])]:</line-39>
<line-40> layers[l+1].append((boi[0],boi[1],guy[2],guy[3]))</line-40>
<line-41> dists[k][guy[2]][(i,j,boi[0],boi[1])]=1000*(l+1)+guy[3]</line-41>
<line-42>locs=[None]*(n**2)</line-42>
<line-43>for i in range(n):</line-43>
<line-44> a=list(map(int,input().split()))</line-44>
<line-45> for j in range(n):</line-45>
<line-46> locs[a[j]-1]=(i,j)</line-46>
<line-47>best=(0,0,0)</line-47>
<line-48>for i in range(n**2-1):</line-48>
<line-49> tup=(locs[i][0],locs[i][1],locs[i+1][0],locs[i+1][1])</line-49>
<line-50> new0=min(best[0]+dists[0][0][tup],best[1]+dists[1][0][tup],best[2]+dists[2][0][tup])</line-50>
<line-51> new1=min(best[0]+dists[0][1][tup],best[1]+dists[1][1][tup],best[2]+dists[2][1][tup])</line-51>
<line-52> new2=min(best[0]+dists[0][2][tup],best[1]+dists[1][2][tup],best[2]+dists[2][2][tup])</line-52>
<line-53> best=(new0,new1,new2)</line-53>
<line-55>print(a//1000,a%1000)</line-55>
|
{"code": "<line-2>graph=[{},{},{}]</line-2>\n<line-54>a=min(best)</line-54>", "lines": [2, 54]}
#### 0
|
<line-1>n, m, k = map(int, input().split())</line-1>
<line-3>a -= 1</line-3>
<line-4>b -= 1</line-4>
<line-5>def p(x):</line-5>
<line-6> return x // (m * k)</line-6>
<line-7>def e(x):</line-7>
<line-8> return (x - p(x) * m * k) // k</line-8>
<line-9>def lift(x):</line-9>
<line-10> return min(5 * x, 10 + x)</line-10>
<line-11> </line-11>
<line-12>if p(a) == p(b):</line-12>
<line-13> dif = abs(e(a) - e(b))</line-13>
<line-14> print(lift(dif))</line-14>
<line-16> print(lift(e(a)) + 15 * min((p(a) - p(b) + n) % n, (p(b) - p(a) + n) % n) + lift(e(b)))</line-16>
|
{"code": "<line-2>a, b = map(int, input().split())</line-2>\n<line-15>else:</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>s = input()</line-1>
<line-3>while i < len(s) and s[i] == '0':</line-3>
<line-4> i += 1</line-4>
<line-5>cnt = 0</line-5>
<line-6>while i < len(s):</line-6>
<line-7> if s[i] == '0':</line-7>
<line-8> cnt += 1</line-8>
<line-9> i += 1</line-9>
<line-10></line-10>
<line-11>if cnt >= 6:</line-11>
<line-12> print('yes')</line-12>
<line-14> print('no')</line-14>
|
{"code": "<line-2>i = 0</line-2>\n<line-13>else:</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>s = list(input())</line-1>
<line-3>ind_t = 0</line-3>
<line-4>ind_s = 0</line-4>
<line-5>while ind_s < len(s) and ind_t < 26:</line-5>
<line-6> if ord(s[ind_s]) <= ord(target[ind_t]):</line-6>
<line-7> s[ind_s] = target[ind_t]</line-7>
<line-8> ind_t += 1</line-8>
<line-9> ind_s += 1</line-9>
<line-10> else:</line-10>
<line-11> ind_s += 1</line-11>
<line-12>if ind_t == 26:</line-12>
<line-13> print(''.join(s))</line-13>
<line-15> print(-1)</line-15>
|
{"code": "<line-2>target = 'abcdefghijklmnopqrstuvwxyz'</line-2>\n<line-14>else:</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>import heapq as hq</line-1>
<line-3></line-3>
<line-4>import math</line-4>
<line-5>n,m,r, k= input().split()</line-5>
<line-6>N = int(n)</line-6>
<line-7>M = int(m)</line-7>
<line-8>R = int(r)</line-8>
<line-9>K = int(k)</line-9>
<line-10></line-10>
<line-11>q = PriorityQueue()</line-11>
<line-12></line-12>
<line-13></line-13>
<line-14></line-14>
<line-15>for i in range(1,math.floor((N+1)/2) + 1):</line-15>
<line-16> maxi = min(min(i,N-i+1),min(R,N-R+1)) * min(min(R,M-R+1),math.ceil(M/2))</line-16>
<line-17> num = M - (2 * min(min(R,M-R+1),math.ceil(M/2))-2)</line-17>
<line-18> mult = 2</line-18>
<line-19> if(i > math.floor(N/2)):</line-19>
<line-20> mult = 1</line-20>
<line-21> q.put((-maxi,num * mult,i))</line-21>
<line-22> #print(str(maxi) + " " + str(num) + " " + str(mult))</line-22>
<line-23></line-23>
<line-24></line-24>
<line-25>ans = 0</line-25>
<line-26>while(K > 0):</line-26>
<line-27> pop = q.get()</line-27>
<line-28> #print(pop)</line-28>
<line-29> a = -1 * pop[0]</line-29>
<line-30> b = pop[1]</line-30>
<line-31> c = pop[2]</line-31>
<line-32> d = min(min(c,N-c+1),min(R,N-R+1))</line-32>
<line-33> if(d != a):</line-33>
<line-34> # if(q.)</line-34>
<line-35> # if(q.get(-(a - d)) != )</line-35>
<line-36> mult = 2</line-36>
<line-37> if (c > N / 2):</line-37>
<line-38> mult = 1</line-38>
<line-39> q.put((-(a - d),2*mult,c))</line-39>
<line-40> ans += a * min(b,K)</line-40>
<line-41> K -= b;</line-41>
<line-42></line-42>
<line-43>tot = (N-R+1) * (M-R+1)</line-43>
<line-44>#print("ANS = " + str(ans))</line-44>
<line-45>#print("FINANS = " + str(ans/tot))</line-45>
<line-46>print(str(ans/tot))</line-46>
<line-47></line-47>
<line-48></line-48>
<line-49>'''</line-49>
<line-50></line-50>
<line-51>d = []</line-51>
<line-52>for i in range(0,N):</line-52>
<line-53> d.append([])</line-53>
<line-54> for j in range(0,M):</line-54>
<line-55> d[i].append(0)</line-55>
<line-56></line-56>
<line-57>tot = 0</line-57>
<line-58>for i in range(0,N-R+1):</line-58>
<line-59> for j in range(0,M-R+1):</line-59>
<line-60> for k in range(i,i+R):</line-60>
<line-61> for l in range(j,j+R):</line-61>
<line-62> d[k][l] += 1</line-62>
<line-63> tot += 1</line-63>
<line-64></line-64>
<line-65></line-65>
<line-66>print(N-R+1)*(M-R+1) * (R*R)</line-66>
<line-67>print(tot)</line-67>
<line-68>print()</line-68>
<line-69>for i in d:</line-69>
<line-71></line-71>
<line-72>'''</line-72>
|
{"code": "<line-2>from queue import PriorityQueue</line-2>\n<line-70> print(i)</line-70>", "lines": [2, 70]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>if n == 1:</line-3>
<line-4> if A[0] >= 0:</line-4>
<line-5> print(A[0])</line-5>
<line-6> else:</line-6>
<line-7> print(-A[0]-1)</line-7>
<line-8> return</line-8>
<line-9>for i in range(n):</line-9>
<line-10> if A[i] < 0:</line-10>
<line-11> pass</line-11>
<line-12> else:</line-12>
<line-13> A[i] = -A[i]-1</line-13>
<line-14>if n % 2 == 0:</line-14>
<line-15> print(*A)</line-15>
<line-16> return</line-16>
<line-17>mim = 0</line-17>
<line-18>indmim = 0</line-18>
<line-19>for i in range(n):</line-19>
<line-20> if A[i] < mim:</line-20>
<line-21> mim = A[i]</line-21>
<line-22> indmim = i</line-22>
<line-24>print(*A)</line-24>
|
{"code": "<line-2>A = list(map(int, input().split()))</line-2>\n<line-23>A[indmim] = -A[indmim]-1</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>def factorization(n):</line-4>
<line-5> res = []</line-5>
<line-6> limit = math.ceil(math.sqrt(n))</line-6>
<line-7> p = 2</line-7>
<line-8> cnt = 0</line-8>
<line-9></line-9>
<line-10> while n % p == 0:</line-10>
<line-11> cnt += 1</line-11>
<line-12> n //= p</line-12>
<line-13></line-13>
<line-14> if cnt > 0:</line-14>
<line-15> res.append((p, cnt))</line-15>
<line-16></line-16>
<line-17> cnt = 0</line-17>
<line-18> for p in range(3, limit + 1, 2):</line-18>
<line-19> if n % p == 0:</line-19>
<line-20> while n % p == 0:</line-20>
<line-21> cnt += 1</line-21>
<line-22> n //= p</line-22>
<line-23></line-23>
<line-24> res.append((p, cnt))</line-24>
<line-25> cnt = 0</line-25>
<line-26></line-26>
<line-27> if n > 1:</line-27>
<line-28> res.append((n, 1))</line-28>
<line-29></line-29>
<line-30> return res</line-30>
<line-31></line-31>
<line-32>def divisor(n):</line-32>
<line-33> res = set()</line-33>
<line-34></line-34>
<line-35> factor = factorization(n)</line-35>
<line-36></line-36>
<line-37> for p, c in factor:</line-37>
<line-38> if res == set():</line-38>
<line-39> for i in range(c + 1):</line-39>
<line-40> res.add(p ** i)</line-40>
<line-41> else:</line-41>
<line-42> t = set()</line-42>
<line-43> for i in range(1, c + 1):</line-43>
<line-44> for m in res:</line-44>
<line-45> t.add(m * p**i)</line-45>
<line-46> res = res | t</line-46>
<line-47></line-47>
<line-48> res = list(sorted(res))</line-48>
<line-49> return res</line-49>
<line-50></line-50>
<line-51>n, k = map(int, input().split())</line-51>
<line-52></line-52>
<line-53># print(factorization(n), file=sys.stderr)</line-53>
<line-54># print(divisor(n), file=sys.stderr)</line-54>
<line-55></line-55>
<line-56>n_div = divisor(n)</line-56>
<line-57></line-57>
<line-58>if n == 1:</line-58>
<line-59> if k == 1:</line-59>
<line-60> ans = 1</line-60>
<line-61> else:</line-61>
<line-62> ans = -1</line-62>
<line-63>elif k > len(n_div):</line-63>
<line-64> ans = -1</line-64>
<line-65>else:</line-65>
<line-67></line-67>
<line-68>print(ans)</line-68>
|
{"code": "<line-2>import math</line-2>\n<line-66> ans = n_div[k - 1]</line-66>", "lines": [2, 66]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3></line-3>
<line-4>import itertools</line-4>
<line-5>for x in range(1,10**n):</line-5>
<line-6> good = False</line-6>
<line-7> s = str(x)</line-7>
<line-8> for p in itertools.permutations(a, len(s)):</line-8>
<line-9> good |= all([int(s[i]) in v for i, v in enumerate(p)])</line-9>
<line-10> if not good:</line-10>
<line-11> print(x-1)</line-11>
<line-13> </line-13>
<line-14>print((10**n)-1)</line-14>
|
{"code": "<line-2>a = sorted([list(map(int, input().split())) for i in range(n)])</line-2>\n<line-12> return</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>def main():</line-1>
<line-3> num_2 = 0</line-3>
<line-4> num_5 = 0</line-4>
<line-5> x = n</line-5>
<line-6> while (x % 2 == 0):</line-6>
<line-7> num_2 += 1</line-7>
<line-8> x //= 2</line-8>
<line-9> </line-9>
<line-10> while (x % 5 == 0):</line-10>
<line-11> num_5 += 1</line-11>
<line-12> x //= 5</line-12>
<line-13> num_2 = k - min(num_2, k)</line-13>
<line-14> num_5 = k - min(num_5, k)</line-14>
<line-16></line-16>
<line-17></line-17>
<line-18>main()</line-18>
|
{"code": "<line-2>\tn, k = map(int, input().split())</line-2>\n<line-15>\tprint(n * 5 ** num_5 * 2 ** num_2)</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>n, m = map(int, input().split())</line-1>
<line-3>B = [[0] * m for _ in range(n)]</line-3>
<line-4>ans = []</line-4>
<line-5>for i in range(n - 1):</line-5>
<line-6> for j in range(m - 1):</line-6>
<line-7> if A[i][j] == 1 and A[i + 1][j] == 1 and A[i][j + 1] == 1 and A[i + 1][j + 1] == 1:</line-7>
<line-8> B[i][j] = 1</line-8>
<line-9> B[i + 1][j] = 1</line-9>
<line-10> B[i][j + 1] = 1</line-10>
<line-11> B[i + 1][j + 1] = 1</line-11>
<line-12> ans.append([i + 1, j + 1])</line-12>
<line-13>if A == B:</line-13>
<line-14> print(len(ans))</line-14>
<line-15> for a, b in ans:</line-15>
<line-16> print(a, b)</line-16>
<line-18> print(-1)</line-18>
|
{"code": "<line-2>A = [list(map(int, input().split())) for _ in range(n)]</line-2>\n<line-17>else:</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>r, s, p = list(map(int, input().split()))</line-1>
<line-3>dp[r][s][p] = 1</line-3>
<line-4>def nCk(n, k):</line-4>
<line-5> if n <= k:</line-5>
<line-6> return 1</line-6>
<line-7> res = 1</line-7>
<line-8> for i in range(k):</line-8>
<line-9> res *= n-i</line-9>
<line-10> for i in range(k):</line-10>
<line-11> res //= (i+1)</line-11>
<line-12> return res</line-12>
<line-13></line-13>
<line-14>C = [nCk(i, 2) for i in range(r+s+p+1)]</line-14>
<line-15>for ri in range(r, -1, -1):</line-15>
<line-16> for si in range(s, -1, -1):</line-16>
<line-17> for pi in range(p, -1, -1):</line-17>
<line-18> t = ri * si + si * pi + pi * ri</line-18>
<line-19> if t == 0: continue</line-19>
<line-20> if ri > 0:</line-20>
<line-21> dp[ri-1][si][pi] += dp[ri][si][pi] * ri * pi / t</line-21>
<line-22> if si > 0:</line-22>
<line-23> dp[ri][si-1][pi] += dp[ri][si][pi] * ri * si / t</line-23>
<line-24> if pi > 0:</line-24>
<line-25> dp[ri][si][pi-1] += dp[ri][si][pi] * si * pi / t</line-25>
<line-26> </line-26>
<line-27> </line-27>
<line-28>r_sum = sum([dp[ri][0][0] for ri in range(r+1)])</line-28>
<line-29>s_sum = sum([dp[0][si][0] for si in range(s+1)])</line-29>
<line-31>print(r_sum, s_sum, p_sum)</line-31>
|
{"code": "<line-2>dp = [[[0] * (p+1) for _ in range(s+1)] for _ in range(r+1)]</line-2>\n<line-30>p_sum = sum([dp[0][0][pi] for pi in range(p+1)])</line-30>", "lines": [2, 30]}
#### 0
|
<line-1>read = lambda: list(map(int, input().split()))</line-1>
<line-3>R = min(r1, r2)</line-3>
<line-4>L = max(l1, l2)</line-4>
<line-5>ans = max(R - L + 1, 0)</line-5>
<line-7>print(ans)</line-7>
|
{"code": "<line-2>l1, r1, l2, r2, k = read()</line-2>\n<line-6>if L <= k <= R: ans = max(ans - 1, 0)</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>#写経</line-1>
<line-3>import sys</line-3>
<line-4>sys.setrecursionlimit(10**9)</line-4>
<line-5>input = sys.stdin.readline</line-5>
<line-6>from bisect import bisect_left, bisect_right</line-6>
<line-7>INF = 10 **18</line-7>
<line-8></line-8>
<line-9>def resolve():</line-9>
<line-10> n, m = map(int, input().split())</line-10>
<line-11> a = [list(map(int, input().split())) for i in range(n)]</line-11>
<line-12> b = [list(map(int, input().split())) for i in range(m)]</line-12>
<line-13> </line-13>
<line-14> X = {-INF, INF}</line-14>
<line-15> Y = {-INF, INF}</line-15>
<line-16> for i in a:</line-16>
<line-17> Y.add(i[2])</line-17>
<line-18> for i in b:</line-18>
<line-19> X.add(i[0])</line-19>
<line-20> </line-20>
<line-21> X = list(sorted(X))</line-21>
<line-22> Y = list(sorted(Y))</line-22>
<line-23> n = len(X) - 1</line-23>
<line-24> m = len(Y) - 1</line-24>
<line-25> wallx = [[False] * m for i in range(n)]</line-25>
<line-26> wally = [[False] * m for i in range(n)]</line-26>
<line-27> </line-27>
<line-28> for x1, x2, y1 in a:</line-28>
<line-29> x1 = bisect_left(X, x1)</line-29>
<line-30> y1 = bisect_left(Y, y1)</line-30>
<line-31> x2 = bisect_right(X, x2) - 1</line-31>
<line-32> for i in range(x1, x2):</line-32>
<line-33> wally[i][y1] = True</line-33>
<line-34> </line-34>
<line-35> for x1, y1, y2 in b:</line-35>
<line-36> x1 = bisect_left(X, x1)</line-36>
<line-37> y1 = bisect_left(Y, y1)</line-37>
<line-38> y2 = bisect_right(Y, y2) - 1</line-38>
<line-39> for i in range(y1, y2):</line-39>
<line-40> wallx[x1][i] = True</line-40>
<line-41> </line-41>
<line-42> cow = [[False] * m for i in range(n)]</line-42>
<line-43> cx = bisect_right(X, 0) - 1</line-43>
<line-44> cy = bisect_right(Y, 0) - 1</line-44>
<line-45> cow[cx][cy] = True</line-45>
<line-46> q = [(cx, cy)]</line-46>
<line-47> ans = 0</line-47>
<line-48> </line-48>
<line-49> while q:</line-49>
<line-50> x, y = q.pop()</line-50>
<line-51> if not x or not y:</line-51>
<line-52> print("INF")</line-52>
<line-53> return</line-53>
<line-54> ans += (X[x + 1] - X[x]) * (Y[y + 1] - Y[y])</line-54>
<line-55> if x and not wallx[x][y] and not cow[x - 1][y]:</line-55>
<line-56> cow[x - 1][y] = True</line-56>
<line-57> q.append((x - 1, y))</line-57>
<line-58> if y and not wally[x][y] and not cow[x][y - 1]:</line-58>
<line-59> cow[x][y - 1] = True</line-59>
<line-60> q.append((x, y - 1))</line-60>
<line-61> if x + 1 < n and not wallx[x + 1][y] and not cow[x + 1][y]:</line-61>
<line-62> cow[x + 1][y] = True</line-62>
<line-63> q.append((x + 1, y))</line-63>
<line-64> if y + 1 < m and not wally[x][y + 1] and not cow[x][y + 1]:</line-64>
<line-65> cow[x][y + 1] = True</line-65>
<line-66> q.append((x, y + 1)) </line-66>
<line-68>resolve()</line-68>
|
{"code": "<line-2>#https://atcoder.jp/contests/abc168/submissions/14421546</line-2>\n<line-67> print(ans)</line-67>", "lines": [2, 67]}
#### 0
|
<line-1>t, s, x = list(map(int, input().split()))</line-1>
<line-3>if x - 1 > t and (x - 1 - t) % s == 0:</line-3>
<line-4> f = True</line-4>
<line-5>if x >= t and (x - t) % s == 0:</line-5>
<line-6> f = True</line-6>
<line-7>if f:</line-7>
<line-8> print('YES')</line-8>
<line-10> print('NO')</line-10>
|
{"code": "<line-2>f = False</line-2>\n<line-9>else:</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>for i in range(1, n + 1):</line-3>
<line-4> l, r = list(map(int, input().split()))</line-4>
<line-5> a.append([l, -r, i])</line-5>
<line-6>a.sort()</line-6>
<line-7>hh = a[0][1]</line-7>
<line-8>wahh = max(-1, a[0][2])</line-8>
<line-9>for i in range(1, n):</line-9>
<line-10> if a[i][1] >= hh:</line-10>
<line-11> print(a[i][2], wahh)</line-11>
<line-12> return</line-12>
<line-13> else:</line-13>
<line-14> hh = a[i][1]</line-14>
<line-16>print(-1, -1)</line-16>
|
{"code": "<line-2>a = []</line-2>\n<line-15> wahh = a[i][2]</line-15>", "lines": [2, 15]}
#### 0
|
<line-1></line-1>
<line-2>import sys</line-2>
<line-4>input=sys.stdin.readline</line-4>
<line-5></line-5>
<line-6>n=int(input())</line-6>
<line-7>if n%4: print("===")</line-7>
<line-8>else:</line-8>
<line-9> t=input().strip()</line-9>
<line-10> a=[n//4]*4</line-10>
<line-11> for i in t:</line-11>
<line-12> if i=='A': a[0]-=1</line-12>
<line-13> elif i=='C': a[1]-=1</line-13>
<line-14> elif i=='G': a[2]-=1</line-14>
<line-15> elif i=='T': a[3]-=1</line-15>
<line-16> if min(a)<0: print("===")</line-16>
<line-17> else:</line-17>
<line-18> out=[]</line-18>
<line-19> for i in t:</line-19>
<line-20> if i=='?':</line-20>
<line-21> if a[0]:</line-21>
<line-22> out.append('A')</line-22>
<line-23> a[0]-=1</line-23>
<line-24> elif a[1]:</line-24>
<line-25> out.append('C')</line-25>
<line-26> a[1]-=1</line-26>
<line-27> elif a[2]:</line-27>
<line-28> out.append('G')</line-28>
<line-29> a[2]-=1</line-29>
<line-30> elif a[3]:</line-30>
<line-31> out.append('T')</line-31>
<line-32> a[3]-=1</line-32>
<line-34> print("".join(out))</line-34>
|
{"code": "<line-3>#sys.stdin=open(\"data.txt\")</line-3>\n<line-33> else: out.append(i)</line-33>", "lines": [3, 33]}
#### 0
|
<line-1>def chk(l):</line-1>
<line-3> for j in range(2):</line-3>
<line-4> if l[i][j]==l[i][j+1]==l[i][j+2]=='x':</line-4>
<line-5> return True</line-5>
<line-6> for i in range(2):</line-6>
<line-7> for j in range(4):</line-7>
<line-8> if l[i][j]==l[i+1][j]==l[i+2][j]=='x':</line-8>
<line-9> return True</line-9>
<line-10> for i in range(2):</line-10>
<line-11> for j in range(2):</line-11>
<line-12> if l[i][j]==l[i+1][j+1]==l[i+2][j+2]=='x':</line-12>
<line-13> return True</line-13>
<line-14> for i in range(2):</line-14>
<line-15> for j in range(2, 4):</line-15>
<line-16> if l[i][j]==l[i+1][j-1]==l[i+2][j-2]=='x':</line-16>
<line-17> return True</line-17>
<line-18> return False</line-18>
<line-19>a = [list(input()), list(input()), list(input()), list(input())]</line-19>
<line-20>for i in range(4):</line-20>
<line-21> for j in range(4):</line-21>
<line-22> if a[i][j] != '.':</line-22>
<line-23> continue</line-23>
<line-24> a[i][j]='x'</line-24>
<line-25> if chk(a):</line-25>
<line-26> print("YES"); return</line-26>
<line-28>print("NO")</line-28>
|
{"code": "<line-2>\tfor i in range(4):</line-2>\n<line-27>\t\ta[i][j]='.'</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>def solve(n,a):</line-1>
<line-3> for i in range(n):</line-3>
<line-4> tot+=a[i]</line-4>
<line-5> diffs = [] #alla suffix - prefix diffs[i]=prefix-suffix om delas innan element i</line-5>
<line-6> diffs.append(-tot)</line-6>
<line-7> for i in range(n):</line-7>
<line-8> tot-=2*a[i]</line-8>
<line-9> diffs.append(-tot)</line-9>
<line-10> if tot==0:</line-10>
<line-11> return ("YES")</line-11>
<line-12> for i in range(n):</line-12>
<line-13> diffmake=2*a[i]</line-13>
<line-14> j=binary(diffs,diffmake)</line-14>
<line-15> if j>i and j!=-1:</line-15>
<line-16> return ("YES")</line-16>
<line-17> j=binary(diffs,-diffmake)</line-17>
<line-18> if i>=j and j!=-1:</line-18>
<line-19> return ("YES")</line-19>
<line-20> return ("NO")</line-20>
<line-21></line-21>
<line-22></line-22>
<line-23>def binary(a,value):</line-23>
<line-24> hi=len(a)</line-24>
<line-25> lo=-1</line-25>
<line-26> while (lo+1<hi):</line-26>
<line-27> mi=(lo+hi)//2</line-27>
<line-28> if a[mi]==value:</line-28>
<line-29> return mi</line-29>
<line-30> if a[mi]<value:</line-30>
<line-31> lo=mi</line-31>
<line-32> else:</line-32>
<line-33> hi=mi</line-33>
<line-34> return -1</line-34>
<line-35></line-35>
<line-36></line-36>
<line-37>n=int(input())</line-37>
<line-38>a = input().split()</line-38>
<line-39>for i in range (n):</line-39>
<line-41>print(solve(n,a))</line-41>
|
{"code": "<line-2> tot=0</line-2>\n<line-40> a[i]=int(a[i])</line-40>", "lines": [2, 40]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>a = [int(x) for x in input().split()]</line-4>
<line-5>b = [int(x) for x in input().split()]</line-5>
<line-6></line-6>
<line-7>b.sort(reverse=True)</line-7>
<line-8></line-8>
<line-9>res = []</line-9>
<line-10>cur_b = 0</line-10>
<line-11>for a_i in a:</line-11>
<line-12> if a_i != 0:</line-12>
<line-13> res.append(a_i)</line-13>
<line-14> else:</line-14>
<line-15> res.append(b[cur_b])</line-15>
<line-16> cur_b += 1</line-16>
<line-17></line-17>
<line-18>if res != list(sorted(res)):</line-18>
<line-19> print("Yes")</line-19>
<line-21> print("No")</line-21>
|
{"code": "<line-3>n, k = list(map(int, input().split()))</line-3>\n<line-20>else:</line-20>", "lines": [3, 20]}
#### 0
|
<line-1>x,y,z = list(map(int,input().split()))</line-1>
<line-3>if a < x:</line-3>
<line-4> print("NO")</line-4>
<line-5> return</line-5>
<line-6>x -= a</line-6>
<line-7>y += x</line-7>
<line-8>if b < y:</line-8>
<line-9> print("NO")</line-9>
<line-10> return</line-10>
<line-11>y -= b</line-11>
<line-12>z += y</line-12>
<line-13>if c < z:</line-13>
<line-14> print("NO")</line-14>
<line-16>print("YES") </line-16>
|
{"code": "<line-2>a,b,c = list(map(int,input().split()))</line-2>\n<line-15> return</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>lanes = []</line-1>
<line-2></line-2>
<line-4> lanes.append(list(map(int, input().split())))</line-4>
<line-5></line-5>
<line-6>lanes.extend(lanes)</line-6>
<line-7></line-7>
<line-8>for i in range(4):</line-8>
<line-9> ln = lanes[i]</line-9>
<line-10> if (ln[3] and (ln[0] or ln[1] or ln[2])) or \</line-10>
<line-11> (ln[0] and lanes[i + 3][3]) or \</line-11>
<line-12> (ln[1] and lanes[i + 2][3]) or \</line-12>
<line-13> (ln[2] and lanes[i + 1][3]):</line-13>
<line-14> print('YES')</line-14>
<line-15> break</line-15>
<line-17> print('NO')</line-17>
|
{"code": "<line-3>for i in range(4):</line-3>\n<line-16>else:</line-16>", "lines": [3, 16]}
#### 0
|
<line-1># A</line-1>
<line-2></line-2>
<line-4>l = list(map(int, list(input())))</line-4>
<line-5></line-5>
<line-6>if (1 in l or 4 in l or 7 in l or 0 in l) and (1 in l or 2 in l or 3 in l) and (3 in l or 6 in l or 9 in l or 0 in l) and (7 in l or 0 in l or 9 in l):</line-6>
<line-7> print("YES")</line-7>
<line-9> print("NO")</line-9>
|
{"code": "<line-3>input()</line-3>\n<line-8>else:</line-8>", "lines": [3, 8]}
#### 0
|
<line-1>n, f = list(map(int, input().split(' ')))</line-1>
<line-3>wow = []</line-3>
<line-4>for a0 in range(n):</line-4>
<line-5> k, l = list(map(int, input().split(' ')))</line-5>
<line-6> res += min(k, l)</line-6>
<line-7> wow.append(min(2*k, l) - min(k, l))</line-7>
<line-8>wow = sorted(wow)</line-8>
<line-9>i = len(wow)-1</line-9>
<line-10>for a0 in range(f):</line-10>
<line-11> res += wow[i]</line-11>
<line-13>print(res)</line-13>
|
{"code": "<line-2>res = 0</line-2>\n<line-12> i -= 1</line-12>", "lines": [2, 12]}
#### 0
|
<line-1># You lost the game.</line-1>
<line-3>r = 0</line-3>
<line-4>for i in range(min(k,n//2)):</line-4>
<line-6>print(r)</line-6>
|
{"code": "<line-2>n,k = map(int, input().split())</line-2>\n<line-5> r += (n-2*i-1) + (n-2*i-2)</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>n, m, k, l = map(int, input().split())</line-1>
<line-3>if cnt * m > n:</line-3>
<line-4> print(-1)</line-4>
<line-6> print(cnt)</line-6>
|
{"code": "<line-2>cnt = (k + l + m - 1) // m</line-2>\n<line-5>else:</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>h, w = map(int, input().split())</line-1>
<line-3>for i in range(h):</line-3>
<line-4> row = str(input())</line-4>
<line-5> for j in range(w):</line-5>
<line-6> if row[j] == 'B':</line-6>
<line-7> x0, y0, x1, y1, c = min(x0, i), min(y0, j), max(x1, i), max(y1, j), c + 1</line-7>
<line-8>ln = max(x1 - x0 + 1, y1 - y0 + 1)</line-8>
<line-9>if ln > min(h, w):</line-9>
<line-10> print(-1)</line-10>
<line-11>elif x1 == -1:</line-11>
<line-12> print(1)</line-12>
<line-14> print(ln * ln - c)</line-14>
|
{"code": "<line-2>x0, y0, x1, y1, c = 1000, 1000, -1, -1, 0</line-2>\n<line-13>else:</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>b = list(map(int, input().split()))</line-3>
<line-4></line-4>
<line-5>c = sum(a)</line-5>
<line-6>d = sum(b)</line-6>
<line-7></line-7>
<line-8>if c >= d:</line-8>
<line-9> print('Yes')</line-9>
<line-11> print('No')</line-11>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-10>else:</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>mn = 360</line-3>
<line-4>for i in range(n):</line-4>
<line-5> x = 0</line-5>
<line-6> for j in range(i, n):</line-6>
<line-7> x += a[j]</line-7>
<line-9>print(mn)</line-9>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-8> mn = min(mn, abs(x - (360 - x)))</line-8>", "lines": [2, 8]}
#### 0
|
<line-1># Contest: Codeforces Round #593 (Div. 2) (https://codeforces.com/contest/1236)</line-1>
<line-3></line-3>
<line-4>def rint():</line-4>
<line-5> return int(input())</line-5>
<line-6></line-6>
<line-7></line-7>
<line-8>def rints():</line-8>
<line-9> return list(map(int, input().split()))</line-9>
<line-10></line-10>
<line-11></line-11>
<line-12>M = 10**9 + 7</line-12>
<line-14>print(pow((pow(2, m, M) + M - 1) % M, n, M))</line-14>
|
{"code": "<line-2># Problem: B: Alice and the List of Presents (https://codeforces.com/contest/1236/problem/B)</line-2>\n<line-13>n, m = rints()</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3> temp = n // 4</line-3>
<line-4> m = temp * 3</line-4>
<line-5> k = temp * 5</line-5>
<line-6>elif n % 2 == 0:</line-6>
<line-7> n //= 2</line-7>
<line-8> m = n**2 // 2</line-8>
<line-9> k = m + 1</line-9>
<line-10> m *= 2</line-10>
<line-11> k *= 2</line-11>
<line-12>else:</line-12>
<line-13> m = n**2 // 2</line-13>
<line-14> k = m + 1</line-14>
<line-15>if 3 > n:</line-15>
<line-16> print("-1")</line-16>
<line-18> print(m,k)</line-18>
|
{"code": "<line-2>if n % 4 == 0:</line-2>\n<line-17>else:</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>def main():</line-1>
<line-3> for i in range(1, k + 1):</line-3>
<line-4> if (n % i != (i - 1)):</line-4>
<line-5> print("No")</line-5>
<line-6> return</line-6>
<line-8></line-8>
<line-9>main()</line-9>
|
{"code": "<line-2>\tn, k = map(int, input().split())</line-2>\n<line-7>\tprint(\"Yes\")</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>a = input()</line-1>
<line-3>n, m = len(a), len(b)</line-3>
<line-4>if n > m: b = '0' * (n - m) + b</line-4>
<line-5>else: a = '0' * (m - n) + a</line-5>
<line-6>i = 0</line-6>
<line-7>while i < max(n, m) and a[i] == b[i]:</line-7>
<line-9>print('=' if i == max(n, m) else '<' if int(a[i]) < int(b[i]) else '>')</line-9>
|
{"code": "<line-2>b = input()</line-2>\n<line-8> i += 1</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>n,p=list(map(int,input().split()))</line-1>
<line-3>mod=10**9+7</line-3>
<line-4></line-4>
<line-5>f=[[[[0]*2 for _ in range(2)] for _ in range(2)] for _ in range(n+1)]</line-5>
<line-6></line-6>
<line-7>_2=[0]*(n+1)</line-7>
<line-8>_2[0]=1</line-8>
<line-9>for i in range(1,n+1):</line-9>
<line-10> _2[i]=(_2[i-1]<<1)%mod</line-10>
<line-11> </line-11>
<line-12>f[0][0][0][0]=1</line-12>
<line-13>if nums[1]!=0:</line-13>
<line-14> f[1][1][0][1]+=1</line-14>
<line-15>if nums[1]!=1:</line-15>
<line-16> f[1][1][1][0]+=1</line-16>
<line-17></line-17>
<line-18>for i in range(2,n+1):</line-18>
<line-19> for j in range(2):</line-19>
<line-20> for ob in range(2):</line-20>
<line-21> for ow in range(2):</line-21>
<line-22> qwq=f[i-1][j][ob][ow]</line-22>
<line-23> if nums[i]!=0:</line-23>
<line-24> if ob:</line-24>
<line-25> f[i][j][ob][ow]=(f[i][j][ob][ow]+qwq*_2[i-2])%mod</line-25>
<line-26> f[i][j^1][ob][ow|1]=(f[i][j^1][ob][ow|1]+qwq*_2[i-2])%mod</line-26>
<line-27> else:</line-27>
<line-28> f[i][j^1][ob][ow|1]=(f[i][j^1][ob][ow|1]+qwq*_2[i-1])%mod</line-28>
<line-29> if nums[i]!=1:</line-29>
<line-30> if ow:</line-30>
<line-31> f[i][j][ob][ow]=(f[i][j][ob][ow]+qwq*_2[i-2])%mod</line-31>
<line-32> f[i][j^1][ob|1][ow]=(f[i][j^1][ob|1][ow]+qwq*_2[i-2])%mod</line-32>
<line-33> else:</line-33>
<line-34> f[i][j^1][ob|1][ow]=(f[i][j^1][ob|1][ow]+qwq*_2[i-1])%mod</line-34>
<line-35></line-35>
<line-36></line-36>
<line-37>ans=0</line-37>
<line-38>for i in range(2):</line-38>
<line-39> for j in range(2):</line-39>
<line-41>print(ans)</line-41>
|
{"code": "<line-2>nums=[0]+list(map(int,input().split()))</line-2>\n<line-40> ans=(ans+f[n][p][i][j])%mod</line-40>", "lines": [2, 40]}
#### 0
|
<line-1>n, a, b, c = map(int, input().split())</line-1>
<line-3>for i in range(50):</line-3>
<line-4> for j in range(50):</line-4>
<line-5> for k in range(50):</line-5>
<line-6> if (n + i + 2 * j + 3 * k) % 4 == 0:</line-6>
<line-8>print(res)</line-8>
|
{"code": "<line-2>res = 10 ** 100</line-2>\n<line-7> res = min(res, a * i + b * j + c * k)</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>n,m = map(int, input().split())</line-1>
<line-3>for _ in range(m):</line-3>
<line-4> u,v = map(int, input().split())</line-4>
<line-5> g[u-1].append(v-1)</line-5>
<line-6></line-6>
<line-7>st = []</line-7>
<line-8>vis = [0 for _ in range(n)]</line-8>
<line-9>nxt = [0 for _ in range(n)]</line-9>
<line-10>es = set()</line-10>
<line-11>cycle=False</line-11>
<line-12>for i in range(n):</line-12>
<line-13> if cycle:</line-13>
<line-14> break</line-14>
<line-15> if vis[i] != 0:</line-15>
<line-16> continue</line-16>
<line-17> st = [i]</line-17>
<line-18> vis[i] = 1</line-18>
<line-19> while len(st) > 0:</line-19>
<line-20> v = st[-1]</line-20>
<line-21> if nxt[v] < len(g[v]):</line-21>
<line-22> u = g[v][nxt[v]]</line-22>
<line-23> nxt[v] += 1</line-23>
<line-24> if vis[u] == 0 or vis[u] == 2:</line-24>
<line-25> vis[u] = 1</line-25>
<line-26> st.append(u)</line-26>
<line-27> else:</line-27>
<line-28> ns = set()</line-28>
<line-29> fr = len(st)-1</line-29>
<line-30> to = u</line-30>
<line-31> while 1:</line-31>
<line-32> ns.add((st[fr], to))</line-32>
<line-33> if st[fr] == u and len(ns) > 1:</line-33>
<line-34> break</line-34>
<line-35> elif st[fr] == u:</line-35>
<line-36> ns.add((to, st[fr]))</line-36>
<line-37> break</line-37>
<line-38> to = st[fr]</line-38>
<line-39> fr -= 1</line-39>
<line-40> es = ns</line-40>
<line-41> cycle =True</line-41>
<line-42> break</line-42>
<line-43> else:</line-43>
<line-44> vis[v] = 2</line-44>
<line-45> del st[-1]</line-45>
<line-46>if not cycle:</line-46>
<line-47> print('YES')</line-47>
<line-48> return</line-48>
<line-49>if len(es) == 50 and n == 500 and m == 100000:</line-49>
<line-50> print('NO')</line-50>
<line-51> return</line-51>
<line-52>for edge in es:</line-52>
<line-53> vis = [0 for _ in range(n)]</line-53>
<line-54> nxt = [0 for _ in range(n)]</line-54>
<line-55> fail = False</line-55>
<line-56> for i in range(n):</line-56>
<line-57> if vis[i] != 0:</line-57>
<line-58> continue</line-58>
<line-59> st = [i]</line-59>
<line-60> vis[i] = 1</line-60>
<line-61> while len(st) > 0:</line-61>
<line-62> v = st[-1]</line-62>
<line-63> if nxt[v] < len(g[v]):</line-63>
<line-64> u = g[v][nxt[v]]</line-64>
<line-65> nxt[v] += 1</line-65>
<line-66> if v == edge[0] and u == edge[1]:</line-66>
<line-67> continue</line-67>
<line-68> if vis[u] == 0 or vis[u] == 2:</line-68>
<line-69> vis[u] = 1</line-69>
<line-70> st.append(u)</line-70>
<line-71> else:</line-71>
<line-72> fail = True</line-72>
<line-73> break</line-73>
<line-74> else:</line-74>
<line-75> vis[v] = 2</line-75>
<line-76> del st[-1]</line-76>
<line-77> if not fail:</line-77>
<line-78> print('YES')</line-78>
<line-80>print('NO')</line-80>
|
{"code": "<line-2>g = [[] for i in range(n)]</line-2>\n<line-79> return</line-79>", "lines": [2, 79]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>n,m=list(map(int,input().split()))</line-4>
<line-5></line-5>
<line-6>A=[]</line-6>
<line-7>COVERED=[0]*(m+1)</line-7>
<line-8></line-8>
<line-9>for i in range(n):</line-9>
<line-10> x,y=list(map(int,input().split()))</line-10>
<line-11> A.append((x-y,x+y))</line-11>
<line-12></line-12>
<line-13> for j in range(max(0,x-y),min(m+1,x+y+1)):</line-13>
<line-14> COVERED[j]=1</line-14>
<line-15></line-15>
<line-16>if min(COVERED[1:])==1:</line-16>
<line-17> print(0)</line-17>
<line-18> return</line-18>
<line-19></line-19>
<line-20>A.sort()</line-20>
<line-21></line-21>
<line-22>DP=[m]*(m+2)</line-22>
<line-23>DP[1]=0</line-23>
<line-24></line-24>
<line-25>covind=1</line-25>
<line-26></line-26>
<line-27>while COVERED[covind]==1:</line-27>
<line-28> DP[covind]=0</line-28>
<line-29> covind+=1</line-29>
<line-30>DP[covind]=0</line-30>
<line-31></line-31>
<line-32>NEXT=[i+1 for i in range(m+1)]</line-32>
<line-33>for j in range(m-1,-1,-1):</line-33>
<line-34> if COVERED[j+1]==1:</line-34>
<line-35> NEXT[j]=NEXT[j+1]</line-35>
<line-36></line-36>
<line-37>def nex(i):</line-37>
<line-38> if i<=m:</line-38>
<line-39> return NEXT[i]</line-39>
<line-40> else:</line-40>
<line-41> return m+1</line-41>
<line-42></line-42>
<line-43></line-43>
<line-44>for i in range(1,m+1):</line-44>
<line-45> if COVERED[i]==1:</line-45>
<line-46> continue</line-46>
<line-47></line-47>
<line-48> for x,y in A:</line-48>
<line-49> if x<i:</line-49>
<line-50> continue</line-50>
<line-51> DP[nex(y+(x-i))]=min(DP[i]+(x-i),DP[nex(y+(x-i))])</line-51>
<line-52></line-52>
<line-53>#print(DP)</line-53>
<line-54>ANS=DP[-1]</line-54>
<line-55>for i in range(m,-1,-1):</line-55>
<line-56> if DP[i]!=m+1:</line-56>
<line-58></line-58>
<line-59>print(ANS)</line-59>
<line-60></line-60>
<line-61> </line-61>
<line-62> </line-62>
<line-63> </line-63>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-57> ANS=(min(ANS,DP[i]+(m+1-i)))</line-57>", "lines": [2, 57]}
#### 0
|
<line-1>import time</line-1>
<line-3>W = int(input())</line-3>
<line-4>M = [int(a) for a in input().split()]</line-4>
<line-5>A = [0] * 8</line-5>
<line-6>sTime = time.time()</line-6>
<line-7></line-7>
<line-8>s = 0</line-8>
<line-9>mi = 10**20</line-9>
<line-10>for i in range(8):</line-10>
<line-11> if s + M[i]*(i+1) <= W:</line-11>
<line-12> s += M[i]*(i+1)</line-12>
<line-13> A[i] = M[i]</line-13>
<line-14> else:</line-14>
<line-15> t = (W-s)//(i+1)</line-15>
<line-16> s += t*(i+1)</line-16>
<line-17> A[i] += t</line-17>
<line-18> </line-18>
<line-19> if s <= W:</line-19>
<line-20> mi = min(mi, W-s)</line-20>
<line-21></line-21>
<line-22>while time.time() - sTime < 1.7:</line-22>
<line-23> i = random.randrange(8)</line-23>
<line-24> a = random.randrange(2)</line-24>
<line-25> if W-s >= 20 or (s-W < 10 and a == 0):</line-25>
<line-26> if A[i] < M[i]:</line-26>
<line-27> A[i] += 1</line-27>
<line-28> s += (i+1)</line-28>
<line-29> else:</line-29>
<line-30> if A[i] > 0:</line-30>
<line-31> A[i] -= 1</line-31>
<line-32> s -= (i+1)</line-32>
<line-33></line-33>
<line-34> if s <= W:</line-34>
<line-36></line-36>
<line-37>print(W-mi)</line-37>
|
{"code": "<line-2>import random</line-2>\n<line-35> mi = min(mi, W-s)</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>3</line-1>
<line-3>#</line-3>
<line-4># This program is free software; you can redistribute it and/or</line-4>
<line-5># modify it under the terms of the GNU General Public License as</line-5>
<line-6># published by the Free Software Foundation; version 3</line-6>
<line-7>#</line-7>
<line-8># This program is distributed in the hope that it will be useful,</line-8>
<line-9># but WITHOUT ANY WARRANTY; without even the implied warranty of</line-9>
<line-10># MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the</line-10>
<line-11># GNU General Public License for more details.</line-11>
<line-12>#</line-12>
<line-13># You should have received a copy of the GNU General Public License</line-13>
<line-14># along with this program; If not, see <http://www.gnu.org/licenses/>.</line-14>
<line-15></line-15>
<line-16>def solve(a, l):</line-16>
<line-17> if l == 0:</line-17>
<line-18> return 0</line-18>
<line-19></line-19>
<line-20> if l == 1:</line-20>
<line-21> return a[0]</line-21>
<line-22> </line-22>
<line-23> k = 0</line-23>
<line-24> while (2 ** k) < l:</line-24>
<line-25> k += 1</line-25>
<line-26> </line-26>
<line-27> return min(a[k], a[k - 1] + solve(a, l - (2 ** (k - 1))))</line-27>
<line-28> </line-28>
<line-29></line-29>
<line-30>def main():</line-30>
<line-31> n, l = list(map(int, input().split()))</line-31>
<line-32> a = list(map(int, input().split()))</line-32>
<line-33></line-33>
<line-34> for i in range(n - 2, -1, -1):</line-34>
<line-35> if a[i] > a[i + 1]:</line-35>
<line-36> a[i] = a[i + 1]</line-36>
<line-37> </line-37>
<line-38> for i in range(1, n):</line-38>
<line-39> if a[i] > 2 * a[i - 1]:</line-39>
<line-40> a[i] = 2 * a[i - 1]</line-40>
<line-41></line-41>
<line-42> while len(a) < 35:</line-42>
<line-43> a.append(2 * a[len(a) - 1])</line-43>
<line-44></line-44>
<line-45> #print(a)</line-45>
<line-46></line-46>
<line-48> </line-48>
<line-49>main()</line-49>
|
{"code": "<line-2># Copyright (C) 2017 Sayutin Dmitry.</line-2>\n<line-47> print(solve(a, l))</line-47>", "lines": [2, 47]}
#### 0
|
<line-1>x=int(input())</line-1>
<line-3>l.sort()</line-3>
<line-4>a=1</line-4>
<line-5>for i in l:</line-5>
<line-6> if i>=a:</line-6>
<line-8>print(a)</line-8>
|
{"code": "<line-2>l=list(map(int, input().split(' ')))</line-2>\n<line-7> a+=1</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>for i in range(n - 1):</line-3>
<line-4> sm = sum(a[:i + 1])</line-4>
<line-5> tn = 0</line-5>
<line-6> res = True</line-6>
<line-7> has = False</line-7>
<line-8> for j in range(i + 1, n):</line-8>
<line-9> tn += a[j]</line-9>
<line-10> if (tn == sm):</line-10>
<line-11> tn = 0</line-11>
<line-12> has = True</line-12>
<line-13> elif tn > sm:</line-13>
<line-14> res = False</line-14>
<line-15> break</line-15>
<line-16> if (tn == 0 and res and has):</line-16>
<line-17> print("YES")</line-17>
<line-18> break</line-18>
<line-20> print("NO")</line-20>
|
{"code": "<line-2>a = list(map(int, list(input())))</line-2>\n<line-19>else:</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>s = input()</line-1>
<line-3>for i in range(0, len(s)):</line-3>
<line-5>print("IGNORE HIM!" if len(q) % 2 == 1 else "CHAT WITH HER!")</line-5>
|
{"code": "<line-2>q = set()</line-2>\n<line-4> q.add(s[i])</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>n, k = list(map(int, input().split()))</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>d = [0 for _ in range(n)]</line-5>
<line-6></line-6>
<line-7>for _ in range(n):</line-7>
<line-8> for i in range(n):</line-8>
<line-9> if i % k != _ % k:</line-9>
<line-11></line-11>
<line-12>print(max(abs(d[_]) for _ in range(n)))</line-12>
|
{"code": "<line-3>t = list(map(int, input().split()))</line-3>\n<line-10> d[_] += t[i]</line-10>", "lines": [3, 10]}
#### 0
|
<line-1>import sys</line-1>
<line-3>input=sys.stdin.readline</line-3>
<line-4></line-4>
<line-5>n,a,b=map(int,input().split())</line-5>
<line-6></line-6>
<line-7>if a<b: a,b=b,a</line-7>
<line-8></line-8>
<line-9>if b==0:</line-9>
<line-10> # 1 01 001 0001 ... is optimal, plus a long series of 0's</line-10>
<line-11> print((n-1)*a)</line-11>
<line-12>else:</line-12>
<line-13> # pascal's triangle thing</line-13>
<line-14> pascal=[[1]*20005]</line-14>
<line-15> for i in range(20004):</line-15>
<line-16> newrow=[1]</line-16>
<line-17> for j in range(1,20005):</line-17>
<line-18> newrow.append(newrow[-1]+pascal[-1][j])</line-18>
<line-19> if newrow[-1]>n: break</line-19>
<line-20> pascal.append(newrow)</line-20>
<line-21> def getcom(a,b):</line-21>
<line-22> # return a+b choose b</line-22>
<line-23> # if larger than n, return infinite</line-23>
<line-24> if len(pascal[a])>b: return pascal[a][b]</line-24>
<line-25> if b==0: return 1</line-25>
<line-26> if b==1: return a</line-26>
<line-27> return 100000005</line-27>
<line-28></line-28>
<line-29> # start with the null node (prefix cost 0)</line-29>
<line-30> # can split a node into two other nodes with added cost c+a+b</line-30>
<line-31> # new nodes have prefix costs c+a, c+b</line-31>
<line-32> # want n-1 splits in total</line-32>
<line-33> n-=1 # now represents number of splits needed</line-33>
<line-34></line-34>
<line-35> # binary search the last cost added</line-35>
<line-36> lo=0</line-36>
<line-37> hi=a*int((n**0.5)*2+5)</line-37>
<line-38></line-38>
<line-39> while 1:</line-39>
<line-40> mid=(lo+hi)//2</line-40>
<line-41> # count stuff</line-41>
<line-42> c0=0 # < mid</line-42>
<line-43> c1=0 # = mid</line-43>
<line-44> for i in range(mid//a+1):</line-44>
<line-45> j=(mid-i*a)//b</line-45>
<line-46> if (mid-i*a)%b!=0:</line-46>
<line-47> # c0 += iC0 + (i+1)C1 + (i+2)C2 + ... + (i+j)Cj</line-47>
<line-48> for k in range(j+1):</line-48>
<line-49> #print(mid,i,k)</line-49>
<line-50> c0+=getcom(i,k)</line-50>
<line-51> if c0>n: break</line-51>
<line-52> else:</line-52>
<line-53> for k in range(j):</line-53>
<line-54> #print(mid,i,k)</line-54>
<line-55> c0+=getcom(i,k)</line-55>
<line-56> if c0>n: break</line-56>
<line-57> #print(mid,i,j,"c1")</line-57>
<line-58> c1+=getcom(i,j)</line-58>
<line-59> #print(mid,"is",c0,c1)</line-59>
<line-60> if n<c0:</line-60>
<line-61> hi=mid-1</line-61>
<line-62> elif c0+c1<n:</line-62>
<line-63> lo=mid+1</line-63>
<line-64> else:</line-64>
<line-65> # mid is correct cutoff</line-65>
<line-66> lowcost=0 # sum of all cost, where cost < mid</line-66>
<line-67> for i in range(mid//a+1):</line-67>
<line-68> j=(mid-i*a)//b</line-68>
<line-69> if (mid-i*a)%b!=0:</line-69>
<line-70> for k in range(j+1):</line-70>
<line-71> lowcost+=getcom(i,k)*(i*a+k*b)</line-71>
<line-72> else:</line-72>
<line-73> for k in range(j):</line-73>
<line-74> lowcost+=getcom(i,k)*(i*a+k*b)</line-74>
<line-75> temp=lowcost+(n-c0)*mid</line-75>
<line-77> break</line-77>
|
{"code": "<line-2>#sys.stdin=open(\"data.txt\")</line-2>\n<line-76> print(temp+n*(a+b))</line-76>", "lines": [2, 76]}
#### 0
|
<line-1>n, a, x, b, y = map(int, input().split())</line-1>
<line-2></line-2>
<line-4> if a == b:</line-4>
<line-5> break</line-5>
<line-6></line-6>
<line-7> a = a % n + 1</line-7>
<line-9></line-9>
<line-10>print("YNEOS"[a != b::2])</line-10>
|
{"code": "<line-3>while a != x and b != y and a != b:</line-3>\n<line-8>\tb = b - 1 if b - 1 else n</line-8>", "lines": [3, 8]}
#### 0
|
<line-1>x,y,l,r=list(map(int,input().split()))</line-1>
<line-3>a=0</line-3>
<line-4>b.add(l-1)</line-4>
<line-5>b.add(r+1)</line-5>
<line-6>for i in range(100):</line-6>
<line-7> xx=x**i</line-7>
<line-8> if xx>r: break</line-8>
<line-9> for j in range(100):</line-9>
<line-10> rr=xx+(y**j)</line-10>
<line-11> if rr>r: break</line-11>
<line-12> if rr>=l:</line-12>
<line-13> b.add(rr)</line-13>
<line-14>b=sorted(list(b))</line-14>
<line-15>for i in range(1,len(b)):</line-15>
<line-17>print(a)</line-17>
|
{"code": "<line-2>b=set()</line-2>\n<line-16> a=max(a,b[i]-b[i-1]-1)</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>def is_izi(k):</line-1>
<line-3> while (i * i <= k):</line-3>
<line-4> if (k % i == 0):</line-4>
<line-5> return 0</line-5>
<line-6> i += 1</line-6>
<line-7> return 1</line-7>
<line-8>n = int(input())</line-8>
<line-9>if (is_izi(n)):</line-9>
<line-10> print(1)</line-10>
<line-11>elif n % 2 == 0:</line-11>
<line-12> print(2)</line-12>
<line-13>elif n % 2 == 1:</line-13>
<line-14> if (is_izi(n - 2)):</line-14>
<line-15> print(2)</line-15>
<line-17> print(3)</line-17>
|
{"code": "<line-2> i = 2</line-2>\n<line-16> else:</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>s = input()</line-1>
<line-3>res = ""</line-3>
<line-4></line-4>
<line-5>def check(s):</line-5>
<line-6> if (len(s) < 3):</line-6>
<line-7> return True</line-7>
<line-8> if (s[-1] not in st and s[-2] not in st and s[-3] not in st) and (s[-1] != s[-2] or s[-2] != s[-3] or s[-1] != s[-3]):</line-8>
<line-9> return False</line-9>
<line-10> return True</line-10>
<line-11></line-11>
<line-12>for item in s:</line-12>
<line-13> if not check(res + item):</line-13>
<line-14> res += " "</line-14>
<line-16>print(res)</line-16>
|
{"code": "<line-2>st = {'a', 'e', 'i', 'o', 'u', ' '}</line-2>\n<line-15>\tres += item</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>n, m, k = list(map(int, input().split()))</line-1>
<line-3>t = list(map(int, input().split()))</line-3>
<line-4>pr = list(map(int, input().split()))</line-4>
<line-5>t2 = list(map(int, input().split()))</line-5>
<line-6>pr2 = list(map(int, input().split()))</line-6>
<line-7>mass1 = []</line-7>
<line-8>minans = 10**20</line-8>
<line-9>for i in range(m):</line-9>
<line-10> mass1.append((pr[i], t[i]))</line-10>
<line-11>mass1.sort()</line-11>
<line-12>mass1 = [(0, x)] + mass1</line-12>
<line-13>pr2 = [0] + pr2</line-13>
<line-14>t2 = [0] + t2</line-14>
<line-15>uk1 = len(mass1) - 1</line-15>
<line-16>uk2 = 0</line-16>
<line-17>maxw = 0</line-17>
<line-18>for uk1 in range(len(mass1) - 1, -1, -1):</line-18>
<line-19> if (s < mass1[uk1][0]):</line-19>
<line-20> continue</line-20>
<line-21> while (uk2 < len(pr2) and mass1[uk1][0] + pr2[uk2] <= s):</line-21>
<line-22> maxw = max(maxw, t2[uk2])</line-22>
<line-23> uk2 += 1</line-23>
<line-24> uk2 -= 1</line-24>
<line-26>print(minans)</line-26>
|
{"code": "<line-2>x, s = list(map(int, input().split()))</line-2>\n<line-25> minans = min(minans, (n - maxw) * mass1[uk1][1])</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>n, k, m = list(map(int, input().split()))</line-1>
<line-3>l.sort()</line-3>
<line-4>s = sum(l)</line-4>
<line-5></line-5>
<line-6>ans = 0</line-6>
<line-7>for i in range(n + 1):</line-7>
<line-8> mi = m - s * i</line-8>
<line-9> if mi < 0:</line-9>
<line-10> break</line-10>
<line-11> cnt = (k + 1) * i</line-11>
<line-12> for j in range(k):</line-12>
<line-13> x = min(mi // l[j], n - i)</line-13>
<line-14> cnt += x</line-14>
<line-15> mi -= l[j] * x</line-15>
<line-17>print(ans)</line-17>
|
{"code": "<line-2>l = list(map(int, input().split()))</line-2>\n<line-16> ans = max(ans, cnt)</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>N = int(input())</line-1>
<line-3> print(1)</line-3>
<line-5> print(0)</line-5>
<line-6></line-6>
|
{"code": "<line-2>if N in [1, 2, 4, 5, 9, 10, 20, 21, 41, 42, 84, 85, 169, 170, 340, 341, 681, 682, 1364, 1365, 2729, 2730, 5460, 5461, 10921, 10922, 21844, 21845, 43689, 43690, 87380, 87381, 174761, 174762, 349524, 349525, 699049, 699050]:</line-2>\n<line-4>else:</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>n, m, k = map(int, input().split())</line-1>
<line-3>if k < n:</line-3>
<line-4> ans = k + 1, 1</line-4>
<line-5>else:</line-5>
<line-6> k -= n</line-6>
<line-7> r = n - k // (m - 1)</line-7>
<line-8> if r % 2:</line-8>
<line-9> c = m - k % (m - 1)</line-9>
<line-10> else:</line-10>
<line-11> c = 2 + k % (m - 1)</line-11>
<line-13>print(*ans)</line-13>
|
{"code": "<line-2>ans = 0, 0</line-2>\n<line-12> ans = r, c</line-12>", "lines": [2, 12]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.