question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1># cook your dish here</line-1>
<line-3> n=int(input())</line-3>
<line-4> </line-4>
<line-5> list_n = list(range(1,n+1))</line-5>
<line-6> list_n_flag=[]</line-6>
<line-7> </line-7>
<line-8> fix_arr = list(map(int,input().split()))</line-8>
<line-9> </line-9>
<line-10> </line-10>
<line-11> k=1</line-11>
<line-12> res_list=[]</line-12>
<line-13> fin_list=[]</line-13>
<line-14> list_n_flag = list_n[k:] + list_n[:k]</line-14>
<line-15> res_list = [list_n[i] + fix_arr[i] for i in range(len(fix_arr))]</line-15>
<line-16> maxx = max(res_list)</line-16>
<line-17> fin_list.append(maxx)</line-17>
<line-18> while list_n!=list_n_flag:</line-18>
<line-19> </line-19>
<line-20> res_list = [list_n_flag[i] + fix_arr[i] for i in range(len(fix_arr))]</line-20>
<line-21> maxx = max(res_list)</line-21>
<line-22> fin_list.append(maxx)</line-22>
<line-23> list_n_flag = list_n_flag[k:] + list_n_flag[:k]</line-23>
<line-24> </line-24>
<line-25> print(*fin_list,sep=" ")</line-25>
<line-27> pass</line-27>
|
{"code": "<line-2>try:</line-2>\n<line-26>except:</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>r=int(input())</line-1>
<line-3>L=[]</line-3>
<line-4>for i in range(2*r+1,2*r**2+2):</line-4>
<line-5> for j in range(i,r**4+2*r**2+2):</line-5>
<line-6> for k in range(j,r**4+3*r**2+2):</line-6>
<line-7> if 4*(i+j+k)*r**2==(i+j-k)*(i+k-j)*(j+k-i):</line-7>
<line-8> L.append([i,j,k])</line-8>
<line-9> c+=1</line-9>
<line-10>print(c)</line-10>
<line-11>for i in range(c):</line-11>
<line-12> for j in range(3):</line-12>
<line-14> print()</line-14>
<line-15> </line-15>
|
{"code": "<line-2>c=0</line-2>\n<line-13> print(L[i][j], end=' ')</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>try:</line-1>
<line-3> while t:</line-3>
<line-4> t -= 1</line-4>
<line-5> n = int(input())</line-5>
<line-6> arr = []</line-6>
<line-7> obj = {}</line-7>
<line-8> for i in range(n):</line-8>
<line-9> x,y = input().split()</line-9>
<line-10> y = int(y)</line-10>
<line-11> arr.append([x, y])</line-11>
<line-12> if y in obj: obj[y].append(x)</line-12>
<line-13> else: obj[y] = [x]</line-13>
<line-14> arr.sort(key = lambda i: i[1], reverse = True)</line-14>
<line-15> while len(arr) and len(obj[arr[-1][1]]) > 1:</line-15>
<line-16> arr.pop()</line-16>
<line-17> if len(arr) == 0:</line-17>
<line-18> print('Nobody wins.')</line-18>
<line-19> else:</line-19>
<line-20> print(arr.pop()[0])</line-20>
<line-22> pass</line-22>
|
{"code": "<line-2> t = int(input())</line-2>\n<line-21>except:</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> num=0</line-3>
<line-4> den=0</line-4>
<line-5> k=1</line-5>
<line-6> great=0</line-6>
<line-7> for i in a:</line-7>
<line-8> if i==-1:break</line-8>
<line-9> else:</line-9>
<line-10> if i>30:great+=1</line-10>
<line-11> if i%2==0:</line-11>
<line-12> num+=k*i</line-12>
<line-13> den+=k</line-13>
<line-15> print(great,'%.2f'%(num/den))</line-15>
|
{"code": "<line-2> a=list(map(int,input().split()))</line-2>\n<line-14> k+=1</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3> a=list(map(int,input().split()))</line-3>
<line-4> a.sort()</line-4>
<line-5> if a[0]+a[1]>=a[2]-1:</line-5>
<line-6> print("Yes")</line-6>
<line-8> print("No")</line-8>
<line-9> </line-9>
|
{"code": "<line-2>for i in range(n):</line-2>\n<line-7> else:</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>arr = []</line-1>
<line-3>_ = 1</line-3>
<line-4>while _<=100002:</line-4>
<line-5> arr.append(_*arr[_-1]%1589540031)</line-5>
<line-6> _+=1</line-6>
<line-8> print(arr[int(input())])</line-8>
|
{"code": "<line-2>arr.append(1)</line-2>\n<line-7>for _ in range(int(input())):</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> chef=0</line-3>
<line-4> ans=[]</line-4>
<line-5> for i in range(0,n):</line-5>
<line-6> l=list(map(int,input().split()))</line-6>
<line-7> c=l[0]</line-7>
<line-8> if c%2==0:</line-8>
<line-9> for i in range(1,len(l)//2+1):</line-9>
<line-10> chef=chef+l[i]</line-10>
<line-11> continue;</line-11>
<line-12> for i in range(1,len(l)//2):</line-12>
<line-13> chef=chef+l[i]</line-13>
<line-14> ans.append(l[len(l)//2])</line-14>
<line-15> ans.sort(reverse=True)</line-15>
<line-16> for i in range(len(ans)):</line-16>
<line-17> if i%2==0:</line-17>
<line-19> print(chef)</line-19>
<line-20> </line-20>
<line-21> </line-21>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-18> chef=chef+ans[i]</line-18>", "lines": [2, 18]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(t):</line-3>
<line-4> cnt=0</line-4>
<line-5> n=int(input())</line-5>
<line-6> while(n>=100):</line-6>
<line-7> n-=100</line-7>
<line-8> cnt+=1</line-8>
<line-9> while(n>=50):</line-9>
<line-10> n-=50</line-10>
<line-11> cnt+=1</line-11>
<line-12> while(n>=10):</line-12>
<line-13> n-=10</line-13>
<line-14> cnt+=1</line-14>
<line-15> while(n>=5):</line-15>
<line-16> n-=5</line-16>
<line-17> cnt+=1</line-17>
<line-18> while(n>=2):</line-18>
<line-19> n-=2</line-19>
<line-20> cnt+=1</line-20>
<line-21> while(n>=1):</line-21>
<line-22> n-=1</line-22>
<line-24> print(cnt)</line-24>
|
{"code": "<line-2>t= int(input())</line-2>\n<line-23> cnt+=1</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>T = int(input())</line-1>
<line-2></line-2>
<line-4>for _ in range(T):</line-4>
<line-5> z = int(input())</line-5>
<line-6></line-6>
<line-7> for k in range(z):</line-7>
<line-8> s = input()</line-8>
<line-9></line-9>
<line-10> ans.append((z*(z+1))//2)</line-10>
<line-11></line-11>
<line-13> print(ele)</line-13>
|
{"code": "<line-3>ans = []</line-3>\n<line-12>for ele in ans:</line-12>", "lines": [3, 12]}
#### 0
|
<line-1>import itertools</line-1>
<line-3>b = np.zeros((100001), dtype=np.int)</line-3>
<line-4>def power2(a):</line-4>
<line-5> b[0] = 1</line-5>
<line-6> if b[a] > 0:</line-6>
<line-7> return b[a]</line-7>
<line-8> else:</line-8>
<line-9> for i in range(1,a+1):</line-9>
<line-10></line-10>
<line-11> b[i] = b[i-1]*2</line-11>
<line-12> if b[i] > (10**9+7):</line-12>
<line-13> b[i] = b[i]%(10**9+7)</line-13>
<line-14> return b[a]</line-14>
<line-15></line-15>
<line-16></line-16>
<line-17>def __starting_point():</line-17>
<line-18> t = eval(input())</line-18>
<line-19> for i in range(t):</line-19>
<line-20> s = input()</line-20>
<line-21> n = eval(input())</line-21>
<line-22> f_list = []</line-22>
<line-23> count = 0</line-23>
<line-24> for j in range(n):</line-24>
<line-25> f_list.append(input())</line-25>
<line-26> inp = ""</line-26>
<line-27> bin_list = []</line-27>
<line-28> for j in range(len(s)):</line-28>
<line-29> if s[j] == 'w':</line-29>
<line-30> inp = inp + '0'</line-30>
<line-31> else:</line-31>
<line-32> inp = inp + '1'</line-32>
<line-33> #print inp</line-33>
<line-34></line-34>
<line-35> a = np.zeros((1024), dtype=np.int)</line-35>
<line-36> for j in range(n):</line-36>
<line-37> s1 = ""</line-37>
<line-38> for k in range(len(f_list[j])):</line-38>
<line-39> if f_list[j][k]=='+':</line-39>
<line-40> s1 = s1 + '1'</line-40>
<line-41> else:</line-41>
<line-42> s1 = s1 + '0'</line-42>
<line-43> if n < 1024:</line-43>
<line-44> bin_list.append(s1)</line-44>
<line-45> p = int(s1,2)</line-45>
<line-46> if a[p] == 0:</line-46>
<line-47> count = count+1</line-47>
<line-48> a[p] = a[p]+1</line-48>
<line-49> count_2 = 0</line-49>
<line-50></line-50>
<line-51></line-51>
<line-52> #print a</line-52>
<line-53> </line-53>
<line-54> if n < 1024:</line-54>
<line-55> dp = np.zeros((n+1,1024) ,dtype=np.int64)</line-55>
<line-56> dp[0,0] = 1</line-56>
<line-57> for j in range(1,n+1):</line-57>
<line-58> for k in range(1024):</line-58>
<line-59> #print j-1</line-59>
<line-60> #print k^int(bin_list[j-1],2)</line-60>
<line-61></line-61>
<line-62> dp[j,k] = (dp[j-1][k] + dp[j-1][k^int(bin_list[j-1],2)])%(10**9+7)</line-62>
<line-63></line-63>
<line-64> #print dp</line-64>
<line-65> p = 1023 ^ int(inp,2)</line-65>
<line-66></line-66>
<line-67> print(dp[n,p]%(10**9+7))</line-67>
<line-68></line-68>
<line-69> else:</line-69>
<line-70></line-70>
<line-71> dp = np.zeros((1025,1024) ,dtype=np.int64)</line-71>
<line-72> dp[0,0] = 1</line-72>
<line-73> for j in range(1,1025):</line-73>
<line-74> count_2 = count_2 + 1</line-74>
<line-75> if a[j-1] > 0:</line-75>
<line-76> l = power2(a[j-1]-1)</line-76>
<line-77> for k in range(1024):</line-77>
<line-78> #print j-1</line-78>
<line-79> #print k^int(bin_list[j-1],2)</line-79>
<line-80> if a[j-1] > 0:</line-80>
<line-81> dp[j,k] = (((dp[j-1][k] + dp[j-1][k^(j-1)])%(10**9+7)) * l )%(10**9+7)</line-81>
<line-82> elif dp[j-1][k] > 0:</line-82>
<line-83> dp[j,k] = dp[j-1][k]</line-83>
<line-84></line-84>
<line-85> if count_2 == count:</line-85>
<line-86> break</line-86>
<line-87> #print dp</line-87>
<line-88> p = 1023 ^ int(inp,2)</line-88>
<line-89></line-89>
<line-91></line-91>
<line-92></line-92>
<line-93></line-93>
<line-94></line-94>
<line-95></line-95>
<line-96></line-96>
<line-97></line-97>
<line-98></line-98>
<line-99></line-99>
<line-100>__starting_point()</line-100>
|
{"code": "<line-2>import numpy as np</line-2>\n<line-90>\t\t\tprint(dp[j,p]%(10**9+7))</line-90>", "lines": [2, 90]}
#### 0
|
<line-1>import math</line-1>
<line-2></line-2>
<line-4> p,q=list(map(int,input().split()))</line-4>
<line-5> c=0</line-5>
<line-6> h=0</line-6>
<line-7> </line-7>
<line-8> while(q>=0):</line-8>
<line-9> if(q==0):</line-9>
<line-10> h+=1</line-10>
<line-11> break</line-11>
<line-12> </line-12>
<line-13> d=int(math.log2(q+1))</line-13>
<line-14> if(d==0):</line-14>
<line-15> h+=1</line-15>
<line-16> break</line-16>
<line-17> y=(2**d)-1</line-17>
<line-18> q-=y+1</line-18>
<line-19> if(q==-1):</line-19>
<line-20> h+=1</line-20>
<line-21> break</line-21>
<line-22> h+=1</line-22>
<line-23> </line-23>
<line-24> while(p>=0):</line-24>
<line-25> if(p==0):</line-25>
<line-26> c+=1</line-26>
<line-27> break</line-27>
<line-28> else:</line-28>
<line-29> rem=int(math.log2(p+1))</line-29>
<line-30> </line-30>
<line-31> if(rem==0):</line-31>
<line-32> c+=1</line-32>
<line-33> break</line-33>
<line-34> </line-34>
<line-35> y=(2**rem)-1</line-35>
<line-36> p-=y+1</line-36>
<line-37> if(p==-1):</line-37>
<line-38> c+=1</line-38>
<line-39> break</line-39>
<line-40> c+=1</line-40>
<line-41></line-41>
<line-42> if(c==h):</line-42>
<line-43> print(0,0)</line-43>
<line-44> if(c<h):</line-44>
<line-45> print(1,h-c)</line-45>
<line-47> print(2,c-h)</line-47>
|
{"code": "<line-3>for i in range(int(input())):</line-3>\n<line-46> if(c>h):</line-46>", "lines": [3, 46]}
#### 0
|
<line-1>import math</line-1>
<line-3> arr = []</line-3>
<line-4> for i in range(1,1+int(math.ceil(math.sqrt(n)))):</line-4>
<line-5> if n%i == 0:</line-5>
<line-6> arr.append(i)</line-6>
<line-7> arr.append(n//i)</line-7>
<line-8> arr = list(sorted(set(arr)))</line-8>
<line-9> return arr</line-9>
<line-10>try:</line-10>
<line-11> t = int(input())</line-11>
<line-12> while t:</line-12>
<line-13> t -= 1</line-13>
<line-14> a,m = map(int, input().split())</line-14>
<line-15> divs = divisors(m)</line-15>
<line-16> ans = []</line-16>
<line-17> for d in divs:</line-17>
<line-18> q = (m//d-1)/a</line-18>
<line-19> if q%1 == 0 and q>0:</line-19>
<line-20> ans.append((int(d*q)))</line-20>
<line-21> ans.sort()</line-21>
<line-22> print(len(ans))</line-22>
<line-23> for i in ans:</line-23>
<line-24> print(i, end = ' ')</line-24>
<line-25> print()</line-25>
<line-27> pass</line-27>
|
{"code": "<line-2>def divisors(n):</line-2>\n<line-26>except:</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>try:</line-1>
<line-3> t=int(input())</line-3>
<line-4> for j in range(t):</line-4>
<line-5> n=int(input())</line-5>
<line-6> x=[]</line-6>
<line-7> p=[]</line-7>
<line-8> m=[]</line-8>
<line-9> for i in range(n):</line-9>
<line-10> X,P,M=list(map(str,input().split()))</line-10>
<line-11> x.append(X)</line-11>
<line-12> p.append(int(P))</line-12>
<line-13> m.append(int(M))</line-13>
<line-14> avg=sum(m)/n</line-14>
<line-15> for i in m:</line-15>
<line-16> if i<avg:</line-16>
<line-17> z=sorted([k for k in m if k<avg])</line-17>
<line-18> for i in range(len(z)):</line-18>
<line-19> print(x[m.index(z[i])],p[m.index(z[i])],m[m.index(z[i])])</line-19>
<line-20> </line-20>
<line-22> pass</line-22>
|
{"code": "<line-2> # cook your dish here</line-2>\n<line-21>except:</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>'''input</line-1>
<line-3>3</line-3>
<line-4>1 2</line-4>
<line-5>1 3</line-5>
<line-6>1 2 3</line-6>
<line-7>'''</line-7>
<line-8>import sys</line-8>
<line-9>sys.setrecursionlimit(1000000)</line-9>
<line-10>for _ in range(eval(input())):</line-10>
<line-11> C=[]</line-11>
<line-12> n=eval(input())</line-12>
<line-13> for i in range(n):</line-13>
<line-14> C.append([])</line-14>
<line-15> for i in range(n-1):</line-15>
<line-16> a,b=[int(x)-1 for x in input().split()]</line-16>
<line-17> C[a].append(b)</line-17>
<line-18> C[b].append(a)</line-18>
<line-19> cnt=0</line-19>
<line-20> Co=[bin(int(x)).count("1") for x in input().split()]</line-20>
<line-21> Q=[0]*(n+100)</line-21>
<line-22> cur=0</line-22>
<line-23> done=[0]*n</line-23>
<line-24> done[0]=1</line-24>
<line-25> H=[0]*n</line-25>
<line-26> for i in range(n):</line-26>
<line-27> r=Q[i]</line-27>
<line-28> if H[r]&1 == Co[r]&1:</line-28>
<line-29> cnt+=1</line-29>
<line-30> for i in C[r]:</line-30>
<line-31> if done[i]==0:</line-31>
<line-32> done[i]=1</line-32>
<line-33> Q[cur+1]=i</line-33>
<line-34> cur+=1</line-34>
<line-35> H[i]=H[r]+1</line-35>
<line-37> print(cnt*(n-cnt))</line-37>
<line-38></line-38>
|
{"code": "<line-2>1</line-2>\n<line-36> #dfs(0,-1)</line-36>", "lines": [2, 36]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n=int(input())</line-3>
<line-4> arr=list(map(int,input().split()))</line-4>
<line-5> d={}</line-5>
<line-6> for i in range(n):</line-6>
<line-7> if arr[i] in d:</line-7>
<line-8> d[arr[i]].append(i)</line-8>
<line-9> else:</line-9>
<line-10> d[arr[i]]=[i]</line-10>
<line-11> q=int(input())</line-11>
<line-12> for i in range(q):</line-12>
<line-13> m=int(input())</line-13>
<line-14> if len(d[m])==1:</line-14>
<line-15> print(n)</line-15>
<line-16> elif len(d[m])==2:</line-16>
<line-17> print(min((d[m][1]-d[m][0]),((n-d[m][1])+d[m][0])))</line-17>
<line-18> else:</line-18>
<line-19> k=100000</line-19>
<line-20> for j in range(len(d[m])-1):</line-20>
<line-21> if (d[m][j+1]-d[m][j])<k:</line-21>
<line-22> k=d[m][j+1]-d[m][j]</line-22>
<line-23> else:</line-23>
<line-25> print(min(k,((n-d[m][len(d[m])-1])+d[m][0])))</line-25>
<line-26> </line-26>
<line-27> </line-27>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-24> pass</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>for __ in range(int(input())):</line-1>
<line-3> d=n%(n//2+1)</line-3>
<line-4> if(d==0):</line-4>
<line-5> t=p*p*p</line-5>
<line-6> else:</line-6>
<line-8> print(t)</line-8>
|
{"code": "<line-2> n,p=list(map(int,input().split()))</line-2>\n<line-7> t=(p-d)*(p-d)+(p-d)*(p-n)+(p-n)*(p-n)</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>for t in range(int(input().strip())):</line-1>
<line-3> x = int(input().strip())</line-3>
<line-4> arr = list(map(int, input().strip().split()))</line-4>
<line-5> arr.sort()</line-5>
<line-6> day = 1</line-6>
<line-7> acc = 0</line-7>
<line-8> isPossible = True</line-8>
<line-9> for a in arr:</line-9>
<line-10> acc += 1</line-10>
<line-11> if acc > x:</line-11>
<line-12> day += 1</line-12>
<line-13> acc = 1</line-13>
<line-14> if day >= a:</line-14>
<line-15> isPossible = False</line-15>
<line-17></line-17>
<line-18> print("Possible" if isPossible else "Impossible")</line-18>
|
{"code": "<line-2> n = int(input().strip())</line-2>\n<line-16> break</line-16>", "lines": [2, 16]}
#### 0
|
<line-1># Bartek Kostka</line-1>
<line-3></line-3>
<line-4>#include "bits/stdc++.h"</line-4>
<line-5></line-5>
<line-6>n = int(input())</line-6>
<line-7>W = {}</line-7>
<line-8>for i in range(n):</line-8>
<line-9> adr = input()</line-9>
<line-10> adr = adr.split("/")</line-10>
<line-11> if adr[-1] == '':</line-11>
<line-12> adr[-1] = '?'</line-12>
<line-13> domena = "/".join(adr[:3])</line-13>
<line-14> adres = "/".join(adr[3:])</line-14>
<line-15> #print(domena, adres)</line-15>
<line-16> if domena not in W:</line-16>
<line-17> W[domena] = set()</line-17>
<line-18> W[domena].add(adres)</line-18>
<line-19></line-19>
<line-20>E = {}</line-20>
<line-21>for key, ele in list(W.items()):</line-21>
<line-22> #print(key, ele)</line-22>
<line-23> lele = "#".join(sorted(list(ele)))</line-23>
<line-24> if lele not in E:</line-24>
<line-25> E[lele] = []</line-25>
<line-26> E[lele].append(key)</line-26>
<line-27></line-27>
<line-28>res = 0</line-28>
<line-29>for key, ele in list(E.items()):</line-29>
<line-30> if len(ele) > 1:</line-30>
<line-31> res += 1</line-31>
<line-32></line-32>
<line-33>print(res)</line-33>
<line-34>for key, ele in list(E.items()):</line-34>
<line-36> print(" ".join(ele))</line-36>
|
{"code": "<line-2># You are not prepared!</line-2>\n<line-35> if len(ele) > 1:</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>def getSum(dp, pos, s, e, type_):</line-1>
<line-3> return 0</line-3>
<line-4> </line-4>
<line-5> if type_=='D':</line-5>
<line-6> if e==m-1:</line-6>
<line-7> return dp[pos][s]</line-7>
<line-8> return dp[pos][s]-dp[pos][e+1]</line-8>
<line-9> else:</line-9>
<line-10> if e==n-1:</line-10>
<line-11> return dp[s][pos]</line-11>
<line-12> return dp[s][pos]-dp[e+1][pos]</line-12>
<line-13></line-13>
<line-14>mod = 10**9+7</line-14>
<line-15>n, m = map(int, input().split())</line-15>
<line-16>a = [list(list(map(lambda x: 1 if x=='R' else 0, input()))) for _ in range(n)] </line-16>
<line-17></line-17>
<line-18>SD = [[0]*m for _ in range(n)]</line-18>
<line-19>SN = [[0]*m for _ in range(n)]</line-19>
<line-20>dpD = [[0]*m for _ in range(n)]</line-20>
<line-21>dpN = [[0]*m for _ in range(n)]</line-21>
<line-22></line-22>
<line-23>for i in range(n-1, -1, -1):</line-23>
<line-24> for j in range(m-1, -1, -1):</line-24>
<line-25> if i == n-1:</line-25>
<line-26> SD[i][j]=a[i][j] </line-26>
<line-27> else:</line-27>
<line-28> SD[i][j]=SD[i+1][j]+a[i][j]</line-28>
<line-29></line-29>
<line-30> if j == m-1:</line-30>
<line-31> SN[i][j]=a[i][j]</line-31>
<line-32> else: </line-32>
<line-33> SN[i][j]=SN[i][j+1]+a[i][j]</line-33>
<line-34> </line-34>
<line-35>for j in range(m-1,-1,-1):</line-35>
<line-36> if a[n-1][j]==1:</line-36>
<line-37> break</line-37>
<line-38> dpD[n-1][j]=1</line-38>
<line-39> dpN[n-1][j]=1</line-39>
<line-40> </line-40>
<line-41>for i in range(n-1,-1,-1):</line-41>
<line-42> if a[i][m-1]==1:</line-42>
<line-43> break</line-43>
<line-44> dpD[i][m-1]=1</line-44>
<line-45> dpN[i][m-1]=1</line-45>
<line-46> </line-46>
<line-47>for j in range(m-2, -1, -1):</line-47>
<line-48> if i==n-1:</line-48>
<line-49> break</line-49>
<line-50> dpD[n-1][j]+=dpD[n-1][j+1]</line-50>
<line-51> </line-51>
<line-52>for i in range(n-2,-1,-1): </line-52>
<line-53> if j==m-1:</line-53>
<line-54> break</line-54>
<line-55> dpN[i][m-1]+=dpN[i+1][m-1] </line-55>
<line-56> </line-56>
<line-57>for i in range(n-2,-1,-1):</line-57>
<line-58> for j in range(m-2,-1,-1):</line-58>
<line-59> s, e = j, m-SN[i][j]-1</line-59>
<line-60> #print(i, j, s, e, 'N')</line-60>
<line-61> dpN[i][j] = getSum(dpD, i+1, s, e, 'D')</line-61>
<line-62> dpN[i][j] = (dpN[i][j] + dpN[i+1][j]) % mod </line-62>
<line-63> </line-63>
<line-64> s, e = i, n-SD[i][j]-1</line-64>
<line-65> #print(i, j, s, e, 'D')</line-65>
<line-66> dpD[i][j] = getSum(dpN, j+1, s, e, 'N')</line-66>
<line-67></line-67>
<line-68> if i != 0:</line-68>
<line-69> for j in range(m-2,-1,-1): </line-69>
<line-71> </line-71>
<line-72>print(dpD[0][0] % mod) </line-72>
|
{"code": "<line-2> if e < s:</line-2>\n<line-70> dpD[i][j] = (dpD[i][j] + dpD[i][j+1]) % mod </line-70>", "lines": [2, 70]}
#### 0
|
<line-2>print(((b-1)*a*b//2+(a+1)*a*b*b*(b-1)//4)%1000000007)</line-2>
|
{"code": "<line-1>a,b=map(int,input().split())</line-1>", "lines": [1]}
#### 0
|
<line-1>l,r = map(int, input().split(" "))</line-1>
<line-3> print (l)</line-3>
<line-5> print (2)</line-5>
|
{"code": "<line-2>if l == r:</line-2>\n<line-4>else:</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>s=input()</line-1>
<line-3>for i in range(len(s)):</line-3>
<line-4> if s[i] == 'A':</line-4>
<line-6>print(ans)</line-6>
|
{"code": "<line-2>ans = 0</line-2>\n<line-5> ans += s[:i].count('Q') * s[i:].count('Q')</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>import sys</line-1>
<line-3> s = sys.stdin.readline</line-3>
<line-4> save = {' ': '%20', '!': '%21', '$': '%24', '%': '%25', '(': '%28', ')': '%29', '*': '%2a'}</line-4>
<line-5> string = s().strip()</line-5>
<line-6> while True:</line-6>
<line-7> output = []</line-7>
<line-8> if '#' in string:</line-8>
<line-9> return</line-9>
<line-10> for i in string:</line-10>
<line-11> if i in save:</line-11>
<line-12> output.append(save[i])</line-12>
<line-13> else:</line-13>
<line-14> output.append(i)</line-14>
<line-15> print(''.join(output))</line-15>
<line-16> string = s().strip()</line-16>
<line-17> </line-17>
<line-18>def __starting_point():</line-18>
<line-20>__starting_point()</line-20>
|
{"code": "<line-2>def main():</line-2>\n<line-19> main()</line-19>", "lines": [2, 19]}
#### 0
|
<line-1># ------------------- fast io --------------------</line-1>
<line-3>import sys</line-3>
<line-4>from io import BytesIO, IOBase</line-4>
<line-5></line-5>
<line-6>BUFSIZE = 8192</line-6>
<line-7></line-7>
<line-8></line-8>
<line-9>class FastIO(IOBase):</line-9>
<line-10> newlines = 0</line-10>
<line-11></line-11>
<line-12> def __init__(self, file):</line-12>
<line-13> self._fd = file.fileno()</line-13>
<line-14> self.buffer = BytesIO()</line-14>
<line-15> self.writable = "x" in file.mode or "r" not in file.mode</line-15>
<line-16> self.write = self.buffer.write if self.writable else None</line-16>
<line-17></line-17>
<line-18> def read(self):</line-18>
<line-19> while True:</line-19>
<line-20> b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))</line-20>
<line-21> if not b:</line-21>
<line-22> break</line-22>
<line-23> ptr = self.buffer.tell()</line-23>
<line-24> self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)</line-24>
<line-25> self.newlines = 0</line-25>
<line-26> return self.buffer.read()</line-26>
<line-27></line-27>
<line-28> def readline(self):</line-28>
<line-29> while self.newlines == 0:</line-29>
<line-30> b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))</line-30>
<line-31> self.newlines = b.count(b"\n") + (not b)</line-31>
<line-32> ptr = self.buffer.tell()</line-32>
<line-33> self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)</line-33>
<line-34> self.newlines -= 1</line-34>
<line-35> return self.buffer.readline()</line-35>
<line-36></line-36>
<line-37> def flush(self):</line-37>
<line-38> if self.writable:</line-38>
<line-39> os.write(self._fd, self.buffer.getvalue())</line-39>
<line-40> self.buffer.truncate(0), self.buffer.seek(0)</line-40>
<line-41></line-41>
<line-42></line-42>
<line-43>class IOWrapper(IOBase):</line-43>
<line-44> def __init__(self, file):</line-44>
<line-45> self.buffer = FastIO(file)</line-45>
<line-46> self.flush = self.buffer.flush</line-46>
<line-47> self.writable = self.buffer.writable</line-47>
<line-48> self.write = lambda s: self.buffer.write(s.encode("ascii"))</line-48>
<line-49> self.read = lambda: self.buffer.read().decode("ascii")</line-49>
<line-50> self.readline = lambda: self.buffer.readline().decode("ascii")</line-50>
<line-51></line-51>
<line-52></line-52>
<line-53>sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)</line-53>
<line-54>input = lambda: sys.stdin.readline().rstrip("\r\n")</line-54>
<line-55></line-55>
<line-56># ------------------- fast io --------------------</line-56>
<line-57>from math import gcd, ceil</line-57>
<line-58></line-58>
<line-59>def prod(a, mod=10**9+7):</line-59>
<line-60> ans = 1</line-60>
<line-61> for each in a:</line-61>
<line-62> ans = (ans * each) % mod</line-62>
<line-63> return ans</line-63>
<line-64></line-64>
<line-65>def lcm(a, b): return a * b // gcd(a, b)</line-65>
<line-66></line-66>
<line-67>def binary(x, length=16):</line-67>
<line-68> y = bin(x)[2:]</line-68>
<line-69> return y if len(y) >= length else "0" * (length - len(y)) + y</line-69>
<line-70></line-70>
<line-71>for _ in range(int(input()) if True else 1):</line-71>
<line-72> n = int(input())</line-72>
<line-73> #n, k = map(int, input().split())</line-73>
<line-74> #a, b = map(int, input().split())</line-74>
<line-75> #c, d = map(int, input().split())</line-75>
<line-76> #a = list(map(int, input().split()))</line-76>
<line-77> #b = list(map(int, input().split()))</line-77>
<line-79> print(*[1]*n)</line-79>
|
{"code": "<line-2>import os</line-2>\n<line-78> #s = input()</line-78>", "lines": [2, 78]}
#### 0
|
<line-1>f={}</line-1>
<line-2></line-2>
<line-4>f[-41] = '-344598.60'</line-4>
<line-5>f[-42] = '-370433.52'</line-5>
<line-6>f[-43] = '-397528.44'</line-6>
<line-7>f[-44] = '-425913.37'</line-7>
<line-8>f[-45] = '-455618.29'</line-8>
<line-9>f[-46] = '-486673.22'</line-9>
<line-10>f[-47] = '-519108.14'</line-10>
<line-11>f[-48] = '-552953.07'</line-11>
<line-12>f[-49] = '-588238.00'</line-12>
<line-13>f[-50] = '-624992.93'</line-13>
<line-14>f[-29] = '-121939.61'</line-14>
<line-15>f[-30] = '-134994.52'</line-15>
<line-16>f[-31] = '-148949.43'</line-16>
<line-17>f[-32] = '-163834.34'</line-17>
<line-18>f[-33] = '-179679.26'</line-18>
<line-19>f[-34] = '-196514.17'</line-19>
<line-20>f[-35] = '-214369.08'</line-20>
<line-21>f[-36] = '-233274.00'</line-21>
<line-22>f[-37] = '-253258.92'</line-22>
<line-23>f[-38] = '-274353.84'</line-23>
<line-24>f[-39] = '-296588.76'</line-24>
<line-25>f[-18] = '-29155.76'</line-25>
<line-26>f[-19] = '-34290.64'</line-26>
<line-27>f[-20] = '-39995.53'</line-27>
<line-28>f[-21] = '-46300.42'</line-28>
<line-29>f[-22] = '-53235.31'</line-29>
<line-30>f[-23] = '-60830.20'</line-30>
<line-31>f[-24] = '-69115.10'</line-31>
<line-32>f[-25] = '-78120.00'</line-32>
<line-33>f[-26] = '-87874.90'</line-33>
<line-34>f[-27] = '-98409.80'</line-34>
<line-35>f[-28] = '-109754.71'</line-35>
<line-36>f[-8] = '-2557.17'</line-36>
<line-37>f[-9] = '-3642.00'</line-37>
<line-38>f[-10] = '-4996.84'</line-38>
<line-39>f[-11] = '-6651.68'</line-39>
<line-40>f[-12] = '-8636.54'</line-40>
<line-41>f[-13] = '-10981.39'</line-41>
<line-42>f[-14] = '-13716.26'</line-42>
<line-43>f[-15] = '-16871.13'</line-43>
<line-44>f[-16] = '-20476.00'</line-44>
<line-45>f[-17] = '-24560.88'</line-45>
<line-46>f[-18] = '-29155.76'</line-46>
<line-47>f[3] = '136.73'</line-47>
<line-48>f[2] = '41.41'</line-48>
<line-49>f[1] = '6.00'</line-49>
<line-50>f[0] = '0.00'</line-50>
<line-51>f[-1] = '-4.00'</line-51>
<line-52>f[-2] = '-38.59'</line-52>
<line-53>f[-3] = '-133.27'</line-53>
<line-54>f[-4] = '-318.00'</line-54>
<line-55>f[-5] = '-622.76'</line-55>
<line-56>f[-6] = '-1077.55'</line-56>
<line-57>f[-7] = '-1712.35'</line-57>
<line-58>f[14] = 'MAGNA NIMIS!'</line-58>
<line-59>f[13] = 'MAGNA NIMIS!'</line-59>
<line-60>f[12] = 'MAGNA NIMIS!'</line-60>
<line-61>f[11] = 'MAGNA NIMIS!'</line-61>
<line-62>f[10] = 'MAGNA NIMIS!'</line-62>
<line-63>f[9] = 'MAGNA NIMIS!'</line-63>
<line-64>f[8] = 'MAGNA NIMIS!'</line-64>
<line-65>f[7] = 'MAGNA NIMIS!'</line-65>
<line-66>f[6] = 'MAGNA NIMIS!'</line-66>
<line-67>f[5] = 'MAGNA NIMIS!'</line-67>
<line-68>f[4] = '322.00'</line-68>
<line-69></line-69>
<line-70>a=[]</line-70>
<line-71>for i in range(11):</line-71>
<line-72> a+=[int(input())]</line-72>
<line-73>for i in a[::-1]:</line-73>
<line-74> s=''</line-74>
<line-75> if i in f:</line-75>
<line-76> s=f[i]</line-76>
<line-77> else:</line-77>
<line-79> print('f(%d) = %s'%(i, s))</line-79>
|
{"code": "<line-3>f[-40] = '-319993.68'</line-3>\n<line-78> s='MAGNA NIMIS!'</line-78>", "lines": [3, 78]}
#### 0
|
<line-1>from math import sqrt</line-1>
<line-2></line-2>
<line-4> return sqrt((x1-x2)**2 + (y1-y2)**2)</line-4>
<line-5></line-5>
<line-6>T = int(input())</line-6>
<line-7>ans = []</line-7>
<line-8></line-8>
<line-9>for _ in range(T):</line-9>
<line-10> blank = input()</line-10>
<line-11> N = int(input())</line-11>
<line-12></line-12>
<line-13> C = [[] for i in range(10**4+1)]</line-13>
<line-14></line-14>
<line-15> for i in range(N):</line-15>
<line-16> x,y = [int(i) for i in input().split()]</line-16>
<line-17> C[x].append(y)</line-17>
<line-18></line-18>
<line-19> distance = 0</line-19>
<line-20> lastx = None</line-20>
<line-21> lasty = None</line-21>
<line-22> for i in range(10**4+1):</line-22>
<line-23> if(C[i]!=[]):</line-23>
<line-24> max_ci = max(C[i])</line-24>
<line-25> min_ci = min(C[i])</line-25>
<line-26> if(lastx!=None and lasty!=None):</line-26>
<line-27> distance += get_distance(lastx,lasty,i,max_ci)</line-27>
<line-28> distance += max_ci - min_ci</line-28>
<line-29> lastx = i</line-29>
<line-30> lasty = min_ci</line-30>
<line-31> # ans.append(round(distance,2))</line-31>
<line-32> ans.append("{:.2f}".format(distance))</line-32>
<line-33> # ans.append(distance)</line-33>
<line-34></line-34>
<line-36> print(i)</line-36>
|
{"code": "<line-3>def get_distance(x1,y1,x2,y2):</line-3>\n<line-35>for i in ans:</line-35>", "lines": [3, 35]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>for i in range(1, 10):</line-5>
<line-6> blocks[i] = [(0, 0)]</line-6>
<line-7>for i in range(2, 10, 2):</line-7>
<line-8> for j in range(1, i / 2 + 1):</line-8>
<line-9> blocks[i].append((j, 0))</line-9>
<line-10> blocks[i + 1].append((0, j))</line-10>
<line-11># print blocks</line-11>
<line-12>blocks[10] = [(0, 0), (0, 1), (1, 0), (1, 1)]</line-12>
<line-13>blocks[11] = [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]</line-13>
<line-14>blocks[12] = [(0, 0), (0, 1), (0, 2), (1, 2), (2, 2)]</line-14>
<line-15>blocks[13] = [(0, 2), (1, 2), (2, 0), (2, 1), (2, 2)]</line-15>
<line-16>blocks[14] = [(0, 0), (1, 0), (2, 0), (2, 1), (2, 2)]</line-16>
<line-17>blocks[15] = [(0, 0), (0, 1), (0, 2), (1, 0), (2, 0)]</line-17>
<line-18>blocks[16] = [(0, 0), (0, 1), (1, 0)]</line-18>
<line-19>blocks[17] = [(0, 0), (0, 1), (1, 1)]</line-19>
<line-20>blocks[18] = [(0, 1), (1, 0), (1, 1)]</line-20>
<line-21>blocks[19] = [(0, 0), (1, 0), (1, 1)]</line-21>
<line-22></line-22>
<line-23>grid = [['.'] * 10] * 10</line-23>
<line-24># print grid</line-24>
<line-25></line-25>
<line-26>id1, id2, id3 = list(map(int, input().split()))</line-26>
<line-27>while not (id1 == id2 == id3 == -1):</line-27>
<line-28> print('-1 -1 -1 -1 -1 -1 -1 -1 -1')</line-28>
<line-30> id1, id2, id3 = list(map(int, input().split()))</line-30>
|
{"code": "<line-3>blocks = {}</line-3>\n<line-29> sys.stdout.flush()</line-29>", "lines": [3, 29]}
#### 0
|
<line-1>#dt = {} for i in x: dt[i] = dt.get(i,0)+1</line-1>
<line-3>#import io,os; input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline #for pypy</line-3>
<line-4>inp,ip = lambda :int(input()),lambda :[int(w) for w in input().split()]</line-4>
<line-5></line-5>
<line-6>from collections import deque</line-6>
<line-7>def getmax(x,n,k):</line-7>
<line-8> mx = []</line-8>
<line-9> dq = deque()</line-9>
<line-10> for i in range(k):</line-10>
<line-11> while dq and x[i] >= x[dq[-1]]:</line-11>
<line-12> dq.pop()</line-12>
<line-13> dq.append(i)</line-13>
<line-14> mx.append(x[dq[0]])</line-14>
<line-15> for i in range(k,n):</line-15>
<line-16> while dq and dq[0] <= i-k:</line-16>
<line-17> dq.popleft() </line-17>
<line-18> while dq and x[i] >= x[dq[-1]]:</line-18>
<line-19> dq.pop()</line-19>
<line-20> dq.append(i)</line-20>
<line-21> mx.append(x[dq[0]])</line-21>
<line-22> return mx</line-22>
<line-23></line-23>
<line-24>n = inp()</line-24>
<line-25>m = n+n</line-25>
<line-26>A = ip()</line-26>
<line-27>B = ip()</line-27>
<line-28>A += A</line-28>
<line-29>B += B</line-29>
<line-30>pre = [0]*(m+1)</line-30>
<line-31>for i in range(1,m+1):</line-31>
<line-32> pre[i] += pre[i-1] + B[i-1]</line-32>
<line-33>plus = [0]*m</line-33>
<line-34>minus = [0]*m</line-34>
<line-35>for i in range(m):</line-35>
<line-36> plus[i] = A[i]+pre[i]</line-36>
<line-37> minus[i] = A[i]-pre[i+1]</line-37>
<line-38>a = getmax(plus,m,n-1)</line-38>
<line-39>ans = float('-inf')</line-39>
<line-40>for i in range(n):</line-40>
<line-42>print(max(ans,*A))</line-42>
|
{"code": "<line-2>import sys;input = sys.stdin.readline</line-2>\n<line-41> ans = max(ans,minus[i]+a[i+1])</line-41>", "lines": [2, 41]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>arr1 = list(map(int, input().split()))</line-3>
<line-4>arr2 = list(map(int, input().split()))</line-4>
<line-5>max1 = arr1.index(max(arr1))</line-5>
<line-6>min2 = arr2.index(min(arr2))</line-6>
<line-7>arr = []</line-7>
<line-8>for i in range(m):</line-8>
<line-9> arr.append([max1, i])</line-9>
<line-10>for i in range(n):</line-10>
<line-11> if i!=max1:</line-11>
<line-12> arr.append([i , min2])</line-12>
<line-14> print(*i)</line-14>
|
{"code": "<line-2>n,m = map(int, input().split())</line-2>\n<line-13>for i in arr:</line-13>", "lines": [2, 13]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> l,n,x=map(int,input().split())</line-3>
<line-4> m=[]</line-4>
<line-5> pw1 = (1 << 17); </line-5>
<line-6> pw2 = (1 << 18); </line-6>
<line-7> if (n == 1) : </line-7>
<line-8> m.append(x)</line-8>
<line-9> elif (n == 2 and x == 0) : </line-9>
<line-10> m.append(-1)</line-10>
<line-11> elif (n == 2) : </line-11>
<line-12> m.append(x)</line-12>
<line-13> m.append(0)</line-13>
<line-14> else : </line-14>
<line-15> ans = 0; </line-15>
<line-16> for i in range(1, n - 2) : </line-16>
<line-17> m.append(i)</line-17>
<line-18> ans = ans ^ i; </line-18>
<line-19> if (ans == x) : </line-19>
<line-20> m.append(pw1+pw2)</line-20>
<line-21> m.append(pw1)</line-21>
<line-22> m.append(pw2)</line-22>
<line-23> else:</line-23>
<line-24> m.append(pw1)</line-24>
<line-25> m.append((pw1 ^ x) ^ ans)</line-25>
<line-26> m.append(0)</line-26>
<line-27> p=(m)*l</line-27>
<line-28> for i in range(0,l):</line-28>
<line-30> print() </line-30>
<line-31> </line-31>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-29> print(p[i],end=' ')</line-29>", "lines": [2, 29]}
#### 0
|
<line-1>#include<stdio.h></line-1>
<line-3>{</line-3>
<line-4>int j,res=0;</line-4>
<line-5>while(k)</line-5>
<line-6>{</line-6>
<line-7>res=res*10+k%10;</line-7>
<line-8>k/=10;</line-8>
<line-9>}</line-9>
<line-10>return res;</line-10>
<line-11>}</line-11>
<line-12>int main()</line-12>
<line-13>{</line-13>
<line-14>int j,a,b,m,k;</line-14>
<line-15>while(scanf("%d",&m)!=EOF)</line-15>
<line-16>{</line-16>
<line-17>for(j=1;j<=m;j++)</line-17>
<line-18>{</line-18>
<line-19>scanf("%d %d",&a,&b);</line-19>
<line-20>k=rev(a)+rev(b);</line-20>
<line-21>printf("%d\n",rev(k));</line-21>
<line-22>}</line-22>
<line-23>}</line-23>
<line-25>}</line-25>
|
{"code": "<line-2>int rev(int k)</line-2>\n<line-24>return 0;</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> if(x==y):</line-3>
<line-4> if(x==1):</line-4>
<line-5> print(1)</line-5>
<line-6> else:</line-6>
<line-7> n=0</line-7>
<line-8> for i in range(x-1):</line-8>
<line-9> n=i</line-9>
<line-10> for _ in range(y):</line-10>
<line-11> print(n,end=' ')</line-11>
<line-12> n=(n+1)%x</line-12>
<line-13> print() </line-13>
<line-14> for i in range(x):</line-14>
<line-15> print(i,end=' ')</line-15>
<line-16> print( )</line-16>
<line-17> else:</line-17>
<line-18> l=[]</line-18>
<line-19> n=min(x,y)</line-19>
<line-20> m=max(x,y)</line-20>
<line-21> for _ in range(n):</line-21>
<line-22> l.append([])</line-22>
<line-23> v=n+1</line-23>
<line-24> for i in range(n):</line-24>
<line-25> u=i</line-25>
<line-26> for j in range(m):</line-26>
<line-27> if(j<=n):</line-27>
<line-28> l[i].append(u)</line-28>
<line-29> u=(u+1)%(n+1)</line-29>
<line-30> else:</line-30>
<line-31> if(j>=v):</line-31>
<line-32> l[i].append(j+1)</line-32>
<line-33> else:</line-33>
<line-34> l[i].append(j)</line-34>
<line-35> v=v+1</line-35>
<line-36> if(x>y):</line-36>
<line-37> for i in range(x):</line-37>
<line-38> for j in l:</line-38>
<line-39> print(j[i],end=' ')</line-39>
<line-40> print( )</line-40>
<line-41> else:</line-41>
<line-42> for i in l:</line-42>
<line-43> for j in i:</line-43>
<line-45> print( )</line-45>
|
{"code": "<line-2> x,y=map(int,input().split())</line-2>\n<line-44> print(j,end=' ')</line-44>", "lines": [2, 44]}
#### 0
|
<line-1>l=list(map(int,input()))</line-1>
<line-3>x=-1</line-3>
<line-4>y=-1</line-4>
<line-5>for i in range(len(l)):</line-5>
<line-6> s=l[i]</line-6>
<line-7> a=i+1</line-7>
<line-8> b=i+1</line-8>
<line-9> for j in range(i+1,len(l)):</line-9>
<line-10> if l[i]<l[j]:</line-10>
<line-11> s=s+l[j]</line-11>
<line-12> b=j+1</line-12>
<line-13> else:</line-13>
<line-14> break</line-14>
<line-15> if s>t:</line-15>
<line-16> t=s</line-16>
<line-17> x=a</line-17>
<line-18> y=b</line-18>
<line-20>print(x,y,sep="-")</line-20>
|
{"code": "<line-2>t=-1</line-2>\n<line-19>print(t,end=\":\")</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>''' J A I ~ S H R E E ~ R A M '''</line-1>
<line-2></line-2>
<line-4># created on: 20-07-2020 at 20:46:04</line-4>
<line-5># Creator & Template : Udit Gupta "@luctivud"</line-5>
<line-6># https://github.com/luctivud</line-6>
<line-7># https://www.linkedin.com/in/udit-gupta-1b7863135/</line-7>
<line-8></line-8>
<line-9></line-9>
<line-10>import math; from collections import *</line-10>
<line-11>import sys; from functools import reduce</line-11>
<line-12>from itertools import groupby</line-12>
<line-13></line-13>
<line-14># sys.setrecursionlimit(10**6)</line-14>
<line-15></line-15>
<line-16>def get_ints(): return map(int, input().strip().split())</line-16>
<line-17>def get_list(): return list(get_ints())</line-17>
<line-18>def get_string(): return list(input().strip().split())</line-18>
<line-19>def printxsp(*args): return print(*args, end="")</line-19>
<line-20>def printsp(*args): return print(*args, end=" ")</line-20>
<line-21></line-21>
<line-22></line-22>
<line-23>DIRECTIONS = [[0, 1], [0, -1], [1, 0], [1, -1]] #up, down, right, left</line-23>
<line-24>NEIGHBOURS = [(i, j) for i in range(-1, 2) for j in range(-1, 2) if (i!=0 or j!=0)]</line-24>
<line-25></line-25>
<line-26></line-26>
<line-27>OrdUnicode_a = ord('a'); OrdUnicode_A = ord('A')</line-27>
<line-28>CAPS_ALPHABETS = {chr(i+OrdUnicode_A) : i for i in range(26)}</line-28>
<line-29>SMOL_ALPHABETS = {chr(i+OrdUnicode_a) : i for i in range(26)}</line-29>
<line-30></line-30>
<line-31></line-31>
<line-32>MOD_JOHAN = int(1e9)+7; MOD_LIGHT = 998244353; INFINITY = float('inf')</line-32>
<line-33>MAXN_EYEPATCH = int(1e5)+1; MAXN_FULLMETAL = 501</line-33>
<line-34></line-34>
<line-35># Custom input output is now piped through terminal commands.</line-35>
<line-36></line-36>
<line-37>def bfs(s):</line-37>
<line-38> queue = deque()</line-38>
<line-39> visited = set()</line-39>
<line-40> visited.add(1)</line-40>
<line-41> queue.append((1, 0))</line-41>
<line-42> while len(queue):</line-42>
<line-43> node, dep = queue.popleft()</line-43>
<line-44> dep += 1</line-44>
<line-45> for zen in tree[node]:</line-45>
<line-46> if zen not in visited:</line-46>
<line-47> visited.add(zen)</line-47>
<line-48> if dep & 1:</line-48>
<line-49> global xorsum</line-49>
<line-50> xorsum ^= li[zen]</line-50>
<line-51> queue.append((zen, dep))</line-51>
<line-52> # print(queue)</line-52>
<line-53> </line-53>
<line-54></line-54>
<line-55></line-55>
<line-56># for _testcases_ in range(int(input())): </line-56>
<line-57>n = int(input())</line-57>
<line-58>li = [0] + get_list()</line-58>
<line-59>tree = defaultdict(list)</line-59>
<line-60>for _ in range(n-1):</line-60>
<line-61> a, b = get_ints()</line-61>
<line-62> tree[a].append(b)</line-62>
<line-63> tree[b].append(a)</line-63>
<line-64>xorsum = 0</line-64>
<line-65>bfs(1)</line-65>
<line-66># print(xorsum)</line-66>
<line-67>print("First" if xorsum else "Second")</line-67>
<line-68></line-68>
<line-69></line-69>
<line-70></line-70>
<line-71></line-71>
<line-72>'''</line-72>
<line-73>THE LOGIC AND APPROACH IS MINE ( UDIT GUPTA )</line-73>
<line-75>'''</line-75>
|
{"code": "<line-3># Title: cc-CKOJ20D.py</line-3>\n<line-74>Link may be copy-pasted here, otherwise.</line-74>", "lines": [3, 74]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3></line-3>
<line-4>while(t>0):</line-4>
<line-5> n = int(input())</line-5>
<line-6> k=1</line-6>
<line-7> while(k<=n):</line-7>
<line-8> print(k, end=' ')</line-8>
<line-9> k+=1</line-9>
<line-11> t-=1</line-11>
|
{"code": "<line-2>t = int(input())</line-2>\n<line-10> print('\\n')</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>from collections import deque</line-1>
<line-3>import psyco</line-3>
<line-4>psyco.full()</line-4>
<line-5></line-5>
<line-6>graph = [[]]</line-6>
<line-7>WHITE, GRAY, BLACK = 0, 1, 2</line-7>
<line-8></line-8>
<line-9>def notoriety(x, f_count):</line-9>
<line-10> queue = deque([x])</line-10>
<line-11> d = [0 for i in range(f_count+1)]</line-11>
<line-12> p = [0 for i in range(f_count+1)]</line-12>
<line-13> color = [WHITE for i in range(f_count+1)]</line-13>
<line-14> while len(queue) > 0:</line-14>
<line-15> top = queue.pop()</line-15>
<line-16> for node in graph[top]:</line-16>
<line-17> if color[node] == WHITE:</line-17>
<line-18> queue.appendleft(node)</line-18>
<line-19> color[node], p[node], d[node] = GRAY, top, d[top] + 1</line-19>
<line-20> color[top] = BLACK</line-20>
<line-21> return sum(d)/(f_count*1.0)</line-21>
<line-22> </line-22>
<line-23>def main():</line-23>
<line-24> groups = int(stdin.readline())</line-24>
<line-25> for g in range(groups):</line-25>
<line-26> global graph</line-26>
<line-27> graph = [[]]</line-27>
<line-28> no_of_friends = int(stdin.readline())</line-28>
<line-29> for i in range(no_of_friends):</line-29>
<line-30> graph.append(list(map(int,stdin.readline().split())))</line-30>
<line-31> min_notoriety, popular = 10000000, -1 # yet another magic number</line-31>
<line-32> for f in range(1,no_of_friends+1):</line-32>
<line-33> curr_not = notoriety(f, no_of_friends)</line-33>
<line-34> if curr_not < min_notoriety:</line-34>
<line-35> min_notoriety,popular = curr_not, f</line-35>
<line-36> assert popular != -1</line-36>
<line-37> print(popular, "%.6f" %min_notoriety)</line-37>
<line-38></line-38>
<line-39>def __starting_point():</line-39>
<line-41></line-41>
<line-42>__starting_point()</line-42>
|
{"code": "<line-2>from sys import stdin</line-2>\n<line-40> main()</line-40>", "lines": [2, 40]}
#### 0
|
<line-1>class PathNode:</line-1>
<line-2></line-2>
<line-4> self.x = row</line-4>
<line-5> self.y = col</line-5>
<line-6> self.pathCount = p_count</line-6>
<line-7></line-7>
<line-8> def __str__(self):</line-8>
<line-9> return str(self.x) + " | " + str(self.y) + " | " + str(self.pathCount)</line-9>
<line-10></line-10>
<line-11></line-11>
<line-12>class GraphUtil:</line-12>
<line-13> def __init__(self, mat, R,C, d):</line-13>
<line-14> self.mat = mat</line-14>
<line-15> self.R = R</line-15>
<line-16> self.C = C</line-16>
<line-17> self.d = d</line-17>
<line-18> self.tab = {}</line-18>
<line-19></line-19>
<line-20> def isValidMove(self, r, c, blockVal):</line-20>
<line-21> return r < self.R and c < self.C and self.mat[r][c] != blockVal</line-21>
<line-22></line-22>
<line-23> def possbilePathUtil(self, r, c, blockVal, step,direction):</line-23>
<line-24></line-24>
<line-25> if(not self.isValidMove(r, c, 0)):</line-25>
<line-26> return 0</line-26>
<line-27> </line-27>
<line-28> if (r == self.R - 1 and c == self.C - 1):</line-28>
<line-29> return 1</line-29>
<line-30></line-30>
<line-31> if ((r,c,step,direction) in self.tab):</line-31>
<line-32> return self.tab[(r,c,step,direction)]</line-32>
<line-33></line-33>
<line-34> result = 0</line-34>
<line-35> </line-35>
<line-36> if direction == 1:</line-36>
<line-37> if step < self.d:</line-37>
<line-38> result = (result + self.possbilePathUtil(r, c + 1, blockVal, step + 1,1)) % 20011</line-38>
<line-39> result = (result + self.possbilePathUtil(r+1, c, blockVal, 1,2)) % 20011</line-39>
<line-40> else:</line-40>
<line-41> if step < self.d:</line-41>
<line-42> result = (result + self.possbilePathUtil(r + 1, c, blockVal, step + 1, 2)) % 20011</line-42>
<line-43> result = (result + self.possbilePathUtil(r, c + 1, blockVal, 1,1)) % 20011</line-43>
<line-44> </line-44>
<line-45> self.tab[(r,c,step,direction)] = result</line-45>
<line-46> </line-46>
<line-47> return result</line-47>
<line-48></line-48>
<line-49> def possbilePath(self):</line-49>
<line-50> if (not self.mat or len(self.mat) < 1):</line-50>
<line-51> return 0</line-51>
<line-52></line-52>
<line-53> return self.possbilePathUtil(0, 0, 0,0,2)</line-53>
<line-54></line-54>
<line-55></line-55>
<line-56>numbers = [int(n) for n in input().split()]</line-56>
<line-57></line-57>
<line-58>mat = [[int(n) for n in input().split()] for r in range(0, numbers[0])]</line-58>
<line-59></line-59>
<line-60>result = GraphUtil(mat, numbers[0], numbers[1], numbers[2])</line-60>
<line-61></line-61>
<line-63># print(result.count)# cook your dish here</line-63>
|
{"code": "<line-3> def __init__(self, row, col, st_x, st_y, p_count=0):</line-3>\n<line-62>print(result.possbilePath())</line-62>", "lines": [3, 62]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> if k%4==0:</line-3>
<line-4> for i in range(0,k,4):</line-4>
<line-5> print(i,i+1)</line-5>
<line-6> print(i+1,i+2)</line-6>
<line-7> print(i+2,i+3)</line-7>
<line-8> print(i+3,i)</line-8>
<line-9> elif k%4==1:</line-9>
<line-10> for i in range(4,k-1,4):</line-10>
<line-11> print(i,i+1)</line-11>
<line-12> print(i+1,i+2)</line-12>
<line-13> print(i+2,i+3)</line-13>
<line-14> print(i+3,i)</line-14>
<line-15> print(0,1)</line-15>
<line-16> print(1,2)</line-16>
<line-17> print(2,3)</line-17>
<line-18> print(3,(1<<n)-1)</line-18>
<line-19> print((1<<n)-1,0)</line-19>
<line-20> elif k%4==2:</line-20>
<line-21> for i in range(4,k-2,4):</line-21>
<line-22> print(i,i+1)</line-22>
<line-23> print(i+1,i+2)</line-23>
<line-24> print(i+2,i+3)</line-24>
<line-25> print(i+3,i)</line-25>
<line-26> print(0,1)</line-26>
<line-27> print(1,2)</line-27>
<line-28> print(2,3)</line-28>
<line-29> print(3,(1<<n)-2)</line-29>
<line-30> print((1<<n)-2,(1<<n)-1)</line-30>
<line-31> print((1<<n)-1,0)</line-31>
<line-32> elif k!=3:</line-32>
<line-33> n=1<<n</line-33>
<line-34> n-=1</line-34>
<line-35> for i in range(4,k-3,4):</line-35>
<line-36> print(i,i+1)</line-36>
<line-37> print(i+1,i+2)</line-37>
<line-38> print(i+2,i+3)</line-38>
<line-39> print(i+3,i)</line-39>
<line-40> print(2,3)</line-40>
<line-41> print(3,n-1)</line-41>
<line-42> print(n-1,0)</line-42>
<line-43> print(0,1)</line-43>
<line-44> print(1,n-2)</line-44>
<line-45> print(n-2,n)</line-45>
<line-46> print(n,2)</line-46>
<line-47> else:</line-47>
<line-48> print(0,1)</line-48>
<line-50> print(3,00)</line-50>
|
{"code": "<line-2> n,k=[int(x) for x in input().split()]</line-2>\n<line-49> print(1,3)</line-49>", "lines": [2, 49]}
#### 0
|
<line-1>m=int(input())</line-1>
<line-3> m-=1</line-3>
<line-4> n=int(input())</line-4>
<line-6> print(''.join(t))</line-6>
|
{"code": "<line-2>while m:</line-2>\n<line-5> t=[i for i in input().split()]</line-5>", "lines": [2, 5]}
#### 0
|
<line-1># import all important libraries and inbuilt functions</line-1>
<line-2></line-2>
<line-4>import numpy as np</line-4>
<line-5>import sys,bisect,copyreg,copy,statistics,os</line-5>
<line-6>from math import *</line-6>
<line-7>from collections import Counter,defaultdict,deque,OrderedDict </line-7>
<line-8>from itertools import combinations,permutations,accumulate </line-8>
<line-9>from numpy.linalg import matrix_power as mp</line-9>
<line-10>from bisect import bisect_left,bisect_right,bisect,insort,insort_left,insort_right</line-10>
<line-11>from statistics import mode</line-11>
<line-12>from functools import reduce,cmp_to_key </line-12>
<line-13>from io import BytesIO, IOBase</line-13>
<line-14>from scipy.spatial import ConvexHull</line-14>
<line-15>from heapq import *</line-15>
<line-16>from decimal import *</line-16>
<line-17>from queue import Queue,PriorityQueue</line-17>
<line-18>from re import sub,subn</line-18>
<line-19></line-19>
<line-20># end of library import</line-20>
<line-21></line-21>
<line-22># map system version faults</line-22>
<line-23>if sys.version_info[0] < 3:</line-23>
<line-24> from builtins import xrange as range</line-24>
<line-25> from future_builtins import ascii, filter, hex, map, oct, zip</line-25>
<line-26></line-26>
<line-27># template of many functions used in competitive programming can add more later </line-27>
<line-28># based on need we will use this commonly.</line-28>
<line-29></line-29>
<line-30># bfs in a graph</line-30>
<line-31>def bfs(adj,v): # a schema of bfs</line-31>
<line-32> visited=[False]*(v+1);q=deque()</line-32>
<line-33> while q:pass</line-33>
<line-34></line-34>
<line-35># definition of vertex of a graph</line-35>
<line-36>def graph(vertex): return [[] for i in range(vertex+1)]</line-36>
<line-37></line-37>
<line-38>def powermodulo(x, y, p) : </line-38>
<line-39> res = 1;x = x % p </line-39>
<line-40> if (x == 0) : return 0 </line-40>
<line-41> while (y > 0) : </line-41>
<line-42> if ((y & 1) == 1) : res = (res * x) % p </line-42>
<line-43> y = y >> 1 </line-43>
<line-44> x = (x * x) % p </line-44>
<line-45> return res</line-45>
<line-46></line-46>
<line-47>def lcm(a,b): return (a*b)//gcd(a,b)</line-47>
<line-48></line-48>
<line-49># most common list in a array of lists</line-49>
<line-50>def most_frequent(List):return Counter(List).most_common(1)[0][0]</line-50>
<line-51></line-51>
<line-52># element with highest frequency</line-52>
<line-53>def most_common(List):return(mode(List))</line-53>
<line-54></line-54>
<line-55>#In number theory, the Chinese remainder theorem states that </line-55>
<line-56>#if one knows the remainders of the Euclidean division of an integer n by </line-56>
<line-57>#several integers, then one can determine uniquely the remainder of the </line-57>
<line-58>#division of n by the product of these integers, under the condition </line-58>
<line-59>#that the divisors are pairwise coprime.</line-59>
<line-60>def chinese_remainder(a, p):</line-60>
<line-61> prod = reduce(op.mul, p, 1);x = [prod // pi for pi in p]</line-61>
<line-62> return sum(a[i] * powermodulo(x[i], p[i] - 2, p[i]) * x[i] for i in range(len(a))) % prod</line-62>
<line-63></line-63>
<line-64># make a matrix</line-64>
<line-65>def createMatrix(rowCount, colCount, dataList): </line-65>
<line-66> mat = []</line-66>
<line-67> for i in range (rowCount):</line-67>
<line-68> rowList = []</line-68>
<line-69> for j in range (colCount):</line-69>
<line-70> if dataList[j] not in mat:rowList.append(dataList[j])</line-70>
<line-71> mat.append(rowList) </line-71>
<line-72> return mat</line-72>
<line-73></line-73>
<line-74># input for a binary tree</line-74>
<line-75>def readTree(): </line-75>
<line-76> v=int(inp());adj=[set() for i in range(v+1)]</line-76>
<line-77> for i in range(v-1):u1,u2=In(); adj[u1].add(u2);adj[u2].add(u1)</line-77>
<line-78> return adj,v</line-78>
<line-79> </line-79>
<line-80># sieve of prime numbers </line-80>
<line-81>def sieve():</line-81>
<line-82> li=[True]*1000001;li[0],li[1]=False,False;prime=[]</line-82>
<line-83> for i in range(2,len(li),1):</line-83>
<line-84> if li[i]==True:</line-84>
<line-85> for j in range(i*i,len(li),i):li[j]=False </line-85>
<line-86> for i in range(1000001):</line-86>
<line-87> if li[i]==True:prime.append(i)</line-87>
<line-88> return prime</line-88>
<line-89></line-89>
<line-90>#count setbits of a number.</line-90>
<line-91>def setBit(n):</line-91>
<line-92> count=0</line-92>
<line-93> while n!=0:n=n&(n-1);count+=1</line-93>
<line-94> return count</line-94>
<line-95></line-95>
<line-96># sum of digits of a number</line-96>
<line-97>def digitsSum(n):</line-97>
<line-98> if n == 0:return 0</line-98>
<line-99> r = 0</line-99>
<line-100> while n > 0:r += n % 10;n //= 10</line-100>
<line-101> return r</line-101>
<line-102></line-102>
<line-103># ncr efficiently</line-103>
<line-104>def ncr(n, r):</line-104>
<line-105> r = min(r, n - r);numer = reduce(op.mul, list(range(n, n - r, -1)), 1);denom = reduce(op.mul, list(range(1, r + 1)), 1)</line-105>
<line-106> return numer // denom # or / in Python 2</line-106>
<line-107></line-107>
<line-108>#factors of a number</line-108>
<line-109>def factors(n):return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))</line-109>
<line-110></line-110>
<line-111>#prime fators of a number</line-111>
<line-112>def prime_factors(n):</line-112>
<line-113> i = 2;factors = []</line-113>
<line-114> while i * i <= n:</line-114>
<line-115> if n % i:i += 1</line-115>
<line-116> else:n //= i;factors.append(i)</line-116>
<line-117> if n > 1:factors.append(n)</line-117>
<line-118> return len(set(factors))</line-118>
<line-119></line-119>
<line-120>def prefixSum(arr):</line-120>
<line-121> for i in range(1, len(arr)):arr[i] = arr[i] + arr[i-1]</line-121>
<line-122> return arr </line-122>
<line-123></line-123>
<line-124>def binomial_coefficient(n, k):</line-124>
<line-125> if 0 <= k <= n:</line-125>
<line-126> ntok = 1;ktok = 1</line-126>
<line-127> for t in range(1, min(k, n - k) + 1):ntok *= n;ktok *= t;n -= 1</line-127>
<line-128> return ntok // ktok</line-128>
<line-129> else:return 0</line-129>
<line-130> </line-130>
<line-131>def powerOfK(k, max):</line-131>
<line-132> if k == 1:return [1]</line-132>
<line-133> if k == -1:return [-1, 1] </line-133>
<line-134> result = [];n = 1</line-134>
<line-135> while n <= max:result.append(n);n *= k</line-135>
<line-136> return result</line-136>
<line-137></line-137>
<line-138># maximum subarray sum use kadane's algorithm</line-138>
<line-139>def kadane(a,size):</line-139>
<line-140> max_so_far = 0;max_ending_here = 0 </line-140>
<line-141> for i in range(0, size):</line-141>
<line-142> max_ending_here = max_ending_here + a[i]</line-142>
<line-143> if (max_so_far < max_ending_here):max_so_far = max_ending_here </line-143>
<line-144> if max_ending_here < 0:max_ending_here = 0</line-144>
<line-145> return max_so_far </line-145>
<line-146> </line-146>
<line-147>def divisors(n):</line-147>
<line-148> result = []</line-148>
<line-149> for i in range(1,ceil(sqrt(n))+1):</line-149>
<line-150> if n%i == 0:</line-150>
<line-151> if n/i == i:result.append(i)</line-151>
<line-152> else:result.append(i);result.append(n/i)</line-152>
<line-153> return result</line-153>
<line-154></line-154>
<line-155>def sumtilln(n): return ((n*(n+1))//2)</line-155>
<line-156></line-156>
<line-157>def isPrime(n) : </line-157>
<line-158> if (n <= 1) :return False</line-158>
<line-159> if (n <= 3) :return True</line-159>
<line-160> if (n % 2 == 0 or n % 3 == 0) :return False</line-160>
<line-161> for i in range(5,ceil(sqrt(n))+1,6):</line-161>
<line-162> if (n % i == 0 or n % (i + 2) == 0) :return False</line-162>
<line-163> return True</line-163>
<line-164></line-164>
<line-165>def isPowerOf2(n):</line-165>
<line-166> while n % 2 == 0:n //= 2</line-166>
<line-167> return (True if n == 1 else False)</line-167>
<line-168></line-168>
<line-169>def power2(n):</line-169>
<line-170> k = 0</line-170>
<line-171> while n % 2 == 0:k += 1;n //= 2</line-171>
<line-172> return k</line-172>
<line-173></line-173>
<line-174>def sqsum(n):return ((n*(n+1))*(2*n+1)//6)</line-174>
<line-175> </line-175>
<line-176>def cusum(n):return ((sumn(n))**2)</line-176>
<line-177></line-177>
<line-178>def pa(a):</line-178>
<line-179> for i in range(len(a)):print(a[i], end = " ")</line-179>
<line-180> print()</line-180>
<line-181></line-181>
<line-182>def pm(a,rown,coln):</line-182>
<line-183> for i in range(rown):</line-183>
<line-184> for j in range(coln):print(a[i][j],end = " ")</line-184>
<line-185> print()</line-185>
<line-186></line-186>
<line-187>def pmasstring(a,rown,coln):</line-187>
<line-188> for i in range(rown):</line-188>
<line-189> for j in range(coln):print(a[i][j],end = "")</line-189>
<line-190> print()</line-190>
<line-191> </line-191>
<line-192>def isPerfectSquare(n):return pow(floor(sqrt(n)),2) == n</line-192>
<line-193></line-193>
<line-194>def nC2(n,m):return (((n*(n-1))//2) % m)</line-194>
<line-195></line-195>
<line-196>def modInverse(n,p):return powermodulo(n,p-2,p)</line-196>
<line-197></line-197>
<line-198>def ncrmodp(n, r, p): </line-198>
<line-199> num = den = 1</line-199>
<line-200> for i in range(r):num = (num * (n - i)) % p ;den = (den * (i + 1)) % p </line-200>
<line-201> return (num * powermodulo(den,p - 2, p)) % p </line-201>
<line-202></line-202>
<line-203>def reverse(string):return "".join(reversed(string)) </line-203>
<line-204></line-204>
<line-205>def listtostr(s):return ' '.join([str(elem) for elem in s]) </line-205>
<line-206></line-206>
<line-207>def binarySearch(arr, l, r, x): </line-207>
<line-208> while l <= r: </line-208>
<line-209> mid = l + (r - l) // 2; </line-209>
<line-210> if arr[mid] == x:return mid </line-210>
<line-211> elif arr[mid] < x:l = mid + 1</line-211>
<line-212> else:r = mid - 1</line-212>
<line-213> return -1</line-213>
<line-214></line-214>
<line-215>def isarrayodd(a):</line-215>
<line-216> r = True</line-216>
<line-217> for i in range(len(a)):</line-217>
<line-218> if a[i] % 2 == 0:</line-218>
<line-219> r = False</line-219>
<line-220> break</line-220>
<line-221> return r</line-221>
<line-222></line-222>
<line-223>def isPalindrome(s):return s == s[::-1] </line-223>
<line-224></line-224>
<line-225>def gt(x,h,c,t):return ((x*h+(x-1)*c)/(2*x-1))</line-225>
<line-226></line-226>
<line-227>def CountFrequency(my_list): </line-227>
<line-228> freq = {} </line-228>
<line-229> for item in my_list:freq[item] = (freq[item] + 1 if (item in freq) else 1)</line-229>
<line-230> return freq</line-230>
<line-231></line-231>
<line-232>def CountFrequencyasPair(my_list1,my_list2,freq): </line-232>
<line-233> for item in my_list1:freq[item][0] = (freq[item][0] + 1 if (item in freq) else 1)</line-233>
<line-234> for item in my_list2:freq[item][1] = (freq[item][1] + 1 if (item in freq) else 1) </line-234>
<line-235> return freq </line-235>
<line-236> </line-236>
<line-237>def binarySearchCount(arr, n, key): </line-237>
<line-238> left = 0;right = n - 1;count = 0 </line-238>
<line-239> while (left <= right): </line-239>
<line-240> mid = int((right + left) / 2) </line-240>
<line-241> if (arr[mid] <= key):count,left = mid + 1,mid + 1</line-241>
<line-242> else:right = mid - 1 </line-242>
<line-243> return count</line-243>
<line-244></line-244>
<line-245>def primes(n):</line-245>
<line-246> sieve,l = [True] * (n+1),[]</line-246>
<line-247> for p in range(2, n+1):</line-247>
<line-248> if (sieve[p]):</line-248>
<line-249> l.append(p)</line-249>
<line-250> for i in range(p, n+1, p):sieve[i] = False</line-250>
<line-251> return l</line-251>
<line-252></line-252>
<line-253>def Next_Greater_Element_for_all_in_array(arr): </line-253>
<line-254> s,n,reta,retb = list(),len(arr),[],[];arr1 = [list([0,i]) for i in range(n)]</line-254>
<line-255> for i in range(n - 1, -1, -1): </line-255>
<line-256> while (len(s) > 0 and s[-1][0] <= arr[i]):s.pop() </line-256>
<line-257> if (len(s) == 0):arr1[i][0] = -1 </line-257>
<line-258> else:arr1[i][0] = s[-1] </line-258>
<line-259> s.append(list([arr[i],i])) </line-259>
<line-260> for i in range(n):reta.append(list([arr[i],i]));retb.append(arr1[i][0])</line-260>
<line-261> return reta,retb</line-261>
<line-262></line-262>
<line-263>def polygonArea(X,Y,n): </line-263>
<line-264> area = 0.0;j = n - 1</line-264>
<line-265> for i in range(n):area += (X[j] + X[i]) * (Y[j] - Y[i]);j = i </line-265>
<line-266> return abs(area / 2.0)</line-266>
<line-267> </line-267>
<line-268>#defining a LRU Cache</line-268>
<line-269># where we can set values and get values based on our requirement</line-269>
<line-270>class LRUCache: </line-270>
<line-271> # initialising capacity </line-271>
<line-272> def __init__(self, capacity: int): </line-272>
<line-273> self.cache = OrderedDict() </line-273>
<line-274> self.capacity = capacity </line-274>
<line-275></line-275>
<line-276> # we return the value of the key </line-276>
<line-277> # that is queried in O(1) and return -1 if we </line-277>
<line-278> # don't find the key in out dict / cache. </line-278>
<line-279> # And also move the key to the end </line-279>
<line-280> # to show that it was recently used. </line-280>
<line-281> def get(self, key: int) -> int: </line-281>
<line-282> if key not in self.cache:return -1</line-282>
<line-283> else:self.cache.move_to_end(key);return self.cache[key] </line-283>
<line-284></line-284>
<line-285> # first, we add / update the key by conventional methods. </line-285>
<line-286> # And also move the key to the end to show that it was recently used. </line-286>
<line-287> # But here we will also check whether the length of our </line-287>
<line-288> # ordered dictionary has exceeded our capacity, </line-288>
<line-289> # If so we remove the first key (least recently used) </line-289>
<line-290> def put(self, key: int, value: int) -> None: </line-290>
<line-291> self.cache[key] = value;self.cache.move_to_end(key) </line-291>
<line-292> if len(self.cache) > self.capacity:self.cache.popitem(last = False)</line-292>
<line-293></line-293>
<line-294>class segtree:</line-294>
<line-295> def __init__(self,n):</line-295>
<line-296> self.m = 1</line-296>
<line-297> while self.m < n:self.m *= 2</line-297>
<line-298> self.data = [0] * (2 * self.m)</line-298>
<line-299> def __setitem__(self,i,x):</line-299>
<line-300> x = +(x != 1);i += self.m;self.data[i] = x;i >>= 1</line-300>
<line-301> while i:self.data[i] = self.data[2 * i] + self.data[2 * i + 1];i >>= 1</line-301>
<line-302> def __call__(self,l,r):</line-302>
<line-303> l += self.m;r += self.m;s = 0</line-303>
<line-304> while l < r:</line-304>
<line-305> if l & 1:s += self.data[l];l += 1</line-305>
<line-306> if r & 1:r -= 1;s += self.data[r]</line-306>
<line-307> l >>= 1;r >>= 1</line-307>
<line-308> return s </line-308>
<line-309></line-309>
<line-310>class FenwickTree:</line-310>
<line-311> def __init__(self, n):self.n = n;self.bit = [0]*(n+1) </line-311>
<line-312> def update(self, x, d):</line-312>
<line-313> while x <= self.n:self.bit[x] += d;x += (x & (-x)) </line-313>
<line-314> def query(self, x):</line-314>
<line-315> res = 0</line-315>
<line-316> while x > 0:res += self.bit[x];x -= (x & (-x))</line-316>
<line-317> return res</line-317>
<line-318> def range_query(self, l, r):return self.query(r) - self.query(l-1) </line-318>
<line-319># can add more template functions here</line-319>
<line-320> </line-320>
<line-321># end of template functions</line-321>
<line-322></line-322>
<line-323># To enable the file I/O i the below 2 lines are uncommented.</line-323>
<line-324># read from in.txt if uncommented</line-324>
<line-325>if os.path.exists('in.txt'): sys.stdin=open('in.txt','r')</line-325>
<line-326># will print on Console if file I/O is not activated</line-326>
<line-327>#if os.path.exists('out.txt'): sys.stdout=open('out.txt', 'w')</line-327>
<line-328></line-328>
<line-329># inputs template</line-329>
<line-330>#for fast input we areusing sys.stdin</line-330>
<line-331>def inp(): return sys.stdin.readline().strip()</line-331>
<line-332></line-332>
<line-333>#for fast output, always take string</line-333>
<line-334>def out(var): sys.stdout.write(str(var)) </line-334>
<line-335></line-335>
<line-336># cusom base input needed for the program</line-336>
<line-337>def I():return (inp())</line-337>
<line-338>def II():return (int(inp()))</line-338>
<line-339>def FI():return (float(inp()))</line-339>
<line-340>def SI():return (list(str(inp())))</line-340>
<line-341>def MI():return (map(int,inp().split()))</line-341>
<line-342>def LI():return (list(MI()))</line-342>
<line-343>def SLI():return (sorted(LI()))</line-343>
<line-344>def MF():return (map(float,inp().split()))</line-344>
<line-345>def LF():return (list(MF()))</line-345>
<line-346></line-346>
<line-347># end of inputs template</line-347>
<line-348></line-348>
<line-349># common modulo values used in competitive programming</line-349>
<line-350>MOD = 998244353</line-350>
<line-351>mod = 10**9+7</line-351>
<line-352></line-352>
<line-353># any particular user-defined functions for the code.</line-353>
<line-354># can be written here. </line-354>
<line-355>def solve():</line-355>
<line-356> n,m = MI();ss = []</line-356>
<line-357> for _ in range(n):ss.append(list(I()) + ['#'])</line-357>
<line-358> ss.append(['#']*(m+1))</line-358>
<line-359> for i in range(n-1, -1, -1):</line-359>
<line-360> for j in range(m-1, -1, -1):</line-360>
<line-361> if ss[i+1][j] == '#' and ss[i][j+1] == '#' and (i,j) != (n-1, m-1):ss[i][j] = '#'</line-361>
<line-362> res = [ss[0][0]];cend = {(0,0)}</line-362>
<line-363> for _ in range(n+m-2):</line-363>
<line-364> ncend = set();mn = 'z'</line-364>
<line-365> for i,j in cend:</line-365>
<line-366> if ss[i+1][j] != '#' and ss[i+1][j] <= mn:ncend.add((i+1, j));mn = ss[i+1][j]</line-366>
<line-367> if ss[i][j+1] != '#' and ss[i][j+1] <= mn:ncend.add((i, j+1));mn = ss[i][j+1]</line-367>
<line-368> res.append(mn)</line-368>
<line-369> cend = {(i,j) for (i,j) in ncend if ss[i][j] == mn}</line-369>
<line-370></line-370>
<line-371> print(''.join(res))</line-371>
<line-372># end of any user-defined functions</line-372>
<line-373></line-373>
<line-374># main functions for execution of the program.</line-374>
<line-375>def __starting_point(): </line-375>
<line-376> # execute your program from here.</line-376>
<line-377> # start your main code from here</line-377>
<line-378> </line-378>
<line-379> # Write your code here</line-379>
<line-380> for _ in range(II()):solve()</line-380>
<line-381> </line-381>
<line-382> # end of main code</line-382>
<line-383> # end of program</line-383>
<line-384></line-384>
<line-385># This program is written by :</line-385>
<line-386># Shubham Gupta</line-386>
<line-387># B.Tech (2019-2023)</line-387>
<line-388># Computer Science and Engineering,</line-388>
<line-389># Department of EECS</line-389>
<line-390># Contact No:8431624358</line-390>
<line-391># Indian Institute of Technology(IIT),Bhilai</line-391>
<line-392># Sejbahar,</line-392>
<line-393># Datrenga,</line-393>
<line-394># Raipur,</line-394>
<line-395># Chhattisgarh</line-395>
<line-396># 492015</line-396>
<line-397></line-397>
<line-398># THANK YOU FOR </line-398>
<line-400>__starting_point()</line-400>
|
{"code": "<line-3>from fractions import Fraction</line-3>\n<line-399>#YOUR KIND PATIENCE FOR READING THE PROGRAM. </line-399>", "lines": [3, 399]}
#### 0
|
<line-1>def check_relative(i,j):</line-1>
<line-3> if len(land[i].intersection(land[j]))>=k:</line-3>
<line-4> is_relative[i]=True</line-4>
<line-5> for ii in range(n):</line-5>
<line-6> check_relative(ii,i)</line-6>
<line-7></line-7>
<line-8>n,k=map(int,input().split())</line-8>
<line-9>land=[]</line-9>
<line-10>is_relative=[True]+[False]*(n-1)</line-10>
<line-11>for i in range(n):</line-11>
<line-12> p,*q=input().split()</line-12>
<line-13> land.append(set(map(int,q)))</line-13>
<line-14></line-14>
<line-15>for i in range(n):</line-15>
<line-17> </line-17>
<line-18>print(is_relative.count(True))</line-18>
|
{"code": "<line-2> if is_relative[i]:return</line-2>\n<line-16> check_relative(i,0)</line-16>", "lines": [2, 16]}
#### 0
|
<line-1># CHNGSS.py</line-1>
<line-2></line-2>
<line-4>from random import *</line-4>
<line-5></line-5>
<line-6>n,m,c = list(map(int,input().split()))</line-6>
<line-7>arr = [[1]*m for i in range(n)];</line-7>
<line-8>saved = 0;</line-8>
<line-9>for i in range(n):</line-9>
<line-10> for j in range(m):</line-10>
<line-11> print(1,(i+1),(i+1),(j+1),(j+1),1,25)</line-11>
<line-12> sys.stdout.flush()</line-12>
<line-13> a = int(input())</line-13>
<line-14> if a == 1 :</line-14>
<line-15> saved += 1;</line-15>
<line-16> arr[i][j] = randint(1,25);</line-16>
<line-17> else:</line-17>
<line-18> arr[i][j] = randint(25,50);</line-18>
<line-19>print(3);</line-19>
<line-20>sys.stdout.flush()</line-20>
<line-21>for a in arr :</line-21>
<line-22> print(' '.join(map(str,a)));</line-22>
<line-24># sys.exit(0);</line-24>
|
{"code": "<line-3>import sys</line-3>\n<line-23>\tsys.stdout.flush()</line-23>", "lines": [3, 23]}
#### 0
|
<line-1>import heapq</line-1>
<line-3>graph={i:[] for i in range(n)}</line-3>
<line-4>for i in range(m):</line-4>
<line-5> u,v,w=map(int,input().split())</line-5>
<line-6> graph[u-1].append((v-1,w))</line-6>
<line-7> graph[v-1].append((u-1,w))</line-7>
<line-8>components=[-1]*n</line-8>
<line-9>comp=-1</line-9>
<line-10>for i in range(n):</line-10>
<line-11> if components[i]==-1:</line-11>
<line-12> comp+=1</line-12>
<line-13> components[i]=comp</line-13>
<line-14> prev=[]</line-14>
<line-15> layer=[i]</line-15>
<line-16> while layer!=[]:</line-16>
<line-17> newlayer=[]</line-17>
<line-18> for guy in layer:</line-18>
<line-19> for guy1 in graph[guy]:</line-19>
<line-20> if guy1[1]==a and components[guy1[0]]==-1:</line-20>
<line-21> newlayer.append(guy1[0])</line-21>
<line-22> components[guy1[0]]=comp</line-22>
<line-23> prev=layer[:]</line-23>
<line-24> layer=newlayer[:]</line-24>
<line-25>useless=[]</line-25>
<line-26>for guy in graph:</line-26>
<line-27> for neigh in graph[guy]:</line-27>
<line-28> if components[guy]==components[neigh[0]] and neigh[1]==b:</line-28>
<line-29> useless.append((guy,neigh))</line-29>
<line-30>for guy in useless:</line-30>
<line-31> graph[guy[0]].remove(guy[1])</line-31>
<line-32>counts=[0]*(comp+1)</line-32>
<line-33>for i in range(n):</line-33>
<line-34> counts[components[i]]+=1</line-34>
<line-35>bad=[]</line-35>
<line-36>for i in range(comp+1):</line-36>
<line-37> if counts[i]<=3:</line-37>
<line-38> bad.append(i)</line-38>
<line-39> for j in range(n):</line-39>
<line-40> if components[j]==i:</line-40>
<line-41> components[j]=-1</line-41>
<line-42>for guy in bad[::-1]:</line-42>
<line-43> for i in range(n):</line-43>
<line-44> if components[i]>guy:</line-44>
<line-45> components[i]-=1</line-45>
<line-46>comp-=len(bad)</line-46>
<line-47>comp+=1</line-47>
<line-48>dists=[[float("inf") for i in range(2**comp)] for j in range(n)]</line-48>
<line-49>dists[0][0]=0</line-49>
<line-50>pq=[]</line-50>
<line-51>heapq.heappush(pq,[0,0,0])</line-51>
<line-52>remaining=n</line-52>
<line-53>visited=[0]*n</line-53>
<line-54>while len(pq)>0 and remaining>0:</line-54>
<line-55> dist,vert,mask=heapq.heappop(pq)</line-55>
<line-56> if visited[vert]==0:</line-56>
<line-57> visited[vert]=1</line-57>
<line-58> remaining-=1</line-58>
<line-59> for neigh in graph[vert]:</line-59>
<line-60> if neigh[1]==b:</line-60>
<line-61> if components[vert]==components[neigh[0]] and components[vert]!=-1:</line-61>
<line-62> continue</line-62>
<line-63> if components[neigh[0]]!=-1:</line-63>
<line-64> if mask & (2**components[neigh[0]])>0:</line-64>
<line-65> continue</line-65>
<line-66> if components[vert]!=-1:</line-66>
<line-67> maskn=mask+2**(components[vert])</line-67>
<line-68> else:</line-68>
<line-69> maskn=mask</line-69>
<line-70> else:</line-70>
<line-71> maskn=mask</line-71>
<line-72> if dist+neigh[1]<dists[neigh[0]][maskn]:</line-72>
<line-73> dists[neigh[0]][maskn]=dist+neigh[1]</line-73>
<line-74> heapq.heappush(pq,[dist+neigh[1],neigh[0],maskn])</line-74>
<line-76>print(" ".join(optimal))</line-76>
|
{"code": "<line-2>n,m,a,b=map(int,input().split())</line-2>\n<line-75>optimal=[str(min(dists[i])) for i in range(n)]</line-75>", "lines": [2, 75]}
#### 0
|
<line-1>X, D = list(map(int, input().split()))</line-1>
<line-3>add0 = 1 if (X&1) else 0</line-3>
<line-4>ans = []</line-4>
<line-5>for i in range(30,0,-1):</line-5>
<line-6> if not (X & (1<<i)): continue</line-6>
<line-7> ans += [cn]*i</line-7>
<line-8> add0 += 1</line-8>
<line-9> cn += D</line-9>
<line-10>for i in range(add0):</line-10>
<line-11> ans.append(cn)</line-11>
<line-12> cn += D</line-12>
<line-14>print(' '.join(map(str, ans)))</line-14>
|
{"code": "<line-2>cn = 1</line-2>\n<line-13>print(len(ans))</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>str = input()</line-1>
<line-3>a = [0] * (2 * l)</line-3>
<line-4>pos = [[] for i in range(26)]</line-4>
<line-5>for i, c in enumerate(str):</line-5>
<line-6> t = ord(c) - ord('a')</line-6>
<line-7> a[i] = t</line-7>
<line-8> a[i + l] = t</line-8>
<line-9> pos[t].append(i)</line-9>
<line-10>ans = 0</line-10>
<line-11>for c in range(26):</line-11>
<line-12> cur = 0</line-12>
<line-13> for k in range(1, l):</line-13>
<line-14> cnt = [0] * 26</line-14>
<line-15> for i in pos[c]:</line-15>
<line-16> cnt[a[i + k]] += 1</line-16>
<line-17> cur = max(cur, len(list([x for x in cnt if x == 1])))</line-17>
<line-19>print(ans / l)</line-19>
|
{"code": "<line-2>l = len(str)</line-2>\n<line-18> ans += cur</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>from bisect import *</line-1>
<line-3></line-3>
<line-4>n = int(input())</line-4>
<line-5>a, b, c, d = list(map(int,input().replace('/',' ').split()))</line-5>
<line-6></line-6>
<line-7>alpha = atan2(c,d) - atan2(a,b)</line-7>
<line-8>tan_alpha = tan(alpha)</line-8>
<line-9></line-9>
<line-10>lis = []</line-10>
<line-11></line-11>
<line-12>for x,y in sorted((y/tan_alpha - x,y) for x,y in [ (x,y) for x,y in [(b*x + a*y,-a*x + b*y) for x, y in [list(map(int,input().split())) for _ in range(n)] if a*x - b*y <= 0 and d*y - c*x <= 0]]):</line-12>
<line-13> pos = bisect_left(lis,-y)</line-13>
<line-14> if pos == len(lis):</line-14>
<line-15> lis.append(-y)</line-15>
<line-16> else:</line-16>
<line-18></line-18>
<line-19>print(len(lis))</line-19>
<line-20></line-20>
|
{"code": "<line-2>from math import *</line-2>\n<line-17> lis[pos] = -y</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>x = input ()</line-1>
<line-2></line-2>
<line-4>s = 0</line-4>
<line-5></line-5>
<line-6>for each_item in x:</line-6>
<line-7> if each_item == '0':</line-7>
<line-8> if flag == 0:</line-8>
<line-9> flag = 1;</line-9>
<line-10> continue</line-10>
<line-11> else:</line-11>
<line-12> print (each_item, end = '')</line-12>
<line-13> else:</line-13>
<line-14> if (s == len (x) - 1 and flag == 0) :</line-14>
<line-15> continue</line-15>
<line-17> s = s + 1</line-17>
|
{"code": "<line-3>flag = 0</line-3>\n<line-16> print (each_item, end = '')</line-16>", "lines": [3, 16]}
#### 0
|
<line-1>X = [[], ['0', '1'], ['00', '01', '10', '11'], ['001', '010', '011', '100', '101', '110'], ['0010', '0011', '0100', '0101', '0110', '1001', '1010', '1011', '1100', '1101'], ['00100', '00101', '00110', '01001', '01011', '01100', '01101', '10010', '10011', '10100', '10110', '11001', '11010', '11011'], ['001001', '001011', '001100', '001101', '010010', '010011', '010110', '011001', '011010', '011011', '100100', '100101', '100110', '101001', '101100', '101101', '110010', '110011', '110100', '110110'], ['0010011', '0011001', '0011010', '0011011', '0100101', '0101100', '0101101', '0110011', '1001100', '1010010', '1010011', '1011010', '1100100', '1100101', '1100110', '1101100'], ['00110011', '01011010', '01100110', '10011001', '10100101', '11001100']]</line-1>
<line-3>N = len(s)</line-3>
<line-4>ans = (N-1)*(N-2)//2</line-4>
<line-5>for i in range(N):</line-5>
<line-6> for j in range(i+3, min(i+9, N+1)):</line-6>
<line-7> if s[i:j] in X[j-i]:</line-7>
<line-9>print(ans)</line-9>
|
{"code": "<line-2>s = input()</line-2>\n<line-8> ans -= 1</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>def gcd(a, b):</line-1>
<line-3> a, b = b, a % b</line-3>
<line-4> return a</line-4>
<line-5></line-5>
<line-6>n = int(input())</line-6>
<line-7>A = list(map(int, input().split()))</line-7>
<line-8></line-8>
<line-9>GCD = A[0]</line-9>
<line-10>for x in A[1:]:</line-10>
<line-11> GCD = gcd(GCD, x)</line-11>
<line-12>num = max(A) // GCD - n</line-12>
<line-13>if num % 2 == 0:</line-13>
<line-14> print("Bob")</line-14>
<line-16> print("Alice")</line-16>
<line-17></line-17>
|
{"code": "<line-2> while b > 0:</line-2>\n<line-15>else:</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from math import *</line-3>
<line-4>def solve():</line-4>
<line-5> n, m = map(int, input().split())</line-5>
<line-6> h = list(map(int, input().split()))</line-6>
<line-7> p = list(map(int, input().split()))</line-7>
<line-8> ss, ll = 0, int(2.2e10)</line-8>
<line-9> while ss < ll:</line-9>
<line-10> avg = (ss + ll) // 2</line-10>
<line-11> works = True</line-11>
<line-12> hidx = 0</line-12>
<line-13> pidx = 0</line-13>
<line-14> while hidx < len(h) and pidx < len(p):</line-14>
<line-15> leftget = p[pidx]</line-15>
<line-16> curpos = h[hidx]</line-16>
<line-17> if curpos - leftget > avg:</line-17>
<line-18> works = False</line-18>
<line-19> break</line-19>
<line-20> getbacktime = max(0, 2*(curpos - leftget))</line-20>
<line-21> alsotoright = max(0, avg - getbacktime)</line-21>
<line-22> leftime = max(0, curpos - leftget)</line-22>
<line-23> remtime = max(0, (avg - leftime) // 2)</line-23>
<line-24> furthestright = curpos + max(alsotoright, remtime)</line-24>
<line-25> while pidx < len(p) and p[pidx] <= furthestright: pidx += 1</line-25>
<line-26> hidx += 1</line-26>
<line-27> if pidx != len(p): works = False</line-27>
<line-28> if works: ll = avg</line-28>
<line-29> else: ss = avg + 1</line-29>
<line-30> print(ss)</line-30>
<line-31></line-31>
<line-32></line-32>
<line-34>solve()</line-34>
|
{"code": "<line-2>from itertools import *</line-2>\n<line-33>if sys.hexversion == 50594544 : sys.stdin = open(\"test.txt\")</line-33>", "lines": [2, 33]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>n = int(stdin.readline())</line-5>
<line-6></line-6>
<line-7>seq = [int(x) for x in stdin.readline().split()]</line-7>
<line-8>carry = seq[0]</line-8>
<line-9>result = [carry]</line-9>
<line-10></line-10>
<line-11>mark = False</line-11>
<line-12>cur_len = 0</line-12>
<line-13>max_len = 0</line-13>
<line-14></line-14>
<line-15>i = 1</line-15>
<line-16>while i < len(seq) - 1:</line-16>
<line-17> if mark:</line-17>
<line-18> if seq[i] != seq[i + 1]:</line-18>
<line-19> cur_len += 1</line-19>
<line-20> else:</line-20>
<line-21> if cur_len > max_len:</line-21>
<line-22> max_len = cur_len</line-22>
<line-23></line-23>
<line-24> if seq[i] == carry:</line-24>
<line-25> result.extend([carry]*cur_len)</line-25>
<line-26> else:</line-26>
<line-27> result.extend([carry]*(cur_len//2))</line-27>
<line-28> result.extend([seq[i]]*(cur_len//2))</line-28>
<line-29></line-29>
<line-30> result.append(seq[i])</line-30>
<line-31> mark = False</line-31>
<line-32> cur_len = 0</line-32>
<line-33> elif seq[i] != seq[i - 1] and seq[i] != seq[i + 1]:</line-33>
<line-34> mark = True</line-34>
<line-35> cur_len = 1</line-35>
<line-36> carry = seq[i - 1]</line-36>
<line-37> else:</line-37>
<line-38> result.append(seq[i])</line-38>
<line-39></line-39>
<line-40> i += 1</line-40>
<line-41></line-41>
<line-42>if mark:</line-42>
<line-43> if cur_len > max_len:</line-43>
<line-44> max_len = cur_len</line-44>
<line-45></line-45>
<line-46> if seq[i] == carry:</line-46>
<line-47> result.extend([carry]*cur_len)</line-47>
<line-48> else:</line-48>
<line-49> result.extend([carry]*(cur_len//2))</line-49>
<line-50> result.extend([seq[i]]*(cur_len//2))</line-50>
<line-51></line-51>
<line-52>result.append(seq[i])</line-52>
<line-53></line-53>
<line-54>print((max_len + 1)//2)</line-54>
<line-56> print(x, end=' ')</line-56>
|
{"code": "<line-3>#stdin = open('input.txt')</line-3>\n<line-55>for x in result:</line-55>", "lines": [3, 55]}
#### 0
|
<line-1>import random</line-1>
<line-2></line-2>
<line-4>v = []</line-4>
<line-5>a = []</line-5>
<line-6>for i in range(n):</line-6>
<line-7> a.append(i)</line-7>
<line-8></line-8>
<line-9>for _ in range(0, n):</line-9>
<line-10> x, y = list(map(int, input().split()))</line-10>
<line-11> v.append([x, y, x*x+y*y])</line-11>
<line-12></line-12>
<line-13>while 1>0:</line-13>
<line-14> x = 0</line-14>
<line-15> y = 0</line-15>
<line-16> ans = [0]*n</line-16>
<line-17> random.shuffle(a)</line-17>
<line-18> for i in range(n):</line-18>
<line-19> if (x+v[a[i]][0])**2+(y+v[a[i]][1])**2 <= (x-v[a[i]][0])**2+(y-v[a[i]][1])**2:</line-19>
<line-20> x += v[a[i]][0]</line-20>
<line-21> y += v[a[i]][1]</line-21>
<line-22> ans[a[i]] = 1</line-22>
<line-23> else:</line-23>
<line-24> x -= v[a[i]][0]</line-24>
<line-25> y -= v[a[i]][1]</line-25>
<line-26> ans[a[i]] = -1</line-26>
<line-27> if x*x+y*y <= 1500000**2:</line-27>
<line-29> break</line-29>
<line-30></line-30>
|
{"code": "<line-3>n = int(input())</line-3>\n<line-28> print(*ans)</line-28>", "lines": [3, 28]}
#### 0
|
<line-1></line-1>
<line-2>x = int(input())</line-2>
<line-4></line-4>
<line-5>y[0] = 1</line-5>
<line-6>y[x-1] = 1</line-6>
<line-7></line-7>
<line-8>z = y[:]</line-8>
<line-9>for i in range(1, x):</line-9>
<line-10> z[i] = min(z[i], z[i-1] + 1)</line-10>
<line-11></line-11>
<line-12>w = y[:]</line-12>
<line-13>for i in range(x-2, -1, -1):</line-13>
<line-14> w[i] = min(w[i], w[i+1]+1)</line-14>
<line-15></line-15>
<line-16>ans = 0</line-16>
<line-17>for i in range(x):</line-17>
<line-19></line-19>
<line-20>print(ans)</line-20>
|
{"code": "<line-3>y = list(map(int, input().split(' ')))</line-3>\n<line-18> ans = max(ans, min(z[i], w[i]))</line-18>", "lines": [3, 18]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>for i in range(max(0,n-100),n+1):</line-3>
<line-4> j=i</line-4>
<line-5> res=i</line-5>
<line-6> while j:</line-6>
<line-7> res+=j%10</line-7>
<line-8> j//=10</line-8>
<line-9> if res==n:</line-9>
<line-10> q.append(i)</line-10>
<line-11>print(len(q))</line-11>
<line-13> print(i)</line-13>
|
{"code": "<line-2>q=[]</line-2>\n<line-12>for i in q:</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3> print(-1)</line-3>
<line-4>else:</line-4>
<line-5> a = [n+1>>1]*n</line-5>
<line-6> for i in range(n//4):</line-6>
<line-7> j = i*2</line-7>
<line-9> print(' '.join(map(str, a)))</line-9>
|
{"code": "<line-2>if n%4 > 1:</line-2>\n<line-8> a[j], a[j+1], a[-2-j], a[-1-j] = j+2, n-j, j+1, n-1-j</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>#!/usr/bin/env python3</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>try:</line-5>
<line-6> while True:</line-6>
<line-7> s = input()</line-7>
<line-8> m = re.search(r"[^a]", s)</line-8>
<line-9> if m is None:</line-9>
<line-10> print(s[:-1], end="z\n")</line-10>
<line-11> else:</line-11>
<line-12> j = s.find('a', m.end())</line-12>
<line-13> if j == -1:</line-13>
<line-14> j = len(s)</line-14>
<line-15> print(end=s[:m.start()])</line-15>
<line-16> for i in range(m.start(), j):</line-16>
<line-17> print(end=chr((ord(s[i]) - 98) % 26 + 97))</line-17>
<line-18> print(s[j:])</line-18>
<line-19></line-19>
<line-21> pass</line-21>
|
{"code": "<line-3>import re</line-3>\n<line-20>except EOFError:</line-20>", "lines": [3, 20]}
#### 0
|
<line-1>mod = 1000000007</line-1>
<line-2></line-2>
<line-4> if k < add : return 0</line-4>
<line-5> up = x + add</line-5>
<line-6> if up > k : up = k</line-6>
<line-7> add = add + 1</line-7>
<line-8> return y * ( ( (add + up) * (up - add + 1) // 2 ) % mod ) % mod</line-8>
<line-9></line-9>
<line-10>def solve(x, y, k, add = 0) :</line-10>
<line-11> if x == 0 or y == 0 : return 0</line-11>
<line-12> if x > y :</line-12>
<line-13> x, y = y, x</line-13>
<line-14> pw = 1</line-14>
<line-15> while (pw << 1) <= y :</line-15>
<line-16> pw <<= 1</line-16>
<line-17> if pw <= x :</line-17>
<line-18> return ( sum(pw, pw, k, add)\</line-18>
<line-19> + sum(pw, x + y - pw - pw, k, add + pw)\</line-19>
<line-20> + solve(x - pw, y - pw, k, add) ) % mod</line-20>
<line-21> else :</line-21>
<line-22> return ( sum(pw, x, k, add)\</line-22>
<line-23> + solve(x, y - pw, k, add + pw) ) % mod</line-23>
<line-24></line-24>
<line-25>q = int(input())</line-25>
<line-26>for i in range(0, q) :</line-26>
<line-27> x1, y1, x2, y2, k = list(map(int, input().split())) </line-27>
<line-28> ans = ( solve(x2, y2, k)\</line-28>
<line-29> - solve(x1 - 1, y2, k)\</line-29>
<line-30> - solve(x2, y1 - 1, k)\</line-30>
<line-31> + solve(x1 - 1, y1 - 1, k) ) % mod</line-31>
<line-33> print(ans)</line-33>
|
{"code": "<line-3>def sum(x, y, k, add) :</line-3>\n<line-32> if ans < 0 : ans += mod</line-32>", "lines": [3, 32]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>v = [ list(map(int, input().split())) for i in range(n)]</line-5>
<line-6></line-6>
<line-7>res = []</line-7>
<line-8></line-8>
<line-9>for i in range(n):</line-9>
<line-10> if v[i][2] >= 0:</line-10>
<line-11> res.append(i + 1)</line-11>
<line-12> dec = 0</line-12>
<line-13> for j in range(i + 1, n):</line-13>
<line-14> if v[j][2] >= 0:</line-14>
<line-15> if v[i][0] > 0:</line-15>
<line-16> v[j][2] -= v[i][0]</line-16>
<line-17> v[i][0] -= 1</line-17>
<line-18> v[j][2] -= dec</line-18>
<line-19> if v[j][2] < 0: dec += v[j][1]</line-19>
<line-20></line-20>
<line-22>print(" ".join(map(str, res)))</line-22>
|
{"code": "<line-3>n = int(input())</line-3>\n<line-21>print(len(res))</line-21>", "lines": [3, 21]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>n,m=list(map(int,input().split()))</line-4>
<line-5>W=[0]+list(map(int,input().split()))</line-5>
<line-6>E=[tuple(map(int,input().split())) for i in range(m)]</line-6>
<line-7>S=int(input())</line-7>
<line-8></line-8>
<line-9>ELIST=[[] for i in range(n+1)]</line-9>
<line-10>EW=[0]*(n+1)</line-10>
<line-11></line-11>
<line-12>for x,y in E:</line-12>
<line-13> ELIST[x].append(y)</line-13>
<line-14> ELIST[y].append(x)</line-14>
<line-15></line-15>
<line-16> EW[x]+=1</line-16>
<line-17> EW[y]+=1</line-17>
<line-18></line-18>
<line-19></line-19>
<line-20>from collections import deque</line-20>
<line-21>Q=deque()</line-21>
<line-22>USED=[0]*(n+1)</line-22>
<line-23></line-23>
<line-24>for i in range(1,n+1):</line-24>
<line-25> if EW[i]==1 and i!=S:</line-25>
<line-26> USED[i]=1</line-26>
<line-27> Q.append(i)</line-27>
<line-28></line-28>
<line-29>EW[S]+=1<<50</line-29>
<line-30>USED[S]=1</line-30>
<line-31></line-31>
<line-32>while Q:</line-32>
<line-33> x=Q.pop()</line-33>
<line-34> EW[x]-=1</line-34>
<line-35></line-35>
<line-36> for to in ELIST[x]:</line-36>
<line-37> if USED[to]==1:</line-37>
<line-38> continue</line-38>
<line-39> EW[to]-=1</line-39>
<line-40></line-40>
<line-41> if EW[to]==1 and USED[to]==0:</line-41>
<line-42> Q.append(to)</line-42>
<line-43> USED[to]=1</line-43>
<line-44></line-44>
<line-45>#print(EW)</line-45>
<line-46>LOOP=[]</line-46>
<line-47></line-47>
<line-48>ANS=0</line-48>
<line-49>for i in range(1,n+1):</line-49>
<line-50> if EW[i]!=0:</line-50>
<line-51> ANS+=W[i]</line-51>
<line-52> LOOP.append(i)</line-52>
<line-53></line-53>
<line-54>SCORE=[0]*(n+1)</line-54>
<line-55>USED=[0]*(n+1)</line-55>
<line-56></line-56>
<line-57>for l in LOOP:</line-57>
<line-58> SCORE[l]=ANS</line-58>
<line-59> USED[l]=1</line-59>
<line-60></line-60>
<line-61>Q=deque(LOOP)</line-61>
<line-62></line-62>
<line-63>while Q:</line-63>
<line-64> x=Q.pop()</line-64>
<line-65></line-65>
<line-66> for to in ELIST[x]:</line-66>
<line-67> if USED[to]==1:</line-67>
<line-68> continue</line-68>
<line-69></line-69>
<line-70> SCORE[to]=W[to]+SCORE[x]</line-70>
<line-71> Q.append(to)</line-71>
<line-73></line-73>
<line-74>print(max(SCORE))</line-74>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-72> USED[to]=1</line-72>", "lines": [2, 72]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>seen = {}</line-5>
<line-6></line-6>
<line-7>res = 0</line-7>
<line-8></line-8>
<line-9>while xs:</line-9>
<line-10> j = xs.index(xs[0], 1)</line-10>
<line-11> res += j - 1</line-11>
<line-13></line-13>
<line-14>print(res)</line-14>
|
{"code": "<line-3>xs = [int(x) for x in input().split()]</line-3>\n<line-12> xs = xs[1:j] + xs[j+1:]</line-12>", "lines": [3, 12]}
#### 0
|
<line-1>n,m=map(int,input().split());a=list(map(int,input().split()));p=0;t=[0]*3</line-1>
<line-3> if(a[i]<a[p]):p=i </line-3>
<line-4>if(n==2):print('0\n1 1\n')</line-4>
<line-5>else:</line-5>
<line-6> a.sort();t[0]=min(a[0]+a[1]+m,a[1]+a[2]);t[1]=max(a[0]+a[n-1]+m,a[n-2]+a[n-1]);t[2]=(a[n-2]+a[n-1])-(a[0]+a[1])</line-6>
<line-7> if(t[1]-t[0]>t[2]):p=n</line-7>
<line-8> else:t[2]=t[1]-t[0]</line-8>
<line-10> for i in range(n):print(int(i==p)+1,end=' ')</line-10>
|
{"code": "<line-2>for i in range(n):</line-2>\n<line-9> print(t[2]) </line-9>", "lines": [2, 9]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>r = n-2</line-3>
<line-4>for d in a:</line-4>
<line-6>print(max(max(a), r//(n-1)))</line-6>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-5> r += d</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>import math</line-1>
<line-3>from functools import reduce</line-3>
<line-4></line-4>
<line-5>n = int(input())</line-5>
<line-6>odd = -1</line-6>
<line-7>beads = [int(x) for x in input().split()]</line-7>
<line-8>for i in range(n):</line-8>
<line-9> if beads[i]%2:</line-9>
<line-10> if odd >= 0:</line-10>
<line-11> print(0)</line-11>
<line-12> print(''.join(chr(ord('a') + i)*beads[i] for i in range(n)))</line-12>
<line-13> break</line-13>
<line-14> else:</line-14>
<line-15> odd = i</line-15>
<line-16>else:</line-16>
<line-17> gcd = reduce(lambda x,y: math.gcd(x,y), beads)</line-17>
<line-18> print(gcd)</line-18>
<line-19> if odd >= 0:</line-19>
<line-20> s = ''.join(chr(ord('a') + i)*(beads[i]//(2*gcd)) for i in range(n) if i != odd)</line-20>
<line-21> p = s + chr(ord('a') + odd)*(beads[odd]//gcd) + s[::-1]</line-21>
<line-22> print(p*gcd)</line-22>
<line-23> else:</line-23>
<line-24> s = ''.join(chr(ord('a') + i)*(beads[i]//gcd) for i in range(n))</line-24>
<line-26> print(p*(gcd//2))</line-26>
|
{"code": "<line-2>#import fractions</line-2>\n<line-25> p = s + s[::-1]</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>def main():</line-1>
<line-3> l = [[] for _ in range(n + 1)]</line-3>
<line-4> for _ in range(m):</line-4>
<line-5> u, v = list(map(int, input().split()))</line-5>
<line-6> l[u].append(v)</line-6>
<line-7> l[v].append(u)</line-7>
<line-8> res = [0] * (n + 1)</line-8>
<line-9> for u, x in enumerate(res):</line-9>
<line-10> if not x:</line-10>
<line-11> x, nxt = -1, [u]</line-11>
<line-12> while nxt:</line-12>
<line-13> x, cur, nxt = -x, nxt, []</line-13>
<line-14> for u in cur:</line-14>
<line-15> if l[u]:</line-15>
<line-16> res[u] = x</line-16>
<line-17> for v in l[u]:</line-17>
<line-18> if not res[v]:</line-18>
<line-19> nxt.append(v)</line-19>
<line-20> elif res[v] == x:</line-20>
<line-21> print(-1)</line-21>
<line-22> return</line-22>
<line-23> for x in -1, 1:</line-23>
<line-24> l = [u for u in range(1, n + 1) if res[u] == x]</line-24>
<line-25> print(len(l))</line-25>
<line-26> print(' '.join(map(str, l)))</line-26>
<line-27></line-27>
<line-28></line-28>
<line-29>def __starting_point():</line-29>
<line-31></line-31>
<line-32>__starting_point()</line-32>
|
{"code": "<line-2> n, m = list(map(int, input().split()))</line-2>\n<line-30> main()</line-30>", "lines": [2, 30]}
#### 0
|
<line-1>n,m=map(int,input().split())</line-1>
<line-3>elif n==3and m==3:</line-3>
<line-4> print('YES')</line-4>
<line-5> print(6, 1, 8)</line-5>
<line-6> print(7,5,3)</line-6>
<line-7> print(2,9,4)</line-7>
<line-8>elif n<4and m<4:print('NO')</line-8>
<line-9>elif n==1 or m==1:</line-9>
<line-10> t=max(n,m)</line-10>
<line-11> a=[i for i in range(2,t+1,2)]</line-11>
<line-12> a+=[i for i in range(1,t+1,2)]</line-12>
<line-13> print('YES')</line-13>
<line-14> for i in a:print(i,end="");print([' ','\n'][m==1],end='')</line-14>
<line-15>else:</line-15>
<line-16> a=[]</line-16>
<line-17> for j in range(n):</line-17>
<line-18> a.append([int(i)+int(m*j) for i in range(1,m+1)])</line-18>
<line-19> if n<=m:</line-19>
<line-20> for j in range(1,m,2):</line-20>
<line-21> t=a[0][j]</line-21>
<line-22> for i in range(1,n):</line-22>
<line-23> a[i-1][j]=a[i][j]</line-23>
<line-24> a[n-1][j]=t</line-24>
<line-25> for i in range(1,n,2):</line-25>
<line-26> r,s=a[i][0],a[i][1]</line-26>
<line-27> for j in range(2,m):</line-27>
<line-28> a[i][j-2]=a[i][j]</line-28>
<line-29> a[i][m-2],a[i][m-1]=r,s</line-29>
<line-30> else:</line-30>
<line-31> for j in range(1,m,2):</line-31>
<line-32> r,s=a[0][j],a[1][j]</line-32>
<line-33> for i in range(2,n):</line-33>
<line-34> a[i-2][j]=a[i][j]</line-34>
<line-35> a[n-2][j], a[n-1][j] = r, s</line-35>
<line-36> for i in range(1,n,2):</line-36>
<line-37> t=a[i][0]</line-37>
<line-38> for j in range(1,m):</line-38>
<line-39> a[i][j-1]=a[i][j]</line-39>
<line-40> a[i][m-1]=t</line-40>
<line-41> print('YES')</line-41>
<line-43> print(*a[i])</line-43>
|
{"code": "<line-2>if n==1and m==1:print('YES\\n1')</line-2>\n<line-42> for i in range(n):</line-42>", "lines": [2, 42]}
#### 0
|
<line-1>from math import sqrt</line-1>
<line-3>k = int(sqrt(n))</line-3>
<line-4>b = []</line-4>
<line-5>last = 0</line-5>
<line-6>while last < n:</line-6>
<line-7> b.append([last + j for j in range(k)])</line-7>
<line-8> last = b[-1][-1] + 1</line-8>
<line-9>k = len(b)</line-9>
<line-10>for i in range(k - 1, -1, -1):</line-10>
<line-11> for j in b[i]:</line-11>
<line-12> if j < n:</line-12>
<line-14>print()</line-14>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-13> print(1 + j, end=' ')</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>n = input()</line-1>
<line-3>p = []</line-3>
<line-4>for x in read.split():</line-4>
<line-5> p.append((float)(x))</line-5>
<line-6> </line-6>
<line-7>v = 0.0</line-7>
<line-8>l = 0.0</line-8>
<line-9>for item in p:</line-9>
<line-10> v = v*(1-item) + item*(v + 2*l + 1)</line-10>
<line-12>print(v)</line-12>
|
{"code": "<line-2>read = input()</line-2>\n<line-11> l = (l + 1)*item</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>def main():</line-1>
<line-3> result = []</line-3>
<line-4> for i in range(2, n + 1):</line-4>
<line-5> j = 2</line-5>
<line-6> while j * j <= i:</line-6>
<line-7> if i % j == 0:</line-7>
<line-8> break</line-8>
<line-9> j += 1</line-9>
<line-10> else:</line-10>
<line-11> j = i</line-11>
<line-12> while j <= n:</line-12>
<line-13> result.append(j)</line-13>
<line-14> j *= i</line-14>
<line-15> </line-15>
<line-16> print(len(result))</line-16>
<line-18> </line-18>
<line-19> </line-19>
<line-20> </line-20>
<line-21>main()</line-21>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-17> print(' '.join(str(i) for i in result))</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>n, d = map(int, input().split())</line-1>
<line-3>x = []</line-3>
<line-4>y = []</line-4>
<line-5>for i in range(n):</line-5>
<line-6> xx, yy = map(int, input().split())</line-6>
<line-7> x += [xx]</line-7>
<line-8> y += [yy]</line-8>
<line-9>b = [-1] * n</line-9>
<line-10>b[0] = 0</line-10>
<line-11>c = True</line-11>
<line-12>while c:</line-12>
<line-13> c = False</line-13>
<line-14> for i in range(n):</line-14>
<line-15> for j in range(1, n):</line-15>
<line-16> if i != j and b[i] != -1:</line-16>
<line-17> t = b[i] + (abs(x[i] - x[j]) + abs(y[i] - y[j])) * d - a[j]</line-17>
<line-18> if b[j] == -1 or t < b[j]:</line-18>
<line-19> b[j] = t</line-19>
<line-21>print(b[-1])</line-21>
|
{"code": "<line-2>a = [0] + list(map(int, input().split())) + [0]</line-2>\n<line-20> c = True</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>t = input()</line-1>
<line-3>a.reverse()</line-3>
<line-5>print('\n'.join(map(str, a)))</line-5>
|
{"code": "<line-2>a, b = [i for i, d in enumerate(t, 1) if d == 'l'], [i for i, d in enumerate(t, 1) if d == 'r']</line-2>\n<line-4>print('\\n'.join(map(str, b)))</line-4>", "lines": [2, 4]}
#### 0
|
<line-1></line-1>
<line-2>def solve(s):</line-2>
<line-4></line-4>
<line-5> for i in range(n):</line-5>
<line-6> s2 = s[i:] + s[:i]</line-6>
<line-7> # print(s2)</line-7>
<line-8> if s != s2 and s2[::-1] == s2:</line-8>
<line-9> return 1</line-9>
<line-10></line-10>
<line-11> for i in range( (n // 2) + 1, n):</line-11>
<line-12> if s[i] != s[0]:</line-12>
<line-13> return 2</line-13>
<line-14> # print(s[i])</line-14>
<line-15> return "Impossible"</line-15>
<line-16></line-16>
<line-18>print(solve(s))</line-18>
|
{"code": "<line-3> n = len(s)</line-3>\n<line-17>s = input()</line-17>", "lines": [3, 17]}
#### 0
|
<line-1>def main():</line-1>
<line-3> ans = [0] * (2 * n)</line-3>
<line-4> for i in range(n):</line-4>
<line-5> a = 2 * i + 1</line-5>
<line-6> b = 2 * i + 2</line-6>
<line-7> if i & 1:</line-7>
<line-8> ans[i] = a</line-8>
<line-9> ans[i + n] = b</line-9>
<line-10> else:</line-10>
<line-11> ans[i] = b</line-11>
<line-12> ans[i + n] = a</line-12>
<line-13> ans *= 2</line-13>
<line-14> curr = sum(ans[:n])</line-14>
<line-15> mi = curr</line-15>
<line-16> ma = curr</line-16>
<line-17> for i in range(n, 4 * n):</line-17>
<line-18> curr -= ans[i - n]</line-18>
<line-19> curr += ans[i]</line-19>
<line-20> mi = min(mi, curr)</line-20>
<line-21> ma = max(ma, curr)</line-21>
<line-22> if ma - mi > 1:</line-22>
<line-23> print("NO")</line-23>
<line-24> else:</line-24>
<line-25> print("YES")</line-25>
<line-26> print(*ans[:2*n])</line-26>
<line-28></line-28>
<line-29>main()</line-29>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-27> return 0</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>from collections import defaultdict</line-1>
<line-3>from functools import reduce</line-3>
<line-4>n, x, y = [int(x) for x in input().split()]</line-4>
<line-5>E = defaultdict(set)</line-5>
<line-6>for i in range(n-1):</line-6>
<line-7> u, v = [int(x) for x in input().split()]</line-7>
<line-8> E[u].add(v)</line-8>
<line-9> E[v].add(u)</line-9>
<line-10></line-10>
<line-11>if x > y:</line-11>
<line-12> for v in E:</line-12>
<line-13> if len(E[v]) == n-1:</line-13>
<line-14> print((n-2)*y + x)</line-14>
<line-15> break</line-15>
<line-16> elif len(E[v]) > 1:</line-16>
<line-17> print((n-1)*y)</line-17>
<line-18> break</line-18>
<line-19>else:</line-19>
<line-20> visited = {v : False for v in E}</line-20>
<line-21> stack = [1]</line-21>
<line-22> topsorted = deque()</line-22>
<line-23> while stack:</line-23>
<line-24> v = stack.pop()</line-24>
<line-25> if visited[v]: continue</line-25>
<line-26> visited[v] = True</line-26>
<line-27> topsorted.appendleft(v)</line-27>
<line-28> stack.extend(E[v])</line-28>
<line-29> chopped = set()</line-29>
<line-30> ans = 0</line-30>
<line-31> for v in topsorted:</line-31>
<line-32> ans += max(0, len(E[v])-2)</line-32>
<line-33> if len(E[v]) > 2:</line-33>
<line-34> S = E[v].intersection(chopped)</line-34>
<line-35> S1 = {S.pop(), S.pop()}</line-35>
<line-36> for u in E[v]:</line-36>
<line-37> if not u in S1:</line-37>
<line-38> E[u].remove(v)</line-38>
<line-39> E[v].clear()</line-39>
<line-40> E[v].update(S1)</line-40>
<line-42> print(ans*y + (n-1-ans)*x)</line-42>
<line-43> </line-43>
|
{"code": "<line-2>from collections import deque</line-2>\n<line-41> chopped.add(v)</line-41>", "lines": [2, 41]}
#### 0
|
<line-1>def main():</line-1>
<line-3> input = sys.stdin.readline</line-3>
<line-4></line-4>
<line-5> N, M = list(map(int, input().split()))</line-5>
<line-6> L = list(map(int, input().split()))</line-6>
<line-7></line-7>
<line-8> if sum(L) < N:</line-8>
<line-9> print(-1)</line-9>
<line-10> return</line-10>
<line-11></line-11>
<line-12> ans = [0] * M</line-12>
<line-13> left = N</line-13>
<line-14> for i in range(M-1, -1, -1):</line-14>
<line-15> if left - L[i] >= i:</line-15>
<line-16> ans[i] = left - L[i] + 1</line-16>
<line-17> left -= L[i]</line-17>
<line-18> else:</line-18>
<line-19> if i+L[i]-1 >= N:</line-19>
<line-20> print(-1)</line-20>
<line-21> return</line-21>
<line-22> ans[i] = i+1</line-22>
<line-23> left = i</line-23>
<line-24> print(*ans)</line-24>
<line-25></line-25>
<line-26></line-26>
<line-27>def __starting_point():</line-27>
<line-29></line-29>
<line-30>__starting_point()</line-30>
|
{"code": "<line-2> import sys</line-2>\n<line-28> main()</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time</line-1>
<line-2></line-2>
<line-4>inf = 10**20</line-4>
<line-5>mod = 10**9 + 7</line-5>
<line-6></line-6>
<line-7>def LI(): return list(map(int, input().split()))</line-7>
<line-8>def II(): return int(input())</line-8>
<line-9>def LS(): return input().split()</line-9>
<line-10>def S(): return input()</line-10>
<line-11></line-11>
<line-12></line-12>
<line-13>def main():</line-13>
<line-14> n = II()</line-14>
<line-15> d = collections.defaultdict(set)</line-15>
<line-16> for _ in range(n-1):</line-16>
<line-17> a,b = LI()</line-17>
<line-18> d[a].add(b)</line-18>
<line-19> d[b].add(a)</line-19>
<line-20></line-20>
<line-21> memo = [-1] * (n+1)</line-21>
<line-22> def path(t,s):</line-22>
<line-23> ps = set()</line-23>
<line-24> dt = list(d[t])</line-24>
<line-25> for k in dt:</line-25>
<line-26> if memo[k] < 0:</line-26>
<line-27> continue</line-27>
<line-28> ps.add(memo[k])</line-28>
<line-29></line-29>
<line-30> if s == -1 and len(ps) == 2:</line-30>
<line-31> memo[t] = sum(ps) + 2</line-31>
<line-32> return memo[t]</line-32>
<line-33></line-33>
<line-34> if len(ps) > 1:</line-34>
<line-35> return -t</line-35>
<line-36></line-36>
<line-37> if len(ps) == 0:</line-37>
<line-38> memo[t] = 0</line-38>
<line-39> return 0</line-39>
<line-40></line-40>
<line-41> memo[t] = list(ps)[0] + 1</line-41>
<line-42> return memo[t]</line-42>
<line-43></line-43>
<line-44> def _path(tt,ss):</line-44>
<line-45> f = [False] * (n+1)</line-45>
<line-46> q = [(tt,ss)]</line-46>
<line-47> tq = []</line-47>
<line-48> qi = 0</line-48>
<line-49> while len(q) > qi:</line-49>
<line-50> t,s = q[qi]</line-50>
<line-51> for k in d[t]:</line-51>
<line-52> if k == s or memo[k] >= 0:</line-52>
<line-53> continue</line-53>
<line-54> q.append((k,t))</line-54>
<line-55> qi += 1</line-55>
<line-56> for t,s in q[::-1]:</line-56>
<line-57> r = path(t,s)</line-57>
<line-58> if r < 0:</line-58>
<line-59> return r</line-59>
<line-60> return memo[tt]</line-60>
<line-61></line-61>
<line-62> t = _path(1,-1)</line-62>
<line-63> if t < 0:</line-63>
<line-64> t = _path(-t,-1)</line-64>
<line-65></line-65>
<line-66> if t > 0:</line-66>
<line-67> while t%2 == 0:</line-67>
<line-68> t//=2</line-68>
<line-69> return t</line-69>
<line-70></line-70>
<line-72></line-72>
<line-73>print(main())</line-73>
|
{"code": "<line-3>sys.setrecursionlimit(10**7)</line-3>\n<line-71> return -1</line-71>", "lines": [3, 71]}
#### 0
|
<line-1>h = int(input())</line-1>
<line-3></line-3>
<line-4>w, q = [], []</line-4>
<line-5>p = r = 0</line-5>
<line-6></line-6>
<line-7>for i in a:</line-7>
<line-8> for j in range(i):</line-8>
<line-9> w.append(r)</line-9>
<line-10> q.append(r - (j and p > 1))</line-10>
<line-11></line-11>
<line-12> p = i</line-12>
<line-13> r += i</line-13>
<line-14></line-14>
<line-15>if w == q:</line-15>
<line-16> print('perfect')</line-16>
<line-17>else:</line-17>
<line-18> print('ambiguous')</line-18>
<line-20> print(*q)</line-20>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-19> print(*w)</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>n = int(input())</line-4>
<line-5>x = []</line-5>
<line-6>y = []</line-6>
<line-7>for i in range(n):</line-7>
<line-8> xi, yi = map(int, input().split())</line-8>
<line-9> x.append(xi)</line-9>
<line-10> y.append(yi)</line-10>
<line-11>min_x = min(x)</line-11>
<line-12>max_x = max(x)</line-12>
<line-13>min_y = min(y)</line-13>
<line-14>max_y = max(y)</line-14>
<line-15>answer = 0</line-15>
<line-16>for i in range(n):</line-16>
<line-17> dx = max(max_x - x[i], x[i] - min_x)</line-17>
<line-18> dy = max(max_y - y[i], y[i] - min_y)</line-18>
<line-19> answer = max(answer, dx + dy)</line-19>
<line-20>print(2*answer, end = ' ')</line-20>
<line-22> print(2*(max_x - min_x + max_y - min_y), end = ' ')</line-22>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-21>for i in range(4, n + 1):</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>MOD = 998244353</line-1>
<line-3> </line-3>
<line-4>n, m = list(map(int, input().split()))</line-4>
<line-5>l = list(map(int,input().split()))</line-5>
<line-6> </line-6>
<line-7>basis = []</line-7>
<line-8>for p in range(m-1,-1,-1):</line-8>
<line-9> p2 = pow(2,p)</line-9>
<line-10> nex = -1</line-10>
<line-11> for i in range(n):</line-11>
<line-12> if l[i] >= p2:</line-12>
<line-13> nex = l[i]</line-13>
<line-14> break</line-14>
<line-15> if nex != -1:</line-15>
<line-16> basis.append(nex)</line-16>
<line-17> for i in range(n):</line-17>
<line-18> if l[i] >= p2:</line-18>
<line-19> l[i] ^= nex</line-19>
<line-20> </line-20>
<line-21>extra = n - len(basis)</line-21>
<line-22></line-22>
<line-23>def add(a, b):</line-23>
<line-24> out = [0] * (max(len(a), len(b)))</line-24>
<line-25> for i in range(len(a)):</line-25>
<line-26> out[i] = a[i]</line-26>
<line-27> for i in range(len(b)):</line-27>
<line-28> out[i] += b[i]</line-28>
<line-29> out[i] %= MOD</line-29>
<line-30> return out</line-30>
<line-31> </line-31>
<line-32> </line-32>
<line-33>def addSh(a, b):</line-33>
<line-34> out = [0] * (max(len(a) + 1, len(b)))</line-34>
<line-35> for i in range(len(a)):</line-35>
<line-36> out[i + 1] = a[i]</line-36>
<line-37> for i in range(len(b)):</line-37>
<line-38> out[i] += b[i]</line-38>
<line-39> out[i] %= MOD</line-39>
<line-40> return out</line-40>
<line-41> </line-41>
<line-42>i = 0</line-42>
<line-43>curr = dict()</line-43>
<line-44>curr[0] = [1]</line-44>
<line-45>for p in range(m-1,-1,-1):</line-45>
<line-46> p2 = pow(2,p)</line-46>
<line-47> if i < len(basis) and basis[i] >= p2:</line-47>
<line-48> currN = dict(curr)</line-48>
<line-49> for v in curr:</line-49>
<line-50> if v ^ basis[i] not in currN:</line-50>
<line-51> currN[v ^ basis[i]] = [0]</line-51>
<line-52> currN[v ^ basis[i]] = add(curr[v], currN[v ^ basis[i]])</line-52>
<line-53> curr = currN</line-53>
<line-54> i += 1</line-54>
<line-55> </line-55>
<line-56> currN = dict(curr)</line-56>
<line-57> for v in curr:</line-57>
<line-58> if v >= p2:</line-58>
<line-59> if v ^ p2 not in currN:</line-59>
<line-60> currN[v ^ p2] = [0]</line-60>
<line-61> currN[v ^ p2] = addSh(curr[v], currN[v ^ p2])</line-61>
<line-62> del currN[v]</line-62>
<line-63> curr = currN </line-63>
<line-64> </line-64>
<line-65>out = curr[0]</line-65>
<line-66>while len(out) < m + 1:</line-66>
<line-67> out.append(0)</line-67>
<line-68>for i in range(m + 1):</line-68>
<line-69> out[i] *= pow(2, extra, MOD)</line-69>
<line-71>print(' '.join(map(str,out)))</line-71>
|
{"code": "<line-2>BOUND = 19</line-2>\n<line-70> out[i] %= MOD</line-70>", "lines": [2, 70]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>n,k=list(map(int,input().split()))</line-4>
<line-5>if k==0:</line-5>
<line-6> print(0)</line-6>
<line-7> return</line-7>
<line-8></line-8>
<line-9>A=sorted(map(int,input().split()))</line-9>
<line-10></line-10>
<line-11># DP[UL][n][left]</line-11>
<line-12># [left*pow(2,n),left*pow(2,n)+pow(2,n))の間のチームで,</line-12>
<line-13># ファンのチームが</line-13>
<line-14># UL=0: upperでもlowerでも勝ち残っている</line-14>
<line-15># UL=1: upperでのみ勝ち残っている</line-15>
<line-16># UL=2: lowerでのみ勝ち残っている</line-16>
<line-17># ときの、そこまでのファンのチームの試合数の最大値.</line-17>
<line-18></line-18>
<line-19>DP=[[[0]*((1<<n)+2) for i in range(n+1)] for UL in range(3)]</line-19>
<line-20></line-20>
<line-21>for i in range(k):</line-21>
<line-22> if A[i]%2==1:</line-22>
<line-23> DP[1][1][A[i]]=1</line-23>
<line-24> DP[2][1][A[i]]=1</line-24>
<line-25> else:</line-25>
<line-26> DP[1][1][A[i]-1]=1</line-26>
<line-27> DP[2][1][A[i]-1]=1</line-27>
<line-28></line-28>
<line-29> if i<k-1 and A[i]%2==1 and A[i+1]==A[i]+1:</line-29>
<line-30> DP[0][1][A[i]]=1</line-30>
<line-31> </line-31>
<line-32>for i in range(2,n+1):</line-32>
<line-33> for left in range(1,(1<<n)+1,1<<i):</line-33>
<line-34></line-34>
<line-35> if DP[0][i-1][left]:</line-35>
<line-36> DP[0][i][left]=max(DP[0][i-1][left] + DP[0][i-1][left+(1<<(i-1))] + 3,DP[0][i-1][left] + DP[1][i-1][left+(1<<(i-1))] + 3,\</line-36>
<line-37> DP[0][i-1][left] + DP[2][i-1][left+(1<<(i-1))] + 3)</line-37>
<line-38> </line-38>
<line-39> if DP[0][i-1][left+(1<<(i-1))]:</line-39>
<line-40> DP[0][i][left]=max(DP[0][i][left], DP[0][i-1][left] + DP[0][i-1][left+(1<<(i-1))] + 3,\</line-40>
<line-41> DP[1][i-1][left] + DP[0][i-1][left+(1<<(i-1))] + 3,DP[2][i-1][left] + DP[0][i-1][left+(1<<(i-1))] + 3)</line-41>
<line-42></line-42>
<line-43> if DP[1][i-1][left]:</line-43>
<line-44> DP[1][i][left]=max(DP[1][i][left], DP[1][i-1][left] + 1)</line-44>
<line-45> DP[2][i][left]=max(DP[2][i][left], DP[1][i-1][left] + 2)</line-45>
<line-46></line-46>
<line-47> if DP[2][i-1][left]:</line-47>
<line-48> DP[2][i][left]=max(DP[2][i][left], DP[2][i-1][left] + 2)</line-48>
<line-49></line-49>
<line-50> if DP[1][i-1][left+(1<<(i-1))]:</line-50>
<line-51> DP[1][i][left]=max(DP[1][i][left], DP[1][i-1][left+(1<<(i-1))] + 1)</line-51>
<line-52> DP[2][i][left]=max(DP[2][i][left], DP[1][i-1][left+(1<<(i-1))] + 2)</line-52>
<line-53></line-53>
<line-54> if DP[2][i-1][left+(1<<(i-1))]:</line-54>
<line-55> DP[2][i][left]=max(DP[2][i][left], DP[2][i-1][left+(1<<(i-1))] + 2)</line-55>
<line-56></line-56>
<line-57></line-57>
<line-58> if DP[1][i-1][left] and DP[1][i-1][left+(1<<(i-1))]:</line-58>
<line-59> DP[0][i][left]=max(DP[0][i][left], DP[1][i-1][left] + DP[1][i-1][left+(1<<(i-1))] + 2)</line-59>
<line-60></line-60>
<line-61> if DP[1][i-1][left] and DP[2][i-1][left+(1<<(i-1))]:</line-61>
<line-62> DP[0][i][left]=max(DP[0][i][left], DP[1][i-1][left] + DP[2][i-1][left+(1<<(i-1))] + 3)</line-62>
<line-63></line-63>
<line-64> if DP[2][i-1][left] and DP[1][i-1][left+(1<<(i-1))]:</line-64>
<line-65> DP[0][i][left]=max(DP[0][i][left], DP[2][i-1][left] + DP[1][i-1][left+(1<<(i-1))] + 3)</line-65>
<line-66></line-66>
<line-67> if DP[2][i-1][left] and DP[2][i-1][left+(1<<(i-1))]:</line-67>
<line-68> DP[2][i][left]=max(DP[2][i][left], DP[2][i-1][left] + DP[2][i-1][left+(1<<(i-1))] + 2)</line-68>
<line-69></line-69>
<line-70></line-70>
<line-71>""" </line-71>
<line-72>for i in range(n+1):</line-72>
<line-73> print(DP[0][i])</line-73>
<line-74>print()</line-74>
<line-75>for i in range(n+1):</line-75>
<line-76> print(DP[1][i])</line-76>
<line-77>print()</line-77>
<line-78>for i in range(n+1):</line-78>
<line-79> print(DP[2][i])</line-79>
<line-80>print()</line-80>
<line-81>for i in range(n+1):</line-81>
<line-82> print(DP[0][0][i])</line-82>
<line-84>print(max(DP[0][n][1],DP[1][n][1],DP[2][n][1])+1)</line-84>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-83>\"\"\"</line-83>", "lines": [2, 83]}
#### 0
|
<line-1># python3</line-1>
<line-3>from collections import namedtuple</line-3>
<line-4></line-4>
<line-5></line-5>
<line-6>def readline(): return list(map(int, input().split()))</line-6>
<line-7></line-7>
<line-8></line-8>
<line-9>def readlines():</line-9>
<line-10> for line in sys.stdin.readlines():</line-10>
<line-11> yield list(map(int, line.split()))</line-11>
<line-12></line-12>
<line-13></line-13>
<line-14>class State(namedtuple('State', 'payload time floor')):</line-14>
<line-15> def hook(self, pivot, a, b):</line-15>
<line-16> lo, up = min(pivot, a, self.floor), max(pivot, a, self.floor)</line-16>
<line-17> return tuple(x for x in self.payload if x < lo or up < x) + (b,), \</line-17>
<line-18> self.time + abs(self.floor - pivot) + abs(pivot - a)</line-18>
<line-19></line-19>
<line-20> def choices_to_take_next(self, a, b):</line-20>
<line-21> floor = self.floor</line-21>
<line-22></line-22>
<line-23> payload, time = self.hook(floor, a, b)</line-23>
<line-24> if len(payload) < 5:</line-24>
<line-25> yield payload, time</line-25>
<line-26> if floor > a:</line-26>
<line-27> pivots = (x for x in self.payload if x > floor)</line-27>
<line-28> elif floor == a:</line-28>
<line-29> pivots = ()</line-29>
<line-30> else:</line-30>
<line-31> pivots = (x for x in self.payload if x < floor)</line-31>
<line-32> else:</line-32>
<line-33> pivots = self.payload</line-33>
<line-34></line-34>
<line-35> for pivot in pivots:</line-35>
<line-36> yield self.hook(pivot, a, b)</line-36>
<line-37></line-37>
<line-38></line-38>
<line-39>def time_to_get_free(payload, floor):</line-39>
<line-40> if payload:</line-40>
<line-41> lo, up = min(payload), max(payload)</line-41>
<line-42> return abs(lo-up) + min(abs(floor-lo), abs(floor-up))</line-42>
<line-43> else:</line-43>
<line-44> return 0</line-44>
<line-45></line-45>
<line-46></line-46>
<line-47>def main():</line-47>
<line-48> n, = readline()</line-48>
<line-49></line-49>
<line-50> floor = 1</line-50>
<line-51> positions = {(): 0} # empty elevator, time = 0</line-51>
<line-52> for (a, b) in readlines():</line-52>
<line-53> max_acceptable_time = min(positions.values()) + 16 - abs(floor - a)</line-53>
<line-54></line-54>
<line-55> new_positions = dict()</line-55>
<line-56> for payload, time in list(positions.items()):</line-56>
<line-57> state = State(payload, time, floor)</line-57>
<line-58> for npayload, ntime in state.choices_to_take_next(a, b):</line-58>
<line-59> if ntime <= max_acceptable_time:</line-59>
<line-60> npayload = tuple(sorted(npayload))</line-60>
<line-61> if new_positions.setdefault(npayload, ntime) > ntime:</line-61>
<line-62> new_positions[npayload] = ntime</line-62>
<line-63></line-63>
<line-64> positions = new_positions</line-64>
<line-65> floor = a</line-65>
<line-66></line-66>
<line-67> return min(t + time_to_get_free(p, floor) for p, t in list(positions.items())) \</line-67>
<line-69></line-69>
<line-70></line-70>
<line-71>print(main())</line-71>
|
{"code": "<line-2>import sys</line-2>\n<line-68> + 2 * n</line-68>", "lines": [2, 68]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>adj_for = [[] for _ in range(n)]</line-5>
<line-6>adj_back = [[] for _ in range(n)]</line-6>
<line-7></line-7>
<line-8>for _ in range(m):</line-8>
<line-9> a, b = [int(x) for x in sys.stdin.readline().split()]</line-9>
<line-10> a -= 1</line-10>
<line-11> b -= 1</line-11>
<line-12> adj_for[a].append(b)</line-12>
<line-13> adj_back[b].append(a)</line-13>
<line-14></line-14>
<line-15></line-15>
<line-16>lens = [len(adj_back[i]) for i in range(n)]</line-16>
<line-17>stack = [x for x in range(n) if lens[x] == 0]</line-17>
<line-18>toposort = [x for x in range(n) if lens[x] == 0]</line-18>
<line-19></line-19>
<line-20>while len(stack):</line-20>
<line-21> cur = stack.pop()</line-21>
<line-22> for nb in adj_for[cur]:</line-22>
<line-23> lens[nb] -= 1</line-23>
<line-24> if lens[nb] == 0:</line-24>
<line-25> toposort.append(nb)</line-25>
<line-26> stack.append(nb)</line-26>
<line-27></line-27>
<line-28>if len(toposort) != n:</line-28>
<line-29> print(-1)</line-29>
<line-30> return</line-30>
<line-31></line-31>
<line-32>min_above = list(range(n))</line-32>
<line-33>min_below = list(range(n))</line-33>
<line-34></line-34>
<line-35>for i in toposort:</line-35>
<line-36> for j in adj_back[i]:</line-36>
<line-37> if min_above[j] < min_above[i]:</line-37>
<line-38> min_above[i] = min_above[j]</line-38>
<line-39></line-39>
<line-40>for i in reversed(toposort):</line-40>
<line-41> for j in adj_for[i]:</line-41>
<line-42> if min_below[j] < min_below[i]:</line-42>
<line-43> min_below[i] = min_below[j]</line-43>
<line-44></line-44>
<line-45>qt = ["A" if min_below[i] == min_above[i] == i else "E" for i in range(n)]</line-45>
<line-46></line-46>
<line-47># qt = [None for x in range(n)]</line-47>
<line-48># </line-48>
<line-49># for i in range(n):</line-49>
<line-50># if qt[i] is not None:</line-50>
<line-51># continue</line-51>
<line-52># qt[i] = 'A'</line-52>
<line-53># stack_for = [i]</line-53>
<line-54># while len(stack_for):</line-54>
<line-55># cur = stack_for.pop()</line-55>
<line-56># for nb in adj_for[cur]:</line-56>
<line-57># if qt[nb] is None:</line-57>
<line-58># qt[nb] = 'E'</line-58>
<line-59># stack_for.append(nb)</line-59>
<line-60># </line-60>
<line-61># </line-61>
<line-62># stack_back = [i]</line-62>
<line-63># while len(stack_back):</line-63>
<line-64># cur = stack_back.pop()</line-64>
<line-65># for nb in adj_back[cur]:</line-65>
<line-66># if qt[nb] is None:</line-66>
<line-67># qt[nb] = 'E'</line-67>
<line-68># stack_back.append(nb)</line-68>
<line-69># </line-69>
<line-71>print("".join(qt))</line-71>
|
{"code": "<line-3>n, m = [int(x) for x in input().split()]</line-3>\n<line-70>print(len([x for x in qt if x == 'A']))</line-70>", "lines": [3, 70]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>n,m=list(map(int,input().split()))</line-4>
<line-5>A=list(map(int,input().split()))</line-5>
<line-6></line-6>
<line-7></line-7>
<line-8>MIN=0</line-8>
<line-9>MAX=m</line-9>
<line-10></line-10>
<line-11>while MIN!=MAX:</line-11>
<line-12> x=(MIN+MAX)//2</line-12>
<line-13> #print(x,MIN,MAX)</line-13>
<line-14> #print()</line-14>
<line-15></line-15>
<line-16> M=0</line-16>
<line-17> for a in A:</line-17>
<line-18> #print(a,M)</line-18>
<line-19> if a<=M and a+x>=M:</line-19>
<line-20> continue</line-20>
<line-21> elif a>M and a+x>=m and (a+x)%m>=M:</line-21>
<line-22> continue</line-22>
<line-23> elif a>M:</line-23>
<line-24> M=a</line-24>
<line-25> else:</line-25>
<line-26> MIN=x+1</line-26>
<line-27> break</line-27>
<line-28> else:</line-28>
<line-30></line-30>
<line-31>print(MIN)</line-31>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-29> MAX=x</line-29>", "lines": [2, 29]}
#### 0
|
<line-2>unit = h*h/n</line-2>
<line-3>for i in range(1,n):</line-3>
<line-4> print((unit*i)**0.5, end=' ')</line-4>
|
{"code": "<line-1>n, h = map(int,input().split())</line-1>", "lines": [1]}
#### 0
|
<line-1>def main():</line-1>
<line-3> if not (n & 1):</line-3>
<line-4> l.append(0)</line-4>
<line-5> l.append(150001)</line-5>
<line-6> i, b, c, fails0, fails1 = 0, 0, 150001, [], []</line-6>
<line-7> try:</line-7>
<line-8> while True:</line-8>
<line-9> a, b, c = b, c, l[i]</line-9>
<line-10> if a >= b or b <= c:</line-10>
<line-11> if len(fails0) + len(fails1) > 5:</line-11>
<line-12> print(0)</line-12>
<line-13> return</line-13>
<line-14> fails1.append(i - 1)</line-14>
<line-15> i += 1</line-15>
<line-16> a, b, c = b, c, l[i]</line-16>
<line-17> if a <= b or b >= c:</line-17>
<line-18> if len(fails0) + len(fails1) > 5:</line-18>
<line-19> print(0)</line-19>
<line-20> return</line-20>
<line-21> fails0.append(i - 1)</line-21>
<line-22> i += 1</line-22>
<line-23> except IndexError:</line-23>
<line-24> fails, res = fails0 + fails1, 0</line-24>
<line-25> for i in fails:</line-25>
<line-26> a = l[i]</line-26>
<line-27> for j in range(n):</line-27>
<line-28> f = fails1 if j & 1 else fails0</line-28>
<line-29> f.append(j)</line-29>
<line-30> l[i], l[j] = l[j], a</line-30>
<line-31> if (all(l[b - 1] > l[b] < l[b + 1] for b in fails0) and</line-31>
<line-32> all(l[b - 1] < l[b] > l[b + 1] for b in fails1)):</line-32>
<line-33> res += 1 if j in fails else 2</line-33>
<line-34> l[j] = l[i]</line-34>
<line-35> del f[-1]</line-35>
<line-36> l[i] = a</line-36>
<line-37> print(res // 2)</line-37>
<line-38></line-38>
<line-39></line-39>
<line-40>def __starting_point():</line-40>
<line-42></line-42>
<line-43>__starting_point()</line-43>
|
{"code": "<line-2> n, l = int(input()), list(map(int, input().split()))</line-2>\n<line-41> main()</line-41>", "lines": [2, 41]}
#### 0
|
<line-1>def main():</line-1>
<line-3> a1 = a + 1</line-3>
<line-4> b += a1</line-4>
<line-5> l, res = [b if c == "w" else a1 for c in input()], []</line-5>
<line-6> l[0] = x = l[0] - a</line-6>
<line-7> if t <= x:</line-7>
<line-8> print(int(t == x))</line-8>
<line-9> return</line-9>
<line-10> f = res.append</line-10>
<line-11> for dr in 0, 1:</line-11>
<line-12> if dr:</line-12>
<line-13> l[1:] = l[-1:-n:-1]</line-13>
<line-14> tot = t</line-14>
<line-15> for hi, x in enumerate(l):</line-15>
<line-16> tot -= x</line-16>
<line-17> if tot < 0:</line-17>
<line-18> break</line-18>
<line-19> else:</line-19>
<line-20> print(n)</line-20>
<line-21> return</line-21>
<line-22> f(hi)</line-22>
<line-23> tot += x</line-23>
<line-24> hi -= 1</line-24>
<line-25> tot -= hi * a</line-25>
<line-26> lo = n</line-26>
<line-27> while True:</line-27>
<line-28> while lo > 0 <= tot:</line-28>
<line-29> lo -= 1</line-29>
<line-30> tot -= l[lo]</line-30>
<line-31> f(n + hi - lo)</line-31>
<line-32> if not (lo and hi):</line-32>
<line-33> break</line-33>
<line-34> while tot <= 0 < hi:</line-34>
<line-35> tot += l[hi] + a</line-35>
<line-36> hi -= 1</line-36>
<line-37> print(max(res))</line-37>
<line-38></line-38>
<line-39></line-39>
<line-40>def __starting_point():</line-40>
<line-42></line-42>
<line-43>__starting_point()</line-43>
|
{"code": "<line-2> n, a, b, t = list(map(int, input().split()))</line-2>\n<line-41> main()</line-41>", "lines": [2, 41]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>for i in range(n):</line-3>
<line-4> l,r = map(int, input().split())</line-4>
<line-5> arr.append([l,r])</line-5>
<line-6> </line-6>
<line-7>lts = []</line-7>
<line-8>for i in range(n):</line-8>
<line-9> if arr[i][0] == 0:</line-9>
<line-10> l = i</line-10>
<line-11> j = i</line-11>
<line-12> while arr[j][1] != 0:</line-12>
<line-13> j = arr[j][1] - 1</line-13>
<line-14> r = j</line-14>
<line-15> lts.append([l,r])</line-15>
<line-16></line-16>
<line-17>for i in range(1, len(lts)):</line-17>
<line-18> arr[lts[i-1][1]][1] = lts[i][0] + 1</line-18>
<line-19> arr[lts[i][0]][0] = lts[i-1][1] + 1</line-19>
<line-20> </line-20>
<line-22> print(arr[i][0], arr[i][1])</line-22>
|
{"code": "<line-2>arr = []</line-2>\n<line-21>for i in range(n):</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>from sys import stdin, stdout</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>print(2+(n-2)//k+(n-3)//k)</line-5>
<line-6></line-6>
<line-7>connectionsList = []</line-7>
<line-8># Leaf node is 1. Make this node have connections to k children</line-8>
<line-9>for i in range(k):</line-9>
<line-10> connectionsList.append((str(1),str(i+2)))</line-10>
<line-11></line-11>
<line-12></line-12>
<line-13>for i in range(k+2,n+1):</line-13>
<line-14> connectionsList.append((str(i-k),str(i)))</line-14>
<line-15></line-15>
<line-17> print(' '.join(conn))</line-17>
|
{"code": "<line-3>n,k = list(map(int,stdin.readline().rstrip().split()))</line-3>\n<line-16>for conn in connectionsList:</line-16>", "lines": [3, 16]}
#### 0
|
<line-1>n, m = map(int, input().split())</line-1>
<line-3>for i in range(m):</line-3>
<line-4> l, r, x = map(int, input().split())</line-4>
<line-5> while l < x:</line-5>
<line-6> if d[l]:</line-6>
<line-7> k = d[l]</line-7>
<line-8> d[l] = x - l</line-8>
<line-9> l += k</line-9>
<line-10> else:</line-10>
<line-11> d[l], p[l] = x - l, x</line-11>
<line-12> l += 1</line-12>
<line-13> l += 1</line-13>
<line-14> r += 1</line-14>
<line-15> while d[r]: r += d[r]</line-15>
<line-16> while l < r:</line-16>
<line-17> if d[l]:</line-17>
<line-18> k = d[l]</line-18>
<line-19> d[l] = r - l</line-19>
<line-20> l += k</line-20>
<line-21> else:</line-21>
<line-22> d[l], p[l] = r - l, x</line-22>
<line-24>print(' '.join(map(str, p[1: -1])))</line-24>
|
{"code": "<line-2>p, d = [0] * (n + 2), [0] * (n + 2)</line-2>\n<line-23> l += 1</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>a, b = [0] * (n + 1), [0] * (n + 1)</line-3>
<line-4>a[1] = b[1] = -1</line-4>
<line-5> </line-5>
<line-6>def f(s, a, b, l):</line-6>
<line-7> nonlocal t</line-7>
<line-8> l.reverse()</line-8>
<line-9> j, n = 0, len(l)</line-9>
<line-10> while True:</line-10>
<line-11> s += t[l[j]]</line-11>
<line-12> a[l[j]] = s</line-12>
<line-13> j += 1</line-13>
<line-14> if j == n: return</line-14>
<line-15> s += t[l[j]]</line-15>
<line-16> b[l[j]] = s</line-16>
<line-17> j += 1</line-17>
<line-18> if j == n: return</line-18>
<line-19></line-19>
<line-20>def g(i, k):</line-20>
<line-21> nonlocal a, b</line-21>
<line-22> l = []</line-22>
<line-23> if k:</line-23>
<line-24> a[i] = -1</line-24>
<line-25> l.append(i)</line-25>
<line-26> i += t[i]</line-26>
<line-27> while True:</line-27>
<line-28> if i > n: return f(0, a, b, l) </line-28>
<line-29> if b[i] > 0: return f(b[i], a, b, l) </line-29>
<line-30> if b[i] == -1: return</line-30>
<line-31> b[i] = -1</line-31>
<line-32> l.append(i)</line-32>
<line-33> i -= t[i]</line-33>
<line-34> if i < 1: return f(0, b, a, l)</line-34>
<line-35> if a[i] > 0: return f(a[i], b, a, l)</line-35>
<line-36> if a[i] == -1: return</line-36>
<line-37> a[i] = -1</line-37>
<line-38> l.append(i)</line-38>
<line-39> i += t[i]</line-39>
<line-40> </line-40>
<line-41>for i in range(2, n + 1):</line-41>
<line-42> if a[i] == 0: g(i, True) </line-42>
<line-43> if b[i] == 0: g(i, False)</line-43>
<line-44></line-44>
<line-45>for i in range(1, n):</line-45>
<line-46> if b[i + 1] > 0: t[i] = i + b[i + 1]</line-46>
<line-48></line-48>
<line-49>print('\n'.join(map(str, t[1: n])))</line-49>
|
{"code": "<line-2>t = [0, 0] + list(map(int, input().split()))</line-2>\n<line-47> else: t[i] = -1</line-47>", "lines": [2, 47]}
#### 0
|
<line-1>def main():</line-1>
<line-3> a, b, c, d = (list(map(int, input().split())) for _ in 'abcd')</line-3>
<line-4> ss, tt, n2, res = [*b, *c[::-1]], [*a, *d[::-1]], n * 2, []</line-4>
<line-5> yx = [*[(2, i + 1) for i in range(n)], *[(3, i) for i in range(n, 0, -1)]]</line-5>
<line-6></line-6>
<line-7> def park():</line-7>
<line-8> for i, s, t, (y, x) in zip(range(n2), ss, tt, yx):</line-8>
<line-9> if s == t != 0:</line-9>
<line-10> ss[i] = 0</line-10>
<line-11> res.append(f'{s} {(1, 4)[y == 3]} {x}')</line-11>
<line-12></line-12>
<line-13> def rotate():</line-13>
<line-14> start = ss.index(0)</line-14>
<line-15> for i in range(start - n2, start - 1):</line-15>
<line-16> s = ss[i] = ss[i + 1]</line-16>
<line-17> if s:</line-17>
<line-18> y, x = yx[i]</line-18>
<line-19> res.append(f'{s} {y} {x}')</line-19>
<line-20> ss[start - 1] = 0</line-20>
<line-21></line-21>
<line-22> park()</line-22>
<line-23> if all(ss):</line-23>
<line-24> print(-1)</line-24>
<line-25> return</line-25>
<line-26> while any(ss):</line-26>
<line-27> rotate()</line-27>
<line-28> park()</line-28>
<line-29> print(len(res), '\n'.join(res), sep='\n')</line-29>
<line-30></line-30>
<line-31></line-31>
<line-32>def __starting_point():</line-32>
<line-34></line-34>
<line-35>__starting_point()</line-35>
|
{"code": "<line-2> n, k = map(int, input().split())</line-2>\n<line-33> main()</line-33>", "lines": [2, 33]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>nums = list(map(int, sys.stdin.readline().split()))</line-4>
<line-5>total = sum(nums)</line-5>
<line-6>avg = int(total / n)</line-6>
<line-7></line-7>
<line-8>def check1(nums, target, K):</line-8>
<line-9> for x in nums:</line-9>
<line-10> if K < 0:</line-10>
<line-11> return False</line-11>
<line-12> if x < target:</line-12>
<line-13> K -= target - x</line-13>
<line-14> return K >= 0</line-14>
<line-15></line-15>
<line-16>def check2(nums, target, K):</line-16>
<line-17> for x in nums:</line-17>
<line-18> if K < 0:</line-18>
<line-19> return False</line-19>
<line-20> if x > target:</line-20>
<line-21> K -= x - target</line-21>
<line-22> return K >= 0</line-22>
<line-23></line-23>
<line-24>l1, r1 = min(nums), avg + 1</line-24>
<line-25>while l1 + 1 < r1:</line-25>
<line-26> mid = (l1 + r1) >> 1</line-26>
<line-27> if check1(nums, mid, k):</line-27>
<line-28> l1 = mid</line-28>
<line-29> else:</line-29>
<line-30> r1 = mid</line-30>
<line-31></line-31>
<line-32>if check2(nums, avg + (0 if total % n == 0 else 1), k):</line-32>
<line-33> r2 = avg + (0 if total % n == 0 else 1)</line-33>
<line-34>else:</line-34>
<line-35> l2, r2 = avg + (0 if total % n == 0 else 1), max(nums)</line-35>
<line-36> while l2 + 1 < r2:</line-36>
<line-37> mid = (l2 + r2) >> 1</line-37>
<line-38> if check2(nums, mid, k):</line-38>
<line-39> r2 = mid</line-39>
<line-40> else:</line-40>
<line-42></line-42>
<line-43>print(r2 - l1)</line-43>
|
{"code": "<line-3>n, k = map(int, sys.stdin.readline().split())</line-3>\n<line-41> l2 = mid</line-41>", "lines": [3, 41]}
#### 0
|
<line-1>import sys</line-1>
<line-3> if q == 0:</line-3>
<line-4> return b0 ^ b1</line-4>
<line-5> if q == 1:</line-5>
<line-6> return b0 | b1</line-6>
<line-7> if q == 2:</line-7>
<line-8> return b0 & b1</line-8>
<line-9>n, m = list(map(int,sys.stdin.readline().split()))</line-9>
<line-10>arr1 = {}</line-10>
<line-11>opt = ['XOR', 'OR', 'AND']</line-11>
<line-12>arr2 = []</line-12>
<line-13>for j in range(n):</line-13>
<line-14> a, b = list(map(str,sys.stdin.readline().split(" := ")))</line-14>
<line-15> b = b.split()</line-15>
<line-16> if len(b) == 1:</line-16>
<line-17> s = b[0]</line-17>
<line-18> arr1[a] = s</line-18>
<line-19> else:</line-19>
<line-20> c = b[0]</line-20>
<line-21> d = b[2]</line-21>
<line-22> q = opt.index(b[1])</line-22>
<line-23> arr2.append((a, c, d, q))</line-23>
<line-24> </line-24>
<line-25>mins = ''</line-25>
<line-26>maxs = ''</line-26>
<line-27>d0 = {'?':0}</line-27>
<line-28>d1 = {'?':1}</line-28>
<line-29>for i in range(m):</line-29>
<line-30> for a, b in list(arr1.items()):</line-30>
<line-31> d0[a] = int(b[i])</line-31>
<line-32> d1[a] = int(b[i])</line-32>
<line-33> s0 = 0</line-33>
<line-34> s1 = 0</line-34>
<line-35> for a, c, d, q in arr2:</line-35>
<line-36> b00 = d0[c]</line-36>
<line-37> b01 = d0[d]</line-37>
<line-38> b10 = d1[c]</line-38>
<line-39> b11 = d1[d]</line-39>
<line-40> c0 = calc(b00, b01, q)</line-40>
<line-41> c1 = calc(b10, b11, q)</line-41>
<line-42> s0 += (1 if c0 else 0)</line-42>
<line-43> s1 += (1 if c1 else 0)</line-43>
<line-44> d0[a] = c0</line-44>
<line-45> d1[a] = c1</line-45>
<line-46> if s1 < s0:</line-46>
<line-47> mins += "1"</line-47>
<line-48> else:</line-48>
<line-49> mins += "0"</line-49>
<line-50> if s1 > s0:</line-50>
<line-51> maxs += "1"</line-51>
<line-52> else:</line-52>
<line-54>sys.stdout.write("{0}\n{1}".format(mins,maxs))</line-54>
<line-55></line-55>
<line-56></line-56>
<line-57></line-57>
<line-58> </line-58>
<line-59></line-59>
|
{"code": "<line-2>def calc(b0, b1, q):</line-2>\n<line-53> maxs += \"0\"</line-53>", "lines": [2, 53]}
#### 0
|
<line-1>"""</line-1>
<line-3></line-3>
<line-4>Author : chaotic_iak</line-4>
<line-5>Language: Python 3.3.4</line-5>
<line-6>"""</line-6>
<line-7></line-7>
<line-8>def main():</line-8>
<line-9> n,k = read()</line-9>
<line-10> s = set()</line-10>
<line-11> for i in range(n): s.add(read(0))</line-11>
<line-12> s = list(s)</line-12>
<line-13> s.sort()</line-13>
<line-14> s = treeify(s)</line-14>
<line-15> res = solve(s)</line-15>
<line-16> if res == 0: # neither: second player win</line-16>
<line-17> print("Second")</line-17>
<line-18> if res == 1: # odd: first player win if k is odd</line-18>
<line-19> print("First" if k % 2 else "Second")</line-19>
<line-20> if res == 2: # even: second player win</line-20>
<line-21> print("Second")</line-21>
<line-22> if res == 3: # both: first player win</line-22>
<line-23> print("First")</line-23>
<line-24></line-24>
<line-25>def treeify(s):</line-25>
<line-26> res = [[] for _ in range(26)]</line-26>
<line-27> for i in s:</line-27>
<line-28> if i: res[ord(i[0]) - 97].append(i[1:])</line-28>
<line-29> fin = []</line-29>
<line-30> for i in range(26):</line-30>
<line-31> if res[i]: fin.append(treeify(res[i]))</line-31>
<line-32> return fin</line-32>
<line-33></line-33>
<line-34>def solve(s, parity=2):</line-34>
<line-35> for i in range(len(s)):</line-35>
<line-36> if isinstance(s[i], list): s[i] = solve(s[i], 3-parity)</line-36>
<line-37> if not s: return parity # no possible move: current parity</line-37>
<line-38> if 0 in s: return 3 # any neither: both</line-38>
<line-39> if 1 in s and 2 in s: return 3 # any odd and any even: both</line-39>
<line-40> if 1 in s: return 1 # any odd: odd</line-40>
<line-41> if 2 in s: return 2 # any even: even</line-41>
<line-42> return 0 # all both: neither</line-42>
<line-43></line-43>
<line-44>################################### NON-SOLUTION STUFF BELOW</line-44>
<line-45></line-45>
<line-46>def read(mode=2):</line-46>
<line-47> # 0: String</line-47>
<line-48> # 1: List of strings</line-48>
<line-49> # 2: List of integers</line-49>
<line-50> inputs = input().strip()</line-50>
<line-51> if mode == 0: return inputs</line-51>
<line-52> if mode == 1: return inputs.split()</line-52>
<line-53> if mode == 2: return map(int, inputs.split())</line-53>
<line-54></line-54>
<line-55>def write(s="\n"):</line-55>
<line-56> if isinstance(s, list): s = " ".join(map(str, s))</line-56>
<line-57> s = str(s)</line-57>
<line-59></line-59>
<line-60>main()</line-60>
|
{"code": "<line-2>Codeforces Contest 260 Div 1 Problem B</line-2>\n<line-58> print(s, end=\"\")</line-58>", "lines": [2, 58]}
#### 0
|
<line-1>from heapq import heappush,heappop,heapify</line-1>
<line-3>*l,=map(int,input().split())</line-3>
<line-4>q=[(-l[i],i)for i in range(k)];heapify(q)</line-4>
<line-5>a=[0]*n</line-5>
<line-6>s=0</line-6>
<line-7>for i in range(k,n):</line-7>
<line-8> heappush(q,(-l[i],i))</line-8>
<line-9> x,j=heappop(q)</line-9>
<line-10> s-=x*(i-j)</line-10>
<line-11> a[j]=i+1</line-11>
<line-12>for i in range(n,n+k):</line-12>
<line-13> x,j=heappop(q)</line-13>
<line-14> s-=x*(i-j)</line-14>
<line-15> a[j]=i+1</line-15>
<line-17>print(' '.join(map(str,a)))</line-17>
|
{"code": "<line-2>n,k=map(int,input().split())</line-2>\n<line-16>print(s)</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>n, m = list(map(int, input().split()))</line-1>
<line-3>for i in range(m):</line-3>
<line-4> x, y = list(map(int, input().split()))</line-4>
<line-5> used[x - 1] = used[n + y - 1] = 0</line-5>
<line-6> </line-6>
<line-7>if n % 2 and used[n // 2]:</line-7>
<line-8> used[n // 2 + n] = 0</line-8>
<line-9>res = sum(used)</line-9>
<line-10>for i in [0, n - 1, n, 2 * n - 1]:</line-10>
<line-12>print(res)</line-12>
<line-13></line-13>
|
{"code": "<line-2>used = [1] * 2 * n</line-2>\n<line-11>\tres -= used[i]</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>n,m=map(int,input().split())</line-1>
<line-3>g=list(map(int,input().split()))</line-3>
<line-4>if max(b)>min(g):</line-4>
<line-5> print(-1)</line-5>
<line-6>else:</line-6>
<line-7> maxi=0</line-7>
<line-8> maxi2=0</line-8>
<line-9> for guy in b:</line-9>
<line-10> if guy>maxi:</line-10>
<line-11> maxi2,maxi=maxi,guy</line-11>
<line-12> elif guy>maxi2:</line-12>
<line-13> maxi2=guy</line-13>
<line-14> sumi=m*sum(b)+sum(g)-m*maxi+maxi-maxi2</line-14>
<line-15> if maxi in g:</line-15>
<line-17> print(sumi)</line-17>
|
{"code": "<line-2>b=list(map(int,input().split()))</line-2>\n<line-16> sumi-=(maxi-maxi2)</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>def main():</line-1>
<line-3> edges = []</line-3>
<line-4> for _ in range(n - 1):</line-4>
<line-5> u, v = list(map(int, input().split()))</line-5>
<line-6> u -= 1</line-6>
<line-7> v -= 1</line-7>
<line-8> edges.append((u, v))</line-8>
<line-9></line-9>
<line-10> colors = list(map(int, input().split()))</line-10>
<line-11> suspect = [(u, v) for (u, v) in edges if colors[u] != colors[v]]</line-11>
<line-12></line-12>
<line-13> if len(suspect) == 0:</line-13>
<line-14> print("YES")</line-14>
<line-15> print(1)</line-15>
<line-16> else:</line-16>
<line-17> cands = set(suspect[0])</line-17>
<line-18> for u, v in suspect:</line-18>
<line-19> cands &= set([u, v])</line-19>
<line-20></line-20>
<line-21> if len(cands) == 0:</line-21>
<line-22> print("NO")</line-22>
<line-23> else:</line-23>
<line-24> print("YES")</line-24>
<line-25> e = list(cands)[0]</line-25>
<line-27></line-27>
<line-28>main()</line-28>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-26> print(e + 1)</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>MOD = 10**9+7</line-1>
<line-2></line-2>
<line-4>n = int(input())</line-4>
<line-5>qs = [['',s]]+[input().split('->') for i in range(n)]</line-5>
<line-6></line-6>
<line-7>ds = {}</line-7>
<line-8>for i in range(10):</line-8>
<line-9> ds[str(i)] = (10,i)</line-9>
<line-10></line-10>
<line-11>for i in range(n,-1,-1):</line-11>
<line-12> out = 0</line-12>
<line-13> mul = 1</line-13>
<line-14> for d in qs[i][1]:</line-14>
<line-15> out = (out * ds[d][0] + ds[d][1]) % MOD</line-15>
<line-16> mul = (mul * ds[d][0]) % MOD</line-16>
<line-18></line-18>
<line-19>print(ds[''][1])</line-19>
|
{"code": "<line-3>s = input()</line-3>\n<line-17> ds[qs[i][0]] = (mul,out)</line-17>", "lines": [3, 17]}
#### 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 ModuleNotFoundError:</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></line-31>
<line-32>s1 = input() +'0'</line-32>
<line-33>s2 = input() +'0'</line-33>
<line-34></line-34>
<line-35>res = 0</line-35>
<line-36></line-36>
<line-37>i = 0</line-37>
<line-38>while i<N:</line-38>
<line-39> if s1[i] != s2[i]:</line-39>
<line-40> if s1[i+1] == s2[i] and s2[i+1] == s1[i]:</line-40>
<line-41> res+=1</line-41>
<line-42> i+=2</line-42>
<line-43> continue</line-43>
<line-44> res+=1</line-44>
<line-46>print(res)</line-46>
<line-47></line-47>
<line-48> </line-48>
<line-49></line-49>
<line-50></line-50>
<line-51></line-51>
<line-52></line-52>
<line-53></line-53>
<line-54></line-54>
|
{"code": "<line-2>import collections, atexit, math, sys, bisect </line-2>\n<line-45> i+=1</line-45>", "lines": [2, 45]}
#### 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># so the ending sequence is b...ba...a</line-6>
<line-7></line-7>
<line-8># find length of ending sequence</line-8>
<line-9></line-9>
<line-10>extra=0</line-10>
<line-11>need=0</line-11>
<line-12>for ch in input().strip():</line-12>
<line-13> if ch=='a':</line-13>
<line-14> need=(need*2+1)%1000000007</line-14>
<line-15> else:</line-15>
<line-17></line-17>
<line-18>print(extra)</line-18>
|
{"code": "<line-3>#sys.stdin=open(\"data.txt\")</line-3>\n<line-16> extra=(extra+need)%1000000007</line-16>", "lines": [3, 16]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.