question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1>t = int(input())</line-1>
<line-3> t =t -1</line-3>
<line-4> n,k = list(map(int,input().split()))</line-4>
<line-5> a = [0]*n</line-5>
<line-6> done = True</line-6>
<line-7></line-7>
<line-8> def swap(z):</line-8>
<line-9> for j in range(0,n):</line-9>
<line-10> if a[j] == 0:</line-10>
<line-11> a[j] = z</line-11>
<line-12> done = True</line-12>
<line-13> break</line-13>
<line-14> else:</line-14>
<line-15> if a[j] > z:</line-15>
<line-16> swap(j)</line-16>
<line-17> a[j] = z</line-17>
<line-18> else:</line-18>
<line-19> done = False</line-19>
<line-20> break</line-20>
<line-21></line-21>
<line-22> for i in range(0,n):</line-22>
<line-23> for j in range(0,n):</line-23>
<line-24> if abs(i-j) == k:</line-24>
<line-25> if a[j] == 0:</line-25>
<line-26> a[j] = i + 1</line-26>
<line-27> done = True</line-27>
<line-28> break</line-28>
<line-29> else:</line-29>
<line-30> if a[j] > i + 1:</line-30>
<line-31> swap(a[j])</line-31>
<line-32> a[j] = i + 1</line-32>
<line-33> else:</line-33>
<line-34> done = False</line-34>
<line-35></line-35>
<line-36> if 0 in a:</line-36>
<line-37> print('CAPTAIN AMERICA EVADES')</line-37>
<line-38> else:</line-38>
<line-39> if done:</line-39>
<line-40> for c in a:</line-40>
<line-41> print(c, end=' ')</line-41>
<line-42> print()</line-42>
<line-43> else:</line-43>
<line-44> print('CAPTAIN AMERICA EVADES')</line-44>
<line-45></line-45>
<line-46></line-46>
<line-47> # for i in range(1,n+1):</line-47>
<line-48> # if i - k >=0 :</line-48>
<line-49> # if a[abs(i-k-1)] == 0:</line-49>
<line-50> # a[abs(i-k-1)] = i</line-50>
<line-51> # done = True</line-51>
<line-52> # else:</line-52>
<line-53> # done = False</line-53>
<line-54> # break</line-54>
<line-55> # else:</line-55>
<line-56> # done = False</line-56>
<line-57> # break</line-57>
<line-58> # if done:</line-58>
<line-59> # for c in a:</line-59>
<line-60> # print c,</line-60>
<line-61> # print</line-61>
<line-63> # print "CAPTAIN AMERICA EVADES"</line-63>
|
{"code": "<line-2>while t> 0:</line-2>\n<line-62> # else:</line-62>", "lines": [2, 62]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> t1=((2*(finish+distanetobolt)/(tigerAcceleration))**0.5)</line-3>
<line-4> t2=(finish/boltspeed)</line-4>
<line-5> if t1>t2:</line-5>
<line-6> print("Bolt")</line-6>
<line-7> elif t1<t2:</line-7>
<line-8> print("Tiger")</line-8>
<line-10> print("Tiger")</line-10>
|
{"code": "<line-2> finish,distanetobolt,tigerAcceleration,boltspeed=map(int,input().split())</line-2>\n<line-9> else:</line-9>", "lines": [2, 9]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>test=int(input())</line-3>
<line-4>for _ in range(test):</line-4>
<line-5> n=int(input())</line-5>
<line-6> a=[(bin(int(x))[2:][::-1]+("0")*32)for x in input().split()]</line-6>
<line-7> res=""</line-7>
<line-8> mysum=0</line-8>
<line-9> for i in range(32):</line-9>
<line-10> mycount=0</line-10>
<line-11> for j in range(n):</line-11>
<line-12> if(a[j][i]=="0"):</line-12>
<line-13> mycount+=1</line-13>
<line-14> if(mycount==n):</line-14>
<line-15> break</line-15>
<line-16> if(mycount>(n//2)):</line-16>
<line-17> res+="0"</line-17>
<line-18> mysum+=(n-mycount)*int(pow(2,i))</line-18>
<line-19> else:</line-19>
<line-20> res+="1"</line-20>
<line-22> print(mysum)</line-22>
|
{"code": "<line-2># cook your dish here</line-2>\n<line-21> mysum+=mycount*int(pow(2,i))</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3> x,y,z=map(int,input().split())</line-3>
<line-4> t=(x+y)//z</line-4>
<line-5> if t%2==0:</line-5>
<line-6> print('Chef')</line-6>
<line-7> else:</line-7>
<line-9> n-=1</line-9>
|
{"code": "<line-2>while(n>0):</line-2>\n<line-8> print('Paja')</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>try:</line-1>
<line-3> if n%a!=0:</line-3>
<line-4> number1=(n//a)+1</line-4>
<line-5> else:</line-5>
<line-6> number1=(n//a)</line-6>
<line-7> if m%a!=0:</line-7>
<line-8> number2=(m//a)+1</line-8>
<line-9> else:</line-9>
<line-10> number2=(m//a)</line-10>
<line-11> print(number1*number2)</line-11>
<line-13> pass</line-13>
|
{"code": "<line-2> n,m,a=map(int,input().split())</line-2>\n<line-12>except:</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>n,k, q = list(map(int, input().split()))</line-1>
<line-3>A = [0] * n</line-3>
<line-4>a, b, c, d, e, f, r, s, t, m, x = list(map(int, input().split())) </line-4>
<line-5>A[0] = x </line-5>
<line-6></line-6>
<line-7>for x in range(1, n):</line-7>
<line-8> if pow(t, x+1, s) <= r:</line-8>
<line-9> A[x] = (a*pow(A[x-1], 2, m) + b*A[x-1] + c) % m</line-9>
<line-10> else:</line-10>
<line-11> A[x] = (d*pow(A[x-1], 2, m) + e*A[x-1] + f) % m</line-11>
<line-12> </line-12>
<line-13>def SRMQ(arr, k):</line-13>
<line-14> from collections import deque</line-14>
<line-15> n = len(arr)</line-15>
<line-16> ans = [None] * n</line-16>
<line-17> deque = deque()</line-17>
<line-18> for i in range(len(arr)):</line-18>
<line-19> while deque and deque[-1] > arr[i]:</line-19>
<line-20> deque.pop()</line-20>
<line-21> deque.append(arr[i])</line-21>
<line-22> if i >= k and arr[i-k] == deque[0]:</line-22>
<line-23> deque.popleft()</line-23>
<line-24> if i >= k-1:</line-24>
<line-25> ans[i-k+1] = deque[0]</line-25>
<line-26> return ans</line-26>
<line-27> </line-27>
<line-28>v = SRMQ(A, k) </line-28>
<line-29></line-29>
<line-30>L1, La, Lc, Lm, D1, Da, Dc, Dm = list(map(int, input().split()))</line-30>
<line-31>s = 0 </line-31>
<line-32>prod = 1 </line-32>
<line-33>for _ in range(q):</line-33>
<line-34> L1 = (La * L1 + Lc) % Lm;</line-34>
<line-35> D1 = (Da * D1 + Dc) %Dm; </line-35>
<line-36> L = L1 + 1;</line-36>
<line-37> R = min(L + k - 1 + D1, n);</line-37>
<line-38> z = min(v[L-1], v[R-k])</line-38>
<line-39> s += z </line-39>
<line-40> </line-40>
<line-42>print(s, prod)</line-42>
<line-43></line-43>
|
{"code": "<line-2>mod = 10 ** 9 + 7</line-2>\n<line-41> prod = (prod * z) % mod</line-41>", "lines": [2, 41]}
#### 0
|
<line-1>from math import sqrt</line-1>
<line-3>sys.setrecursionlimit(10**8)</line-3>
<line-4>intMax = 10**18</line-4>
<line-5>def knapsack(rl,l,c,m):</line-5>
<line-6> if m==0 and rl>0:</line-6>
<line-7> return intMax</line-7>
<line-8> if rl<=0:</line-8>
<line-9> return 0</line-9>
<line-10> return min(c[m-1]+knapsack(rl-l[m-1],l,c,m),knapsack(rl,l,c,m-1))</line-10>
<line-11>for _ in range(int(input())):</line-11>
<line-12> n= int(input())</line-12>
<line-13> cost=[]</line-13>
<line-14> length=[]</line-14>
<line-15> sides=[]</line-15>
<line-16> for i in range(n):</line-16>
<line-17> x,y = map(int,input().split())</line-17>
<line-18> if i == 0:</line-18>
<line-19> x0 = x</line-19>
<line-20> y0 = y</line-20>
<line-21> prevx = x</line-21>
<line-22> prevy = y</line-22>
<line-23> elif i == n-1:</line-23>
<line-24> sides.append(sqrt((prevx-x)**2 + (prevy-y)**2))</line-24>
<line-25> sides.append(sqrt((x0-x)**2 + (y0-y)**2))</line-25>
<line-26> else:</line-26>
<line-27> sides.append(sqrt((prevx-x)**2 + (prevy-y)**2))</line-27>
<line-28> prevx = x</line-28>
<line-29> prevy = y</line-29>
<line-30> m = int(input())</line-30>
<line-31> for j in range(m):</line-31>
<line-32> li,ci = map(int,input().split())</line-32>
<line-33> length.append(li)</line-33>
<line-34> cost.append(ci)</line-34>
<line-35> ans=0</line-35>
<line-36> #print(sides)</line-36>
<line-37> for k in sides:</line-37>
<line-39> print(int(ans))</line-39>
|
{"code": "<line-2>import sys</line-2>\n<line-38> ans= ans + knapsack(k,length,cost,m)</line-38>", "lines": [2, 38]}
#### 0
|
<line-1>import math</line-1>
<line-2></line-2>
<line-4> if s==2:</line-4>
<line-5> return 1</line-5>
<line-6> </line-6>
<line-7> for i in range(2,math.ceil(math.sqrt(s))+1):</line-7>
<line-8> if s%i == 0:</line-8>
<line-9> return 0</line-9>
<line-10> </line-10>
<line-11> return 1</line-11>
<line-12> </line-12>
<line-13></line-13>
<line-14>def Solve(slots):</line-14>
<line-15> if slots<3:</line-15>
<line-16> return 0</line-16>
<line-17> </line-17>
<line-18> #check</line-18>
<line-19> s = math.sqrt(slots)</line-19>
<line-20> if math.floor(s) == math.ceil(s):</line-20>
<line-21> return check(s)</line-21>
<line-22> </line-22>
<line-23> return 0</line-23>
<line-24></line-24>
<line-25></line-25>
<line-26>N = int(input())</line-26>
<line-27></line-27>
<line-28>for t in range(N):</line-28>
<line-29> </line-29>
<line-30> slots = int(input())</line-30>
<line-31> </line-31>
<line-32> if (Solve(slots)):</line-32>
<line-33> print("YES")</line-33>
<line-34> </line-34>
<line-36> print("NO")</line-36>
|
{"code": "<line-3>def check(s):</line-3>\n<line-35> else:</line-35>", "lines": [3, 35]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>input=sys.stdin.readline</line-3>
<line-4>for _ in range(int(input())):</line-4>
<line-5> n,x=list(map(int,input().split()))</line-5>
<line-6> l=[0]</line-6>
<line-7> pre=[0]*(n+1)</line-7>
<line-8> sum=0</line-8>
<line-9> i=1</line-9>
<line-10> for m in input().split():</line-10>
<line-11> l.append(int(m))</line-11>
<line-12> sum+=int(m)</line-12>
<line-13> pre[i]=sum</line-13>
<line-14> i+=1</line-14>
<line-15> dict={}</line-15>
<line-16> k=[]</line-16>
<line-17> i=1</line-17>
<line-18> while (i*i)<=x:</line-18>
<line-19> if x%i==0:</line-19>
<line-20> k.append(i)</line-20>
<line-21> if (i*i)!=x:</line-21>
<line-22> k.append(x//i)</line-22>
<line-23> else:</line-23>
<line-24> break</line-24>
<line-25> i+=1 </line-25>
<line-26> ans=0 </line-26>
<line-27> for a in k:</line-27>
<line-28> if a>n:</line-28>
<line-29> continue</line-29>
<line-30> z=x//a </line-30>
<line-31> for j in range(a,n+1):</line-31>
<line-32> s=pre[j]-pre[j-a]</line-32>
<line-33> if s>z:</line-33>
<line-34> continue</line-34>
<line-35> if s in dict:</line-35>
<line-36> dict[s]+=1</line-36>
<line-37> else:</line-37>
<line-38> dict[s]=1</line-38>
<line-39> for j in range(a,n+1):</line-39>
<line-40> s=pre[j]-pre[j-a]</line-40>
<line-41> if s>z:</line-41>
<line-42> continue</line-42>
<line-43> if (z-s) in dict:</line-43>
<line-44> ans+=dict[z-s]</line-44>
<line-45> for j in range(a,n+1):</line-45>
<line-46> s=pre[j]-pre[j-a]</line-46>
<line-47> if s>z:</line-47>
<line-48> continue</line-48>
<line-50> </line-50>
<line-51> print(ans) </line-51>
<line-52> </line-52>
|
{"code": "<line-2>import sys</line-2>\n<line-49> dict[s]=0</line-49>", "lines": [2, 49]}
#### 0
|
<line-1>rooms=int(input())</line-1>
<line-3>keys=int(input())</line-3>
<line-4>rev=-1</line-4>
<line-5>a,b=0,-1</line-5>
<line-6>tot=[]</line-6>
<line-7>#print(money[-3:-1])</line-7>
<line-8>x=0</line-8>
<line-9>for i in range(keys):</line-9>
<line-10> #print(money[b:-1],money[0:a])</line-10>
<line-11> x=sum(money[b:])+sum(money[0:keys-abs(b)])</line-11>
<line-12> tot.append(x)</line-12>
<line-14>print(max(tot))</line-14>
|
{"code": "<line-2>money=list(map(int,input().split()))</line-2>\n<line-13> b-=1</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>s1=s2=lead=0</line-1>
<line-3>for _ in range(int(input())):</line-3>
<line-4> x, y= list(map(int, input().split()))</line-4>
<line-5> s1, s2= s1+x, s2+y</line-5>
<line-6> if(s1>s2):</line-6>
<line-7> lead=(s1-s2)</line-7>
<line-8> mlead1= max(mlead1, lead)</line-8>
<line-9> else:</line-9>
<line-10> lead=(s2-s1)</line-10>
<line-11> mlead2= max(mlead2, lead)</line-11>
<line-12>if(mlead1<(mlead2)):</line-12>
<line-13> print('2', mlead2)</line-13>
<line-15> print('1', mlead1)</line-15>
<line-16></line-16>
|
{"code": "<line-2>mlead1=mlead2=0</line-2>\n<line-14>else:</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>try:</line-1>
<line-3> for a in range(t):</line-3>
<line-4> l=input().split()</line-4>
<line-5> n=int(l[0])</line-5>
<line-6> m=int(l[1])</line-6>
<line-7> d={}</line-7>
<line-8> s=0</line-8>
<line-9> for b in range(m):</line-9>
<line-10> l1=input().split()</line-10>
<line-11> i=int(l1[0])</line-11>
<line-12> j=int(l1[1])</line-12>
<line-13> k=int(l1[2])</line-13>
<line-14> for c in range(i,j+1):</line-14>
<line-15> if c not in d:</line-15>
<line-16> d[c]=10</line-16>
<line-17> for c in range(i,j+1):</line-17>
<line-18> d[c]=d[c]*k</line-18>
<line-19> for i in d:</line-19>
<line-20> s=s+d[i]</line-20>
<line-21> print(s//n)</line-21>
<line-23> pass</line-23>
|
{"code": "<line-2> t=int(input())</line-2>\n<line-22>except:</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>n,q=map(int,input().split())</line-1>
<line-3>dc={}</line-3>
<line-4>for i in range(1,n+1):</line-4>
<line-5> dr[i]=0</line-5>
<line-6> dc[i]=0</line-6>
<line-7>mer=0</line-7>
<line-8>mec=0</line-8>
<line-9>for i in range(q):</line-9>
<line-10> s,j,k=input().split()</line-10>
<line-11> j=int(j)</line-11>
<line-12> k=int(k)</line-12>
<line-13> if s=="RowAdd":</line-13>
<line-14> dr[j]+=k</line-14>
<line-15> if dr[j]>mer:</line-15>
<line-16> mer=dr[j]</line-16>
<line-17> else:</line-17>
<line-18> dc[j]+=k</line-18>
<line-19> if mec<dc[j]:</line-19>
<line-20> mec=dc[j]</line-20>
<line-21># m=max(list(dr.values()))+max(list(dc.values()))</line-21>
<line-22></line-22>
<line-23># for i in range(n):</line-23>
<line-24># for j in range(n):</line-24>
<line-25># ar[i][j]=dr[i+1]+dc[j+1]</line-25>
<line-26># if ar[i][j]>m:</line-26>
<line-28></line-28>
<line-29>print(mer+mec)</line-29>
|
{"code": "<line-2>dr={}</line-2>\n<line-27># m=ar[i][j]</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>try:</line-1>
<line-3> k=int(input())</line-3>
<line-4> for i in range(1,k+1):</line-4>
<line-5> print(" "*(k-i),end="")</line-5>
<line-6> if i%2==1:</line-6>
<line-7> for j in range(0,i):</line-7>
<line-8> print(chr(65+j),end="")</line-8>
<line-9> else:</line-9>
<line-10> for j in range(0,i):</line-10>
<line-11> print(j+1,end="")</line-11>
<line-12> print()</line-12>
<line-13> </line-13>
<line-14> </line-14>
<line-16> pass</line-16>
|
{"code": "<line-2> for _ in range(int(input())):</line-2>\n<line-15>except:</line-15>", "lines": [2, 15]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(int(input())):</line-3>
<line-4> n=int(input())</line-4>
<line-5> a=list(map(int,input().split()))</line-5>
<line-7> print(int(ans))</line-7>
|
{"code": "<line-2>from math import ceil</line-2>\n<line-6> ans=ceil(n/min(a))</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> a=list(map(int,input().split()))</line-3>
<line-4> g=1</line-4>
<line-5> for j in range(1,n):</line-5>
<line-6> if j-5<0:</line-6>
<line-7> mi=min(a[0:j])</line-7>
<line-8> #print(a[0:j])</line-8>
<line-9> if mi>a[j]:</line-9>
<line-10> g=g+1</line-10>
<line-11> else:</line-11>
<line-12> mi=min(a[j-5:j])</line-12>
<line-13> #print(a[j-5:j])</line-13>
<line-14> if mi>a[j]:</line-14>
<line-16> print(g)</line-16>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-15> g=g+1</line-15>", "lines": [2, 15]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> first=b[0]</line-3>
<line-4> b.sort()</line-4>
<line-5> for j in range(n1-1):</line-5>
<line-6> if(a[j+1]-a[j]>d):</line-6>
<line-7> return "NO"</line-7>
<line-8> for j in range(n1):</line-8>
<line-9> if(b[j]==first):</line-9>
<line-10> pos=j</line-10>
<line-11> if(pos==0 or pos==n1-1):</line-11>
<line-12> return "YES"</line-12>
<line-13> rec=1</line-13>
<line-14> for j in range(pos-1,n1-2):</line-14>
<line-15> if(a[j+2]-a[j]>d):</line-15>
<line-16> rec=0</line-16>
<line-17> break</line-17>
<line-18> if(rec):</line-18>
<line-19> return "YES"</line-19>
<line-20> rec=1</line-20>
<line-21> for j in range(pos+1,1,-1):</line-21>
<line-22> if(a[j]-a[j-2]>d):</line-22>
<line-23> rec=0</line-23>
<line-24> break</line-24>
<line-25> if(rec):</line-25>
<line-26> return "YES"</line-26>
<line-27> else:</line-27>
<line-28> return "NO"</line-28>
<line-29> </line-29>
<line-30>testcase=int(input())</line-30>
<line-31>for i in range(testcase):</line-31>
<line-32> n,d=list(map(int,input().split()))</line-32>
<line-34> print(solution(a,n,d))</line-34>
|
{"code": "<line-2>def solution(b,n1,d):</line-2>\n<line-33> a=list(map(int,input().split()))</line-33>", "lines": [2, 33]}
#### 0
|
<line-1>t=eval(input())</line-1>
<line-3> x=input()</line-3>
<line-4> nm=x.split(' ')</line-4>
<line-5> nm[0]=int(nm[0])</line-5>
<line-6> nm[1]=int(nm[1])</line-6>
<line-7> csoint=[]</line-7>
<line-8> lsoint=[]</line-8>
<line-9> csofloat=[]</line-9>
<line-10> lsofloat=[]</line-10>
<line-11> for j in range(0,nm[0]):</line-11>
<line-12> a=input()</line-12>
<line-13> b=a.split(' ')</line-13>
<line-14> b[0]=int(b[0])</line-14>
<line-15> b[1]=int(b[1])</line-15>
<line-16> csoint.append(b[0])</line-16>
<line-17> lsoint.append(b[1])</line-17>
<line-18> for k in range(0,nm[1]):</line-18>
<line-19> a=input()</line-19>
<line-20> b=a.split(' ')</line-20>
<line-21> b[0]=int(b[0])</line-21>
<line-22> b[1]=int(b[1])</line-22>
<line-23> csofloat.append(b[0])</line-23>
<line-24> lsofloat.append(b[1])</line-24>
<line-25> chakra=0</line-25>
<line-26></line-26>
<line-27>## for j in range(0,nm[0]):</line-27>
<line-28>## if csofloat==[0]*nm[1]:</line-28>
<line-29>## print chakra</line-29>
<line-30>## break</line-30>
<line-31>## for k in range(0,nm[1]):</line-31>
<line-32>## if csofloat==[0]*nm[1]:</line-32>
<line-33>## print chakra</line-33>
<line-34>## break</line-34>
<line-35>## if lsoint[j]==lsofloat[k]:</line-35>
<line-36>## if csoint[j]>csofloat[k]:</line-36>
<line-37>## csoint[j]-=csofloat[k]</line-37>
<line-38>## csofloat[k]=0</line-38>
<line-39>## lsofloat[k]=0</line-39>
<line-40>## elif csofloat[k]>csoint[j]:</line-40>
<line-41>## if lsoint.count(lsoint[j])==1==lsofloat.count(lsofloat[k]):</line-41>
<line-42>## chakra+=csofloat[k]-csoint[j]</line-42>
<line-43>## csoint[j]=csofloat[k]</line-43>
<line-44>## csoint[j]=0</line-44>
<line-45>## csofloat[k]=0</line-45>
<line-46>## lsoint[j]=0</line-46>
<line-47>## lsofloat[k]=0</line-47>
<line-48>## elif lsoint.count(lsoint[j])==1 and lsofloat.count(lsofloat[k])>lsoint.count(lsoint[j]):</line-48>
<line-49>## csoint[j]=csofloat[k]+1</line-49>
<line-50>## chakra+=csofloat[k]-csoint[j]+1</line-50>
<line-51>## csoint[j]=1</line-51>
<line-52>## csofloat[k]=0</line-52>
<line-53>## lsofloat[k]=0</line-53>
<line-54>## else:</line-54>
<line-55>## csofloat[k]-=csoint[j]</line-55>
<line-56>## csoint[j]=0</line-56>
<line-57>## lsoint[j]=0</line-57>
<line-58>## break</line-58>
<line-59>## else:</line-59>
<line-60>## if lsoint.count(lsoint[j])==1 and lsoint.count(lsoint[j])>=lsofloat.count(lsofloat[k]):</line-60>
<line-61>## csoint[j]=0</line-61>
<line-62>## csofloat[k]=0</line-62>
<line-63>## lsoint[j]=0</line-63>
<line-64>## lsofloat[k]=0</line-64>
<line-65>## break</line-65>
<line-66>## elif lsoint.count(lsoint[j])==1 and lsoint.count(lsoint[j])<lsofloat.count(lsofloat[k]):</line-66>
<line-67>## csoint[j]=1</line-67>
<line-68>## chakra+=1</line-68>
<line-69>## csofloat[k]=0</line-69>
<line-70>## lsofloat[k]=0</line-70>
<line-71> l=min(lsoint)-1</line-71>
<line-72> ci=[]</line-72>
<line-73> for a in range(l+1,max(lsoint)+1):</line-73>
<line-74> c=0</line-74>
<line-75> l+=1</line-75>
<line-76> if l not in lsoint:</line-76>
<line-77> continue</line-77>
<line-78> for j in range(0,nm[0]):</line-78>
<line-79> if lsoint[j]==l:</line-79>
<line-80> c+=csoint[j]</line-80>
<line-81> ci.append(c)</line-81>
<line-82> </line-82>
<line-83> l=min(lsofloat)-1</line-83>
<line-84> cf=[]</line-84>
<line-85> for a in range(l+1,max(lsofloat)+1):</line-85>
<line-86> c=0</line-86>
<line-87> l+=1</line-87>
<line-88> if l not in lsofloat:</line-88>
<line-89> continue</line-89>
<line-90> for j in range(0,nm[1]):</line-90>
<line-91> if lsofloat[j]==l:</line-91>
<line-92> c+=csofloat[j]</line-92>
<line-93> cf.append(c)</line-93>
<line-94></line-94>
<line-95> for i in range(0,len(ci)):</line-95>
<line-96> if ci[i]<cf[i]:</line-96>
<line-98> print(chakra)</line-98>
|
{"code": "<line-2>for i in range(0,t):</line-2>\n<line-97> chakra+=cf[i]-ci[i]</line-97>", "lines": [2, 97]}
#### 0
|
<line-1>a=int(input())</line-1>
<line-3> print("4")</line-3>
<line-4> print(a/2,a/2,a/2,a/2)</line-4>
<line-5>else:</line-5>
<line-7> print((a-1)/2,(a-1)/2,(a-1)/2,(a-1)/2,(a-1)/2,(a+1)/2)</line-7>
|
{"code": "<line-2>if(a%2==0):</line-2>\n<line-6> print(\"6\")</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>MAXX = 10**9+1</line-1>
<line-3>nodes = list(map(int, input().split(" ")))</line-3>
<line-4>edges = [set() for _ in range(N)]</line-4>
<line-5>for _ in range(N-1):</line-5>
<line-6> a, b = list(map(int, input().split(" ")))</line-6>
<line-7> edges[a-1].add(b-1)</line-7>
<line-8> edges[b-1].add(a-1)</line-8>
<line-9>path = [[] for _ in range(N)]</line-9>
<line-10>visited, tovisit = set(), [(0, 0)]</line-10>
<line-11>while tovisit:</line-11>
<line-12> p, v = tovisit.pop()</line-12>
<line-13> if v not in visited:</line-13>
<line-14> path[v] = path[p] + [v]</line-14>
<line-15> visited.add(v)</line-15>
<line-16> news = edges[v] - visited</line-16>
<line-17> tovisit.extend([(v, x) for x in news])</line-17>
<line-18># print path</line-18>
<line-19></line-19>
<line-20>Q = eval(input())</line-20>
<line-21>for _ in range(Q):</line-21>
<line-22> q, a, b = input().split(" ")</line-22>
<line-23> a, b = int(a)-1, int(b)-1</line-23>
<line-24> i = 1</line-24>
<line-25> while i < min(len(path[a]), len(path[b])):</line-25>
<line-26> if path[a][i] != path[b][i]: break</line-26>
<line-27> i += 1</line-27>
<line-28> s = path[a][i-1:] + path[b][i:]</line-28>
<line-29></line-29>
<line-30> # print s</line-30>
<line-31> if q == "C":</line-31>
<line-32> s = sorted([nodes[i] for i in s])</line-32>
<line-33> d = s[-1] - s[0]</line-33>
<line-34> for i in range(len(s)-1):</line-34>
<line-35> d = min(d, s[i+1]-s[i])</line-35>
<line-36> print(d)</line-36>
<line-37> else:</line-37>
<line-38> M = 0</line-38>
<line-39> m = MAXX</line-39>
<line-40> for i in range(len(s)):</line-40>
<line-41> M = max(M, nodes[s[i]])</line-41>
<line-42> m = min(m, nodes[s[i]])</line-42>
<line-44> # print M[(s, l)] - m[(s, l)]</line-44>
|
{"code": "<line-2>N = eval(input())</line-2>\n<line-43> print(M - m)</line-43>", "lines": [2, 43]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> k=list(n)</line-3>
<line-4> dd,c,n=d,0,len(n)</line-4>
<line-5> for x in range(n):</line-5>
<line-6> if int(k[n-x-1])>int(d):</line-6>
<line-7> k.pop(n-x-1)</line-7>
<line-8> c+=1 </line-8>
<line-9> else:</line-9>
<line-11> print(''.join(k)+c*dd)</line-11>
|
{"code": "<line-2> n,d=map(str,input().split())</line-2>\n<line-10> d=k[n-x-1]</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>import math</line-1>
<line-3> n=int(input())</line-3>
<line-4> ar=[int(x) for x in input().split()]</line-4>
<line-5> # dp=[1]*n</line-5>
<line-6> f=0</line-6>
<line-7> g=ar[0]</line-7>
<line-8> for i in range(1,n):</line-8>
<line-9> g=math.gcd(g,ar[i])</line-9>
<line-10> if g==1:</line-10>
<line-11> f=1</line-11>
<line-12> print(n)</line-12>
<line-13> break</line-13>
<line-15> print(-1)</line-15>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-14> if f==0:</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n=int(input())</line-3>
<line-4> l=[int(i) for i in input().split()]</line-4>
<line-5> m={}</line-5>
<line-6> count=1</line-6>
<line-7> for i in range(1,n):</line-7>
<line-8> if l[i]==l[i-1]:</line-8>
<line-9> count+=1</line-9>
<line-10> else:</line-10>
<line-11> </line-11>
<line-12> if l[i-1] not in m:</line-12>
<line-13> m[l[i-1]]=(count*(count+1))/2</line-13>
<line-14> else:</line-14>
<line-15> </line-15>
<line-16> m[l[i-1]]+=(count*(count+1))/2</line-16>
<line-17> count=1</line-17>
<line-18> if(l[n-1]) not in m:</line-18>
<line-19> m[l[n-1]]=(count*(count+1))/2</line-19>
<line-20> else:</line-20>
<line-21> </line-21>
<line-22> m[l[n-1]]+=(count*(count+1))/2</line-22>
<line-23> s=1</line-23>
<line-24> </line-24>
<line-25> for x in m:</line-25>
<line-26> </line-26>
<line-28> print(s)</line-28>
<line-29> </line-29>
|
{"code": "<line-2>for k in range(t):</line-2>\n<line-27> s=(s*m[x])%(1000000007)</line-27>", "lines": [2, 27]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>import functools</line-3>
<line-4>def gcd(a, b): </line-4>
<line-5> if (a == 0): </line-5>
<line-6> return b </line-6>
<line-7> return gcd(b % a, a) </line-7>
<line-8> </line-8>
<line-9>MAX=10001</line-9>
<line-10>def func(ind, g, dp, n, a): </line-10>
<line-11> if (ind == n): </line-11>
<line-12> if (g == 1): </line-12>
<line-13> return 1</line-13>
<line-14> else: </line-14>
<line-15> return 0</line-15>
<line-16> if (dp[ind][g] != -1): </line-16>
<line-17> return dp[ind][g] </line-17>
<line-18> ans = (func(ind + 1, g, dp, n, a) + </line-18>
<line-19> func(ind + 1, gcd(a[ind], g), </line-19>
<line-20> dp, n, a)) </line-20>
<line-21> dp[ind][g] = ans </line-21>
<line-22> return dp[ind][g] </line-22>
<line-23> </line-23>
<line-24>def countSubsequences(a, n): </line-24>
<line-25> dp = [[-1 for i in range(MAX)] </line-25>
<line-26> for i in range(n)] </line-26>
<line-27> count = 0</line-27>
<line-28> for i in range(n): </line-28>
<line-29> count += func(i + 1, a[i], dp, n, a) </line-29>
<line-30> return count </line-30>
<line-31></line-31>
<line-32>test=int(stdin.readline())</line-32>
<line-33>for _ in range(test):</line-33>
<line-34> n=int(stdin.readline())</line-34>
<line-36> print(countSubsequences(list1,n))</line-36>
<line-37></line-37>
|
{"code": "<line-2>from sys import stdin</line-2>\n<line-35> list1=list(map(int,stdin.readline().split()))</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>#code snippet reference:http://www.geeksforgeeks.org/searching-for-patterns-set -2-kmp-algorithm/</line-1>
<line-3> M = len(pattern)</line-3>
<line-4> N = len(string)</line-4>
<line-5> nonlocal ans</line-5>
<line-6></line-6>
<line-7> lps = [0]*M</line-7>
<line-8> j = 0 </line-8>
<line-9> LPSCompute(pattern, M, lps)</line-9>
<line-10></line-10>
<line-11> i = 0 </line-11>
<line-12> while i < N:</line-12>
<line-13> if pattern[j] == string[i]:</line-13>
<line-14> i+=1</line-14>
<line-15> j+=1</line-15>
<line-16></line-16>
<line-17> if j==M:</line-17>
<line-18> ans+=1</line-18>
<line-19> j = lps[j-1]</line-19>
<line-20> </line-20>
<line-21> elif i < N and pattern[j] != string[i]:</line-21>
<line-22> if j != 0:</line-22>
<line-23> j = lps[j-1]</line-23>
<line-24> else:</line-24>
<line-25> i+=1</line-25>
<line-26></line-26>
<line-27>def LPSCompute(pattern, M, lps):</line-27>
<line-28> len = 0 </line-28>
<line-29> lps[0] </line-29>
<line-30> i = 1</line-30>
<line-31> while i < M:</line-31>
<line-32> if pattern[i]==pattern[len]:</line-32>
<line-33> len+=1</line-33>
<line-34> lps[i] = len</line-34>
<line-35> i+=1</line-35>
<line-36> else:</line-36>
<line-37> if len!=0:</line-37>
<line-38> len = lps[len-1]</line-38>
<line-39></line-39>
<line-40> else:</line-40>
<line-41> lps[i] = 0</line-41>
<line-42> i+=1</line-42>
<line-43></line-43>
<line-44>for _ in range(int(input())):</line-44>
<line-45> n,k=list(map(int,input().split()))</line-45>
<line-46> s=list(map(int,input().split()))</line-46>
<line-47> pattern=list(map(int,input().split()))</line-47>
<line-48> ans=0</line-48>
<line-49> string=[]</line-49>
<line-50> for i in range(n-1):</line-50>
<line-51> string.append(s[i+1]-s[i])</line-51>
<line-53> print(ans)</line-53>
<line-54></line-54>
|
{"code": "<line-2>def KMPMatch(pattern, string):</line-2>\n<line-52> KMPMatch(pattern, string)</line-52>", "lines": [2, 52]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n,k=map(int,input().split())</line-3>
<line-4> s=input()</line-4>
<line-5> upper=0</line-5>
<line-6> lower=0</line-6>
<line-7> for i in s:</line-7>
<line-8> if i.isupper():</line-8>
<line-9> upper+=1</line-9>
<line-10> else:</line-10>
<line-11> lower+=1</line-11>
<line-12> if lower>k and upper<=k:</line-12>
<line-13> print('chef')</line-13>
<line-14> elif(upper>k and lower<=k):</line-14>
<line-15> print('brother')</line-15>
<line-16> elif(upper<=k and lower<=k):</line-16>
<line-17> print('both')</line-17>
<line-18> else:</line-18>
<line-19> print('none')</line-19>
<line-20> return</line-20>
<line-22> do()</line-22>
|
{"code": "<line-2>def do():</line-2>\n<line-21>for i in range(t):</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from copy import copy</line-3>
<line-4></line-4>
<line-5>MOD = 10**9 + 7</line-5>
<line-6></line-6>
<line-7>R = lambda t = int: t(input())</line-7>
<line-8>RL = lambda t = int: [t(x) for x in input().split()]</line-8>
<line-9>RLL = lambda n, t = int: [RL(t) for _ in range(n)]</line-9>
<line-10></line-10>
<line-11># primes up to n</line-11>
<line-12>def primes(n):</line-12>
<line-13> P = []</line-13>
<line-14> n = int(n)</line-14>
<line-15> U = [1] * (n+1)</line-15>
<line-16> p = 2</line-16>
<line-17> while p <= n:</line-17>
<line-18> if U[p]:</line-18>
<line-19> P += [p]</line-19>
<line-20> x = p</line-20>
<line-21> while x <= n:</line-21>
<line-22> U[x] = 0</line-22>
<line-23> x += p</line-23>
<line-24> p += 1</line-24>
<line-25> return P</line-25>
<line-26> </line-26>
<line-27> </line-27>
<line-28> </line-28>
<line-29>def solve():</line-29>
<line-30> S = R(str).strip()</line-30>
<line-31> X = [ord(c)-ord('a') for c in S]</line-31>
<line-32> P = primes(10000)</line-32>
<line-33> L = defaultdict(lambda : 0)</line-33>
<line-34> s = 0</line-34>
<line-35> for i in range(len(S)):</line-35>
<line-36> p = i in P</line-36>
<line-37> NL = defaultdict(lambda : 0)</line-37>
<line-38> for a in range(26):</line-38>
<line-39> for l in L:</line-39>
<line-40> NL[l + a * p] += L[l]</line-40>
<line-41> for a in range(X[i]):</line-41>
<line-42> NL[s + a * p] += 1</line-42>
<line-43> s += X[i] * p</line-43>
<line-44> L = NL</line-44>
<line-45> L[s] += 1</line-45>
<line-46> r = 0 </line-46>
<line-47> for p in P:</line-47>
<line-48> r += L[p]</line-48>
<line-49> print(r % MOD)</line-49>
<line-50> </line-50>
<line-51>T = R()</line-51>
<line-53> solve()</line-53>
|
{"code": "<line-2>from collections import defaultdict</line-2>\n<line-52>for t in range(1, T + 1):</line-52>", "lines": [2, 52]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>d=defaultdict(list)</line-3>
<line-4>def dfs(i):</line-4>
<line-5> p=0</line-5>
<line-6> nonlocal v</line-6>
<line-7> e=[i]</line-7>
<line-8> while(e!=[]):</line-8>
<line-9> p+=1</line-9>
<line-10> x=e.pop(0)</line-10>
<line-11> v[x]=1</line-11>
<line-12> for i in d[x]:</line-12>
<line-13> if v[i]==-1:</line-13>
<line-14> v[i]=1</line-14>
<line-15> e.append(i)</line-15>
<line-16> return p</line-16>
<line-17></line-17>
<line-18>n,m=list(map(int,input().split()))</line-18>
<line-19>for i in range(n+1):</line-19>
<line-20> d[i]=[]</line-20>
<line-21>for _ in range(m):</line-21>
<line-22> a,b=list(map(int,input().split()))</line-22>
<line-23> d[a].append(b)</line-23>
<line-24> d[b].append(a)</line-24>
<line-25>v=[]</line-25>
<line-26>for i in range(n+1):</line-26>
<line-27> v.append(-1)</line-27>
<line-28>c=0</line-28>
<line-29>p=[]</line-29>
<line-30>for i in range(1,n+1):</line-30>
<line-31> if v[i]==-1:</line-31>
<line-32> c+=1</line-32>
<line-33> p.append(dfs(i))</line-33>
<line-34>an=0</line-34>
<line-35>s=0</line-35>
<line-36>for i in range(c):</line-36>
<line-37> s+=p[i]</line-37>
<line-39>print(an)</line-39>
|
{"code": "<line-2>from collections import defaultdict</line-2>\n<line-38> an+=p[i]*(n-s)</line-38>", "lines": [2, 38]}
#### 0
|
<line-1>from math import log2, ceil</line-1>
<line-3>srt = lambda s: ''.join(sorted(s))</line-3>
<line-4>for _ in range(int(input())):</line-4>
<line-5> s = srt(input())</line-5>
<line-6> res = -1</line-6>
<line-7> for p in range(ceil(log2(int(s))), int(log2(int(s[::-1]))) + 1):</line-7>
<line-8> if int(srt(str(pow(2, p)))) == int(s):</line-8>
<line-9> if res == -1: res = 0</line-9>
<line-11> print(res)</line-11>
|
{"code": "<line-2>MOD = int(1e9 + 7)</line-2>\n<line-10> res = (res + pow(2, p, MOD)) % MOD</line-10>", "lines": [2, 10]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> for _ in range(int(input())):</line-3>
<line-4> k = int(input())</line-4>
<line-5> num = 1</line-5>
<line-6> for i in range(1,k+1,1):</line-6>
<line-7> for j in range(1,k+1,1):</line-7>
<line-8> print(num*2,end="")</line-8>
<line-9> num = num +1</line-9>
<line-10> print("")</line-10>
<line-12> pass</line-12>
|
{"code": "<line-2>try:</line-2>\n<line-11>except:</line-11>", "lines": [2, 11]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> c=0</line-3>
<line-4> for i in range(int(input())):</line-4>
<line-5> s,j=list(map(int,input().split()))</line-5>
<line-6> if (j-s)>5:</line-6>
<line-8> print(c)</line-8>
<line-9> </line-9>
|
{"code": "<line-2>for t in range(int(input())):</line-2>\n<line-7> c+=1 </line-7>", "lines": [2, 7]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> a1,a2,a3,a4,a5,p=[int(x)for x in input().rstrip().split()]</line-3>
<line-4> if (a1+a2+a3+a4+a5)*p >120:</line-4>
<line-5> print("Yes")</line-5>
<line-7> print("No")</line-7>
|
{"code": "<line-2>for t in range(int(input())):</line-2>\n<line-6> else:</line-6>", "lines": [2, 6]}
#### 0
|
<line-1></line-1>
<line-2>for _ in range(int(input())):</line-2>
<line-4> arr = list(map(int, input().split()))</line-4>
<line-5> hrs = arr[0] - arr[1]</line-5>
<line-6></line-6>
<line-7> for i in range(1, n-1):</line-7>
<line-8> if hrs > arr[i] - arr[i+1]:</line-8>
<line-10></line-10>
<line-11> print(hrs)</line-11>
|
{"code": "<line-3> n = int(input())</line-3>\n<line-9> hrs = arr[i] - arr[i+1]</line-9>", "lines": [3, 9]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> N=int(input())</line-3>
<line-4> L=list(map(int,input().split()))</line-4>
<line-5> l,h=0,N-1 </line-5>
<line-6> flag=1</line-6>
<line-7> if L[l]!=1 and L[h]!=1:</line-7>
<line-8> flag=0</line-8>
<line-9> else:</line-9>
<line-10> while(l<h):</line-10>
<line-11> if (L[l]!=L[h]) or (L[l+1]-L[l]!=1 and L[h-1]-L[h]!=1):</line-11>
<line-12> flag=0</line-12>
<line-13> break</line-13>
<line-14> l+=1 </line-14>
<line-15> h-=1</line-15>
<line-16> if flag:</line-16>
<line-17> print("yes")</line-17>
<line-19> print("no")</line-19>
|
{"code": "<line-2>for i in range(int(input())):</line-2>\n<line-18> else:</line-18>", "lines": [2, 18]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n,k=list(map(int,input().split()))</line-3>
<line-4> a=list(map(int,input().split()))</line-4>
<line-5> m=0</line-5>
<line-6> for i in range(n):</line-6>
<line-7> if i%2==0:</line-7>
<line-8> if m<0:</line-8>
<line-9> m-=a[i]</line-9>
<line-10> else:</line-10>
<line-11> m+=a[i]</line-11>
<line-12> else:</line-12>
<line-13> if m<0:</line-13>
<line-14> m+=a[i]</line-14>
<line-15> else:</line-15>
<line-16> m-=a[i]</line-16>
<line-17> if abs(m)>=k:</line-17>
<line-18> print(1)</line-18>
<line-20> print(2)</line-20>
<line-21> </line-21>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-19> else:</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>class Node:</line-1>
<line-3> self.x=x</line-3>
<line-4> self.next=None</line-4>
<line-5> self.prev=None</line-5>
<line-6> self.flag=True</line-6>
<line-7></line-7>
<line-8>for t in range(1):</line-8>
<line-9> n=int(input())</line-9>
<line-10> arr=list(map(int,input().split()))</line-10>
<line-11> for i in range(n):</line-11>
<line-12> arr[i]=Node(arr[i])</line-12>
<line-13> for i in arr:</line-13>
<line-14> d=[i.x%3==0,i.x,i.x//3,i.x*2]</line-14>
<line-15> if d[0]:</line-15>
<line-16> for j in arr:</line-16>
<line-17> if j.x==d[2]:</line-17>
<line-18> i.next=j</line-18>
<line-19> j.prev=i</line-19>
<line-20> break</line-20>
<line-21> else:</line-21>
<line-22> for j in arr:</line-22>
<line-23> if j.x == d[3]:</line-23>
<line-24> i.next = j</line-24>
<line-25> j.prev = i</line-25>
<line-26> break</line-26>
<line-27> else:</line-27>
<line-28> for j in arr:</line-28>
<line-29> if j.x==d[3]:</line-29>
<line-30> i.next=j</line-30>
<line-31> j.prev=i</line-31>
<line-32> break</line-32>
<line-33> f,l=None,None</line-33>
<line-34> for i in arr:</line-34>
<line-35> if i.prev==None:</line-35>
<line-36> f=i</line-36>
<line-37> elif i.next==None:</line-37>
<line-38> l=i</line-38>
<line-39> while f!=l and l!=None:</line-39>
<line-40> print(f.x,end=" ")</line-40>
<line-42> print(f.x)</line-42>
|
{"code": "<line-2> def __init__(self,x):</line-2>\n<line-41> f=f.next</line-41>", "lines": [2, 41]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>import math</line-3>
<line-4>test=int(input())</line-4>
<line-5>for _ in range(test):</line-5>
<line-6> n=int(input())</line-6>
<line-7> l=list(map(int,input().split()))</line-7>
<line-8> f=0</line-8>
<line-9> for i in range(math.ceil(n//2)):</line-9>
<line-10> if n%2==1:</line-10>
<line-11> f=1</line-11>
<line-12> break</line-12>
<line-13> else:</line-13>
<line-14> if l[i]!=l[i+n//2]:</line-14>
<line-15> if min(l[i],l[i+n//2])==-1:</line-15>
<line-16> l[i]=max(l[i],l[i+n//2])</line-16>
<line-17> l[i+n//2]=max(l[i],l[i+n//2])</line-17>
<line-18> else:</line-18>
<line-19> f=1</line-19>
<line-20> break</line-20>
<line-21> else:</line-21>
<line-22> if l[i]==-1:</line-22>
<line-23> l[i]=1</line-23>
<line-24> l[i+n//2]=1</line-24>
<line-25> if f==1:</line-25>
<line-26> print("NO")</line-26>
<line-27> else:</line-27>
<line-29> print(*l)</line-29>
|
{"code": "<line-2># cook your dish here</line-2>\n<line-28> print(\"YES\")</line-28>", "lines": [2, 28]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n = int(input())</line-3>
<line-4> count = 1</line-4>
<line-5> l = 3*(n-1)</line-5>
<line-6> i = 0</line-6>
<line-7> if n==1:</line-7>
<line-8> print(1)</line-8>
<line-9> continue</line-9>
<line-10> while count<=l-n:</line-10>
<line-11> for j in range(i+1):</line-11>
<line-12> if j==i:</line-12>
<line-13> print(count)</line-13>
<line-14> count += 1</line-14>
<line-15> elif j==0:</line-15>
<line-16> print(count,end="")</line-16>
<line-17> count += 1</line-17>
<line-18> else:</line-18>
<line-19> print(" ",end="") </line-19>
<line-20> i+=1</line-20>
<line-21> while count<=l:</line-21>
<line-22> print(count,end="")</line-22>
<line-24> print()</line-24>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-23> count += 1</line-23>", "lines": [2, 23]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(int(input())):</line-3>
<line-4> sli,mem,sma,luc = list(map(int, input().split()))</line-4>
<line-5> total = sma</line-5>
<line-6> t = sma</line-6>
<line-7> while mem > 1:</line-7>
<line-8> t *= luc</line-8>
<line-9> total += t</line-9>
<line-10> mem -= 1</line-10>
<line-11> if total <= sli:</line-11>
<line-12> extra += sli-total</line-12>
<line-13> print('POSSIBLE',sli-total)</line-13>
<line-14> else:</line-14>
<line-15> less += total-sli</line-15>
<line-16> print('IMPOSSIBLE',total-sli)</line-16>
<line-17>if extra >= less:</line-17>
<line-18> print('POSSIBLE')</line-18>
<line-20> print('IMPOSSIBLE')</line-20>
<line-21> </line-21>
<line-22> </line-22>
<line-23> </line-23>
<line-24> </line-24>
|
{"code": "<line-2>extra, less = 0,0</line-2>\n<line-19>else:</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>from collections import defaultdict as dd,deque as dq</line-1>
<line-3> q=dq([(u,0)])</line-3>
<line-4> uu=u</line-4>
<line-5> su=0</line-5>
<line-6> while q:</line-6>
<line-7> </line-7>
<line-8> u,lol=q.pop()</line-8>
<line-9> par=parr[u]</line-9>
<line-10> if(lol%2==0):</line-10>
<line-11> vis[u]=1</line-11>
<line-12> su+=ll[u-1]</line-12>
<line-13> ll[u-1]=0</line-13>
<line-14> for j in d[u]:</line-14>
<line-15> if(j!=par):</line-15>
<line-16> q.appendleft((j,lol+1))</line-16>
<line-17> ll[uu-1]=su</line-17>
<line-18>def bfs(height,d,parr):</line-18>
<line-19> q=dq([1])</line-19>
<line-20> while q:</line-20>
<line-21> u=q.pop()</line-21>
<line-22> height[u]=height[parr[u]]+1</line-22>
<line-23> for i in d[u]:</line-23>
<line-24> if(i!=parr[u]):</line-24>
<line-25> q.appendleft(i)</line-25>
<line-26> parr[i]=u</line-26>
<line-27>t=int(input())</line-27>
<line-28>while t:</line-28>
<line-29> n,q=map(int,input().split())</line-29>
<line-30> ll=list(map(int,input().split()))</line-30>
<line-31> d=dd(list)</line-31>
<line-32> for i in range(n-1):</line-32>
<line-33> u,v=map(int,input().split())</line-33>
<line-34> d[u].append(v)</line-34>
<line-35> d[v].append(u)</line-35>
<line-36> vis=[0]*(n+1)</line-36>
<line-37> l=[]</line-37>
<line-38> height=[0]*(n+1)</line-38>
<line-39> parr=[0]*(n+1)</line-39>
<line-40> bfs(height,d,parr)</line-40>
<line-41> for i in range(q):</line-41>
<line-42> u=int(input())</line-42>
<line-43> l.append((height[u],u,i))</line-43>
<line-44> l.sort()</line-44>
<line-45> vis=[0]*(n+1)</line-45>
<line-46> #print(l)</line-46>
<line-47> for i in l:</line-47>
<line-48> he,u,ind=i</line-48>
<line-49> if(vis[u]==0):</line-49>
<line-50> #print(u)</line-50>
<line-51> opbfs(u,vis,ll,parr)</line-51>
<line-53> t-=1</line-53>
|
{"code": "<line-2>def opbfs(u,vis,ll,parr):</line-2>\n<line-52> print(*ll)</line-52>", "lines": [2, 52]}
#### 0
|
<line-1>d=1000000007</line-1>
<line-3> l=sorted(list(map(int,input().split())))</line-3>
<line-5> print(ans%d)</line-5>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-4> ans=(l[0]%d)*((l[1]-1)%d)*((l[2]-2)%d)</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>T=int(input())</line-1>
<line-3> n,m=list(map(int,input().split()))</line-3>
<line-4> if(m<=2):</line-4>
<line-5> print("impossible")</line-5>
<line-6> else:</line-6>
<line-7> l=[0]*m</line-7>
<line-8></line-8>
<line-9> if(m%2==0):</line-9>
<line-10> a=m//2</line-10>
<line-11> else:</line-11>
<line-12> a=(m//2)+1</line-12>
<line-13> for j in range(a):</line-13>
<line-14> if(j%2==0):</line-14>
<line-15> l[j]="a"</line-15>
<line-16> l[m-j-1]="a"</line-16>
<line-17> </line-17>
<line-18> else:</line-18>
<line-19> l[j]="b"</line-19>
<line-20> l[m-j-1]="b"</line-20>
<line-21> </line-21>
<line-22> </line-22>
<line-23> r=""</line-23>
<line-24> s=n//m</line-24>
<line-25> for e in l:</line-25>
<line-27> print(r*s)</line-27>
<line-28> </line-28>
<line-29> </line-29>
<line-30></line-30>
|
{"code": "<line-2>for i in range(T):</line-2>\n<line-26> r=r+e</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>def power(x, y):</line-1>
<line-3> return 1</line-3>
<line-4> if y % 2 == 0:</line-4>
<line-5> return power(x, y // 2) * power(x, y // 2)</line-5>
<line-6></line-6>
<line-7> return x * power(x, y // 2) * power(x, y // 2)</line-7>
<line-8></line-8>
<line-9></line-9>
<line-10># Function to calculate order of the number</line-10>
<line-11>def order(x):</line-11>
<line-12> # Variable to store of the number</line-12>
<line-13> n = 0</line-13>
<line-14> while (x != 0):</line-14>
<line-15> n = n + 1</line-15>
<line-16> x = x // 10</line-16>
<line-17></line-17>
<line-18> return n</line-18>
<line-19></line-19>
<line-20></line-20>
<line-21># Function to check whether the given</line-21>
<line-22># number is Armstrong number or not</line-22>
<line-23>def isArmstrong(x):</line-23>
<line-24> n = order(x)</line-24>
<line-25> temp = x</line-25>
<line-26> sum1 = 0</line-26>
<line-27></line-27>
<line-28> while (temp != 0):</line-28>
<line-29> r = temp % 10</line-29>
<line-30> sum1 = sum1 + power(r, n)</line-30>
<line-31> temp = temp // 10</line-31>
<line-32></line-32>
<line-33> # If condition satisfies</line-33>
<line-34> return (sum1 == x)</line-34>
<line-35></line-35>
<line-36></line-36>
<line-37># Driver code</line-37>
<line-38></line-38>
<line-39>for _ in range(int(input())):</line-39>
<line-40> num = int(input())</line-40>
<line-41> if isArmstrong(num):</line-41>
<line-42> print("FEELS GOOD")</line-42>
<line-44> print("FEELS BAD")</line-44>
|
{"code": "<line-2>\tif y == 0:</line-2>\n<line-43>\telse:</line-43>", "lines": [2, 43]}
#### 0
|
<line-1>T = int(input())</line-1>
<line-3> n,m = map(int,input().split())</line-3>
<line-4> completed = list(map(int,input().split()))</line-4>
<line-5> jobs = []</line-5>
<line-6> for i in range(1,n+1):</line-6>
<line-7> if i not in completed:</line-7>
<line-8> jobs.append(i)</line-8>
<line-9> jobs.sort()</line-9>
<line-10> chef = []</line-10>
<line-11> ass = []</line-11>
<line-12> for i in range(len(jobs)):</line-12>
<line-13> if i%2==0:</line-13>
<line-14> chef.append(str(jobs[i]))</line-14>
<line-15> else:</line-15>
<line-16> ass.append(str(jobs[i]))</line-16>
<line-18> print(' '.join(ass))</line-18>
|
{"code": "<line-2>for _ in range(T):</line-2>\n<line-17> print(' '.join(chef))</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> t-=1;</line-3>
<line-4> n,l,r = list(map(int,input().split()));</line-4>
<line-5> a = bin(l)[2:];</line-5>
<line-6> b = bin(r)[2:];</line-6>
<line-7> # find matching</line-7>
<line-8> z = 0;</line-8>
<line-9> l = min(len(a),len(b));</line-9>
<line-10> for i in range(l):</line-10>
<line-11> if a[i]==b[i]:</line-11>
<line-12> z+=1;</line-12>
<line-13> else:</line-13>
<line-14> break;</line-14>
<line-15></line-15>
<line-16> #find base string</line-16>
<line-17> a = a[z:]</line-17>
<line-18> b = b[z:]</line-18>
<line-19> if(len(a)==0 and len(b)==0):</line-19>
<line-20> print(n);</line-20>
<line-21> else :</line-21>
<line-22> m = max(len(a),len(b))</line-22>
<line-23> #print m;</line-23>
<line-24> zz = bin(n)[2:]</line-24>
<line-25> x= len(zz)</line-25>
<line-26> y = zz[:x-m]</line-26>
<line-27> </line-27>
<line-28> f1 = y+a;</line-28>
<line-29> f2 = y+b;</line-29>
<line-30> ans = int(y,2)</line-30>
<line-31> if(int(f1,2)>n or int(f2,2)>n):</line-31>
<line-33> </line-33>
<line-34> print(ans) </line-34>
<line-35> </line-35>
<line-36></line-36>
<line-37> </line-37>
|
{"code": "<line-2>while(t>0):</line-2>\n<line-32> ans-=1;</line-32>", "lines": [2, 32]}
#### 0
|
<line-1>import math</line-1>
<line-3>while(t > 0):</line-3>
<line-4> h,s = input().split()</line-4>
<line-5> h = int(h)</line-5>
<line-6> s = int(s)</line-6>
<line-7> if(((h*h*h*h) - (16*s*s)) < 0):</line-7>
<line-8> print("-1")</line-8>
<line-9> else:</line-9>
<line-10> B = (math.sqrt((h*h) + math.sqrt((h*h*h*h) - (16*s*s))))/math.sqrt(2)</line-10>
<line-11> P = (2*s)/B</line-11>
<line-12> if(B > P):</line-12>
<line-13> print('{0:.6f}'.format(P),'{0:.6f}'.format(B),'{0:.6f}'.format(h))</line-13>
<line-14> else:</line-14>
<line-16> t = t-1</line-16>
|
{"code": "<line-2>t = eval(input())</line-2>\n<line-15> print('{0:.6f}'.format(B),'{0:.6f}'.format(P),'{0:.6f}'.format(h))</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>a = [1]</line-1>
<line-3>for ii in range(1, 1000005):</line-3>
<line-4> a.append((a[-1]*ii)%M)</line-4>
<line-5>for __ in range(eval(input())):</line-5>
<line-6> n, x = list(map(int, input().split()))</line-6>
<line-8> else: print((a[n]*x)%M)</line-8>
|
{"code": "<line-2>M = 10**6 + 3</line-2>\n<line-7> if n>=M: print(0)</line-7>", "lines": [2, 7]}
#### 0
|
{"code": "<line-1>print(0)</line-1>", "lines": [1]}
#### 0
|
|
<line-1>from math import log2;</line-1>
<line-3>from bisect import bisect_left,bisect_right</line-3>
<line-4>import sys;</line-4>
<line-5>from math import gcd,sqrt</line-5>
<line-6>sys.setrecursionlimit(10**7)</line-6>
<line-7>from collections import defaultdict</line-7>
<line-8>inf=float("inf")</line-8>
<line-9># n=int(input())</line-9>
<line-10># n,m=map(int,input().split())</line-10>
<line-11># l=list(map(int,input().split()))</line-11>
<line-12>def get_factors(x):</line-12>
<line-13> if x==1:</line-13>
<line-14> return [];</line-14>
<line-15> sqrta=int(sqrt(x))+1</line-15>
<line-16> for i in range(2,sqrta):</line-16>
<line-17> if x%i==0:</line-17>
<line-18> return [i]+get_factors(x//i)</line-18>
<line-19> return [x]</line-19>
<line-20>def min_generator(fac,k,index,new_list):</line-20>
<line-21> if index==len(fac):</line-21>
<line-22> return sum(new_list)</line-22>
<line-23> mina=inf;</line-23>
<line-24> for i in range(0,min(index+1,len(new_list))):</line-24>
<line-25> new_list[i]*=fac[index]</line-25>
<line-26> theta=min_generator(fac,k,index+1,new_list)</line-26>
<line-27> if theta<mina:</line-27>
<line-28> mina=theta;</line-28>
<line-29> new_list[i]//=fac[index]</line-29>
<line-30> return mina;</line-30>
<line-31>def fun(k,x):</line-31>
<line-32> dict=defaultdict(lambda :1)</line-32>
<line-33> factors=get_factors(x)</line-33>
<line-34> for i in factors:</line-34>
<line-35> dict[i]*=i;</line-35>
<line-36> if len(dict)==k:</line-36>
<line-37> print(sum(dict.values()))</line-37>
<line-38> return;</line-38>
<line-39> if len(dict)<k:</line-39>
<line-40> suma=sum(dict.values())</line-40>
<line-41> left=k-len(dict)</line-41>
<line-42> suma+=left;</line-42>
<line-43> print(suma)</line-43>
<line-44> return;</line-44>
<line-45> if k==1:</line-45>
<line-46> print(x)</line-46>
<line-47> return;</line-47>
<line-48> fac=list(dict.values())</line-48>
<line-49></line-49>
<line-50> new_list=[1]*k</line-50>
<line-51> theta=min_generator(fac,k,0,new_list)</line-51>
<line-52> print(theta)</line-52>
<line-53>for i in range(int(input())):</line-53>
<line-55> fun(k,x)</line-55>
|
{"code": "<line-2>import bisect;</line-2>\n<line-54> k,x=map(int,input().split())</line-54>", "lines": [2, 54]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3></line-3>
<line-4>CurrentPosition = namedtuple('current_position', 'points, cell, pairs')</line-4>
<line-5></line-5>
<line-6>T = int(input())</line-6>
<line-7>for _ in range(T):</line-7>
<line-8> R, C, N = map(int, input().split())</line-8>
<line-9> Sx, Sy = map(int, input().split())</line-9>
<line-10> tx = map(int, input().split())</line-10>
<line-11> ty = map(int, input().split())</line-11>
<line-12> tel_pairs = list(zip(tx, ty))</line-12>
<line-13> board = []</line-13>
<line-14> for _ in range(R):</line-14>
<line-15> board += [[int(c) for c in input().split()]]</line-15>
<line-16> </line-16>
<line-17> def explore(p):</line-17>
<line-18> next_pos = []</line-18>
<line-19> for i, (dx, dy) in enumerate(p.pairs):</line-19>
<line-20> sx, sy = p.cell</line-20>
<line-21> new_pairs = p.pairs[:i]+p.pairs[i+1:]</line-21>
<line-22> # case (+, +)</line-22>
<line-23> px, py = sx + dx, sy + dy</line-23>
<line-24> if px < R and py < C:</line-24>
<line-25> next_pos += [CurrentPosition(p.points+board[px][py], (px, py), new_pairs)]</line-25>
<line-26> # case (+, -)</line-26>
<line-27> px, py = sx + dx, sy - dy</line-27>
<line-28> if px < R and 0 <= py:</line-28>
<line-29> next_pos += [CurrentPosition(p.points+board[px][py], (px, py), new_pairs)]</line-29>
<line-30> # case (-, +)</line-30>
<line-31> px, py = sx - dx, sy + dy</line-31>
<line-32> if 0 <= px and py < C:</line-32>
<line-33> next_pos += [CurrentPosition(p.points+board[px][py], (px, py), new_pairs)]</line-33>
<line-34> # case (-, -)</line-34>
<line-35> px, py = sx - dx, sy - dy</line-35>
<line-36> if 0 <= px and 0 <= py:</line-36>
<line-37> next_pos += [CurrentPosition(p.points+board[px][py], (px, py), new_pairs)]</line-37>
<line-38> return next_pos</line-38>
<line-39> </line-39>
<line-40> pos = [CurrentPosition(board[Sx][Sy], (Sx, Sy), tel_pairs)]</line-40>
<line-41> result = board[Sx][Sy]</line-41>
<line-42> while pos:</line-42>
<line-43> p = pos.pop(0)</line-43>
<line-44> if p.pairs:</line-44>
<line-45> pos += explore(p)</line-45>
<line-46> else:</line-46>
<line-48> </line-48>
<line-49> print(result) </line-49>
|
{"code": "<line-2>from collections import namedtuple</line-2>\n<line-47> result = max(result, p.points)</line-47>", "lines": [2, 47]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(t):</line-3>
<line-4> x1,y1,x2,y2=map(int,input().split())</line-4>
<line-5> x3,y3,x4,y4=map(int,input().split())</line-5>
<line-6> if (x1==x3 and y1==y3)or(x2==x4 and y2==y4):</line-6>
<line-7> print("yes")</line-7>
<line-8> elif (x1==x4 and y1==y4)or(x2==x3 and y2==y3):</line-8>
<line-9> print("yes")</line-9>
<line-10> else:</line-10>
<line-11> if(y1==y2)and(y1==y3)and(y1==y4):</line-11>
<line-12> a1=max(x1,x2);a2=min(x1,x2)</line-12>
<line-13> b1=max(x3,x4);b2=min(x3,x4)</line-13>
<line-14> if a1>=b2 and a2<=b1:</line-14>
<line-15> print("yes")</line-15>
<line-16> else:</line-16>
<line-17> print("no")</line-17>
<line-18> elif (x1==x2)and(x1==x3)and(x1==x4):</line-18>
<line-19> a1=max(y1,y2);a2=min(y1,y2)</line-19>
<line-20> b1=max(y3,y4);b2=min(y3,y4)</line-20>
<line-21> if a1>=b2 and a2<=b1:</line-21>
<line-22> print("yes")</line-22>
<line-23> else:</line-23>
<line-24> print("no")</line-24>
<line-26> print("no")</line-26>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-25> else:</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> a = []</line-3>
<line-4> last = 0</line-4>
<line-5> for i in range(len(s)):</line-5>
<line-6> if s[i] == 'P':</line-6>
<line-7> a.append(i - last)</line-7>
<line-8> last = i + 1</line-8>
<line-9> x = 0</line-9>
<line-10> a = a[::-1]</line-10>
<line-11> for v in a[::2]:</line-11>
<line-13> print('Yes' if x else 'No')</line-13>
|
{"code": "<line-2> s = input().strip()</line-2>\n<line-12> x ^= v % 3</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>MOD = int(1e9+7)</line-1>
<line-2></line-2>
<line-4> rsp = [[0, 0, 0],</line-4>
<line-5> [0, 0, 0],</line-5>
<line-6> [0, 0, 0]]</line-6>
<line-7></line-7>
<line-8> for i in range(3):</line-8>
<line-9> for j in range(3):</line-9>
<line-10> for k in range(3):</line-10>
<line-11> rsp[i][j] += a[i][k] * b[k][j]</line-11>
<line-12> rsp[i][j] %= MOD</line-12>
<line-13></line-13>
<line-14> return rsp</line-14>
<line-15></line-15>
<line-16>ident = [[1, 0, 0],</line-16>
<line-17> [0, 1, 0],</line-17>
<line-18> [0, 0, 1]]</line-18>
<line-19>m = [[1, 1, 0],</line-19>
<line-20> [1, 0, 1],</line-20>
<line-21> [1, 0, 0]]</line-21>
<line-22></line-22>
<line-23>powers = [m]</line-23>
<line-24>for _ in range(53):</line-24>
<line-25> p = powers[-1]</line-25>
<line-26> powers.append(mult(p ,p))</line-26>
<line-27></line-27>
<line-28>def pow2(e):</line-28>
<line-29> y = ident</line-29>
<line-30> i = 0</line-30>
<line-31> for p in powers:</line-31>
<line-32> if e & (1 << i):</line-32>
<line-33> y = mult(p, y)</line-33>
<line-34> i += 1</line-34>
<line-35> return y</line-35>
<line-36></line-36>
<line-37>t = eval(input())</line-37>
<line-38></line-38>
<line-39>for _ in range(t):</line-39>
<line-40> n = eval(input())</line-40>
<line-41></line-41>
<line-42> if n < 3:</line-42>
<line-43> print(0)</line-43>
<line-44> continue</line-44>
<line-45></line-45>
<line-46> r = pow(2, n, MOD)</line-46>
<line-47> b = pow2(n - 2)</line-47>
<line-48> # print(b)</line-48>
<line-49> r -= (4 * b[0][0]) % MOD</line-49>
<line-50> r -= (2 * b[1][0]) % MOD</line-50>
<line-51> r -= b[2][0]</line-51>
<line-53> print(r)</line-53>
|
{"code": "<line-3>def mult(a, b):</line-3>\n<line-52> r = (MOD + r) % MOD</line-52>", "lines": [3, 52]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> ans=0</line-3>
<line-4> x,y=list(map(int,input().split()))</line-4>
<line-5> if y>x:</line-5>
<line-6> if (y-x)%4==0:ans=3</line-6>
<line-7> elif (y-x)%2==0: ans=2</line-7>
<line-8> else: ans=1</line-8>
<line-9> if y<x:</line-9>
<line-10> if (y-x)%2==0:ans=1</line-10>
<line-12> print(ans)</line-12>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-11> else: ans=2</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-2></line-2>
<line-4> n,q=map(int,input().split())</line-4>
<line-5> s=input()</line-5>
<line-6> l=[0]*(n-1)</line-6>
<line-7> for i in range(n-2):</line-7>
<line-8> a,b,c=s[i],s[i+1],s[i+2]</line-8>
<line-9> if len(set([a,b,c]))<3:</line-9>
<line-10> l[i]=l[i-1]+1</line-10>
<line-11> else:</line-11>
<line-12> l[i]=l[i-1]</line-12>
<line-13> </line-13>
<line-14> for i in range(q):</line-14>
<line-15> left,right=map(int,input().split())</line-15>
<line-16> left-=1</line-16>
<line-17> right-=1</line-17>
<line-18> if right-left+1 <3:</line-18>
<line-19> print('NO')</line-19>
<line-20> continue</line-20>
<line-21> if (l[right-2]-l[left-1])>0:</line-21>
<line-22> print('YES')</line-22>
<line-24> print('NO')</line-24>
|
{"code": "<line-3>for _ in range(t):</line-3>\n<line-23> else:</line-23>", "lines": [3, 23]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n=int(input())</line-3>
<line-4> l=list(map(int,input().split()))</line-4>
<line-5> d=[]</line-5>
<line-6> dd=[]</line-6>
<line-7> s=1</line-7>
<line-8> for i in range(n-1):</line-8>
<line-9> s=l[i]</line-9>
<line-10> d.append(s)</line-10>
<line-11> dd.append([i,i])</line-11>
<line-12> for j in range(i+1,n):</line-12>
<line-13> s=s*l[j]</line-13>
<line-14> d.append(s)</line-14>
<line-15> dd.append([i,j])</line-15>
<line-16> d.append(l[n-1])</line-16>
<line-17> dd.append([n-1,n-1])</line-17>
<line-18> k=len(d)</line-18>
<line-19> m=max(d)</line-19>
<line-20> x,y=0,0</line-20>
<line-21> for i in range(k):</line-21>
<line-22> if(d[i]==m):</line-22>
<line-24> print(m,*x)</line-24>
|
{"code": "<line-2>for u in range(int(input())):</line-2>\n<line-23> x=dd[i]</line-23>", "lines": [2, 23]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-2> </line-2>
<line-4> while(y): </line-4>
<line-5> x, y = y, x % y </line-5>
<line-6> return x </line-6>
<line-7># t=int(input())</line-7>
<line-8># l=list(map(int,input().split()))</line-8>
<line-9>for _ in range(int(input())):</line-9>
<line-10> n,p=map(int,input().split())</line-10>
<line-11></line-11>
<line-12> c=0</line-12>
<line-13> for i in range(1,n+1):</line-13>
<line-14> if G(i,p)==1:</line-14>
<line-15> c+=1</line-15>
<line-17> print(ans)</line-17>
|
{"code": "<line-3>def G(x, y): </line-3>\n<line-16> ans=c*(c-1)//2</line-16>", "lines": [3, 16]}
#### 0
|
<line-1>test_case = int(input())</line-1>
<line-3> n, k = map(int,input().split())</line-3>
<line-4> l = list(map(str,input().split()))</line-4>
<line-5> ans = []</line-5>
<line-6> for q in range(k):</line-6>
<line-7> l2 = list(map(str,input().split()))</line-7>
<line-8> ans.extend(l2[1:])</line-8>
<line-9> for i in l:</line-9>
<line-10> if i in ans:</line-10>
<line-11> print('YES',end=' ')</line-11>
<line-12> else:</line-12>
<line-14> print()# cook your dish here</line-14>
|
{"code": "<line-2>for w in range(test_case):</line-2>\n<line-13> print('NO',end=' ')</line-13>", "lines": [2, 13]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(number):</line-3>
<line-4> a = list(input())</line-4>
<line-5> for k in range(len(a)):</line-5>
<line-7> print(sum(a))</line-7>
|
{"code": "<line-2>number = int(input())</line-2>\n<line-6> a[k] = eval(a[k])</line-6>", "lines": [2, 6]}
#### 0
|
<line-1></line-1>
<line-2></line-2>
<line-3>vow = ['a', 'e', 'i','o', 'u']</line-3>
<line-5> name = str(input())</line-5>
<line-6> tmp = ''</line-6>
<line-7> for i in range(len(name)):</line-7>
<line-8> if name[i] not in vow and name[i].isalpha():</line-8>
<line-9> tmp+='1'</line-9>
<line-10> elif name[i] in vow and name[i].isalpha():</line-10>
<line-12> </line-12>
<line-13> print( int(tmp, 2)% (10**9 + 7))</line-13>
|
{"code": "<line-4>for _ in range(int(input())):</line-4>\n<line-11> tmp+='0'</line-11>", "lines": [4, 11]}
#### 0
|
<line-1>for t in range(int(input())):</line-1>
<line-3> limakEat = 0; bobEat = 0</line-3>
<line-4> eating = 1</line-4>
<line-5> while limakEat <= limakMax or bobEat <= bobMax:</line-5>
<line-6></line-6>
<line-7> if eating % 2 != 0 and limakEat <= limakMax:</line-7>
<line-8> limakEat += eating</line-8>
<line-9> eating += 1</line-9>
<line-10> if limakEat > limakMax:</line-10>
<line-11> print("Bob")</line-11>
<line-12> break</line-12>
<line-13> elif eating % 2 == 0 and bobEat <= bobMax:</line-13>
<line-14> bobEat += eating</line-14>
<line-15> eating += 1</line-15>
<line-16> if bobEat > bobMax:</line-16>
<line-18> break</line-18>
<line-19></line-19>
|
{"code": "<line-2> limakMax, bobMax = list(map(int, input().split()))</line-2>\n<line-17> print(\"Limak\")</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>def iinput(): return int(input())</line-4>
<line-5>def rinput(): return list(map(int, sys.stdin.readline().strip().split())) </line-5>
<line-6>def get_list(): return list(map(int, sys.stdin.readline().strip().split()))</line-6>
<line-7></line-7>
<line-8></line-8>
<line-9>t=iinput()</line-9>
<line-10></line-10>
<line-11>for _ in range(t):</line-11>
<line-12> n=iinput()</line-12>
<line-13> p=[]</line-13>
<line-14> mi=[]</line-14>
<line-15> for i in range(n):</line-15>
<line-16> x,y=rinput()</line-16>
<line-17> p.append(x+y)</line-17>
<line-18> mi.append(x-y)</line-18>
<line-19></line-19>
<line-20> p.sort()</line-20>
<line-21> mi.sort()</line-21>
<line-22> m=float('inf')</line-22>
<line-23> for i in range(1,n):</line-23>
<line-24> if(p[i]-p[i-1]<m):</line-24>
<line-25> m=p[i]-p[i-1]</line-25>
<line-26> if(mi[i]-mi[i-1]<m):</line-26>
<line-27> m=mi[i]-mi[i-1]</line-27>
<line-28></line-28>
<line-29> if m%2==0:</line-29>
<line-30> print(m//2)</line-30>
<line-32> print(m/2)</line-32>
|
{"code": "<line-3>def input(): return sys.stdin.readline().strip()</line-3>\n<line-31> else:</line-31>", "lines": [3, 31]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> a,k=list(map(int,input().split()))</line-3>
<line-4> x1,x2,x3=list(map(int,input().split()))</line-4>
<line-5> big=max(x1,x2,x3)</line-5>
<line-6> small=min(x1,x2,x3)</line-6>
<line-7> q=big-small-2*k</line-7>
<line-8> </line-8>
<line-9> if q>=a:</line-9>
<line-10> print(0)</line-10>
<line-11> elif -1*q>=0:</line-11>
<line-12> print(a*a)</line-12>
<line-14> print(a*(a-q))</line-14>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-13> else:</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>#</line-1>
<line-2></line-2>
<line-4> n,k = list(map(int,input().split()))</line-4>
<line-5> arr = list(map(int,input().split()))</line-5>
<line-6> s=set(arr)</line-6>
<line-7> t1=len(s)</line-7>
<line-8> max=-1</line-8>
<line-9> for i in range(n-k+1):</line-9>
<line-10> temp=set(arr[i:i+k])</line-10>
<line-11> #print(temp,i,k+i+1)</line-11>
<line-12> t=len(temp)</line-12>
<line-13> if t1 == t:</line-13>
<line-14> if max<sum(arr[i:k+i]):</line-14>
<line-16> print(max)</line-16>
|
{"code": "<line-3>for _ in range(int(input())):</line-3>\n<line-15> max=sum(arr[i:k+i])</line-15>", "lines": [3, 15]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for j in range(t):</line-3>
<line-4> s=input()</line-4>
<line-5> st=[]</line-5>
<line-6> ans=0</line-6>
<line-7></line-7>
<line-8> for i in range(len(s)):</line-8>
<line-9> </line-9>
<line-10> if(s[i]=='>'):</line-10>
<line-11> if(len(st)!=0 and st[-1]=='<'):</line-11>
<line-12> st.pop()</line-12>
<line-13> if(len(st)==0):</line-13>
<line-14> ans=i+1</line-14>
<line-15> else:</line-15>
<line-16> break</line-16>
<line-17></line-17>
<line-18> else:</line-18>
<line-20></line-20>
<line-21> print(ans)</line-21>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-19> st.append('<')</line-19>", "lines": [2, 19]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(0,t):</line-3>
<line-4> my_ip = int(input().strip())</line-4>
<line-5> for xyz in range(my_ip+1):</line-5>
<line-6> for abc in range(0,xyz+1):</line-6>
<line-7> if abc == xyz:</line-7>
<line-8> print(xyz,end="")</line-8>
<line-9> else:</line-9>
<line-11></line-11>
<line-12> print()</line-12>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-10> print('*',end=\"\")</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>from collections import deque </line-1>
<line-3>def break_down(num):</line-3>
<line-4> count=0</line-4>
<line-5> while(len(num)!=1):</line-5>
<line-6> temp=0</line-6>
<line-7> for i in range(0,len(num)):</line-7>
<line-8> temp=temp+int(num[i])</line-8>
<line-9> num=str(temp)</line-9>
<line-10> count=count+1</line-10>
<line-11> return (int(num),count)</line-11>
<line-12>def digit_sum(num):</line-12>
<line-13> temp=0</line-13>
<line-14> for i in range(0,len(num)):</line-14>
<line-15> temp=temp+int(num[i])</line-15>
<line-16> num=temp</line-16>
<line-17> return (num)</line-17>
<line-18>while(T):</line-18>
<line-19> queue=deque()</line-19>
<line-20> count_n=0</line-20>
<line-21> count_d=0</line-21>
<line-22> T=T-1</line-22>
<line-23> N,d=[i for i in input().split()]</line-23>
<line-24> n,count_n=break_down(N)</line-24>
<line-25> D,count_D=break_down(d)</line-25>
<line-26> dic={}</line-26>
<line-27> if(D==1 or D==2 or D==4 or D==5 or D==7 or D==8):</line-27>
<line-28> mini=1 </line-28>
<line-29> elif(D==3 or D==6):</line-29>
<line-30> mini=min(digit_sum(str(n+3)),digit_sum(str(n+6)),digit_sum(str(n+9)))</line-30>
<line-31> else:</line-31>
<line-32> mini=n</line-32>
<line-33> queue.append((int(N),0))</line-33>
<line-34> ele=int(N)</line-34>
<line-35> count=0</line-35>
<line-36> while(len(queue)!=0):</line-36>
<line-37> ele,count=queue.popleft()</line-37>
<line-38> if(ele==mini):</line-38>
<line-39> break</line-39>
<line-40> else:</line-40>
<line-41> if(len(str(ele))==1):</line-41>
<line-42> temp1=ele+int(d)</line-42>
<line-43> queue.append((temp1,count+1))</line-43>
<line-44> else:</line-44>
<line-45> temp2=digit_sum(str(ele))</line-45>
<line-46> temp1=ele+int(d)</line-46>
<line-47> queue.append((temp2,count+1))</line-47>
<line-49> print(ele,count)</line-49>
|
{"code": "<line-2>T=int(input())</line-2>\n<line-48> queue.append((temp1,count+1))</line-48>", "lines": [2, 48]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n=int(input())</line-3>
<line-4> A=list(map(int,input().split()))</line-4>
<line-5> A.sort()</line-5>
<line-6> for i in range(len(A)):</line-6>
<line-7> if A[i]==1:</line-7>
<line-9> break</line-9>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-8> print(i)</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>test=int(input())</line-1>
<line-3> s=input()</line-3>
<line-4> b=len(s)</line-4>
<line-5> list1=[]</line-5>
<line-6> for j in range(len(s)):</line-6>
<line-7> if s[j]=='.':</line-7>
<line-8> list1.append(j)</line-8>
<line-9> for i in list1:</line-9>
<line-10> if b-i-1 in list1 :</line-10>
<line-11> if i!=b-i-1 and ((s[i] and s[b-i-1]) != 'a' ):</line-11>
<line-12> s=s[:i]+'a'+s[i+1:b-i-1]+'a'+s[b-i:]</line-12>
<line-13> else:</line-13>
<line-14> s=s[:i]+'a'+s[i+1:]</line-14>
<line-15> else:</line-15>
<line-16> s=s[:i]+s[b-i-1]+s[i+1:]</line-16>
<line-17></line-17>
<line-18> if s==s[::-1]:</line-18>
<line-19> print(s)</line-19>
<line-21> print(-1)</line-21>
<line-22></line-22>
<line-23> </line-23>
|
{"code": "<line-2>for i in range(test):</line-2>\n<line-20> else:</line-20>", "lines": [2, 20]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>arr=list(map(int,input().split()))</line-3>
<line-4>arr=sorted(arr,reverse=True)</line-4>
<line-5>ans=0</line-5>
<line-6>w=0</line-6>
<line-7>q=m</line-7>
<line-8>for m in range(q):</line-8>
<line-9> if(arr[m]>n):</line-9>
<line-10> w=1</line-10>
<line-11> break </line-11>
<line-12> ans+=1+(arr[m]*(arr[m]+1))//2</line-12>
<line-13> n-=arr[m]</line-13>
<line-14></line-14>
<line-15>if(n==0):</line-15>
<line-16> print(ans)</line-16>
<line-17>else:</line-17>
<line-18> if(w==1):</line-18>
<line-19> print(ans+q-m+(n*(n+1))//2)</line-19>
<line-21> print(ans)</line-21>
|
{"code": "<line-2>m,n=[int(i) for i in input().split()]</line-2>\n<line-20> else:</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3> a,b,c=map(int,input().split())</line-3>
<line-4> if a>0 and b>0 and c>0 and a+b+c==180:</line-4>
<line-5> print("YES")</line-5>
<line-7> print("NO")</line-7>
|
{"code": "<line-2>for i in range(n):</line-2>\n<line-6> else:</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>import math</line-1>
<line-2></line-2>
<line-4> m=a%10</line-4>
<line-5> if(m==4):</line-5>
<line-6> return a+3</line-6>
<line-7> elif(m==7):</line-7>
<line-8> p=list(str(a))</line-8>
<line-9> #print p</line-9>
<line-10> for i in range(digits-1,-1,-1):</line-10>
<line-11> #print p[i]</line-11>
<line-12> if (p[i]=='4'):</line-12>
<line-13> #print 'four'</line-13>
<line-14> p[i]='7'</line-14>
<line-15> p = ''.join(str(n) for n in p)</line-15>
<line-16> return int(p)</line-16>
<line-17> if ((p[i]=='7')&(i==0)):</line-17>
<line-18> #print 'seven'</line-18>
<line-19> p[i]='4'</line-19>
<line-20> p.insert(0,4)</line-20>
<line-21> p = ''.join(str(n) for n in p)</line-21>
<line-22> return int(p)</line-22>
<line-23></line-23>
<line-24> if(p[i]=='7'):</line-24>
<line-25> #print 'seven only'</line-25>
<line-26> p[i]='4'</line-26>
<line-27> </line-27>
<line-28> #print p[i]</line-28>
<line-29> </line-29>
<line-30> </line-30>
<line-31> </line-31>
<line-32></line-32>
<line-33>t=eval(input())</line-33>
<line-34></line-34>
<line-35>n=[]</line-35>
<line-36>op=[]</line-36>
<line-37></line-37>
<line-38>for i in range(0,t):</line-38>
<line-39> n.append(eval(input()))</line-39>
<line-40></line-40>
<line-41>for i in range(0,t):</line-41>
<line-42> digits = int(math.log10(n[i]))+1</line-42>
<line-43> #print digits</line-43>
<line-44> op.append(magic(n[i],digits))</line-44>
<line-45> </line-45>
<line-46>#for i in range(0,t):</line-46>
<line-47> #print n[i]</line-47>
<line-48></line-48>
<line-50> print(op[i])</line-50>
<line-51></line-51>
<line-52></line-52>
<line-53></line-53>
<line-54> </line-54>
|
{"code": "<line-3>def magic(a,digits):</line-3>\n<line-49>for i in range(0,t):</line-49>", "lines": [3, 49]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(0,t):</line-3>
<line-4> p=input()</line-4>
<line-5> l=list(p)</line-5>
<line-6> for j in range(0,len(l)):</line-6>
<line-7> l[j]=int(l[j])</line-7>
<line-8> l[j]=l[j]-2</line-8>
<line-9> for j in range(0,len(l)):</line-9>
<line-10> l[j]=str(l[j])</line-10>
<line-12> print(q)</line-12>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-11> q=''.join(l)</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>for i in range(n):</line-3>
<line-4> a.append(int(input()))</line-4>
<line-5>m1 = 0</line-5>
<line-6>m2 = 0</line-6>
<line-7>for e in a:</line-7>
<line-8> if (e > m1):</line-8>
<line-9> m2 = m1</line-9>
<line-10> m1 = e</line-10>
<line-11> elif (e > m2 and e != m1):</line-11>
<line-12> m2 = e</line-12>
<line-13>ans = 0</line-13>
<line-14>for e in a:</line-14>
<line-15> temp = m1%e</line-15>
<line-16> if (temp>ans):</line-16>
<line-18>print(max(m2%m1,ans))</line-18>
|
{"code": "<line-2>a = []</line-2>\n<line-17> ans = temp</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>def countSubstr(str, n, x, y): </line-1>
<line-2> </line-2>
<line-4> </line-4>
<line-5> count_x = 0</line-5>
<line-6> </line-6>
<line-7> for i in range(n): </line-7>
<line-8> if str[i] == x: </line-8>
<line-9> count_x += 1</line-9>
<line-10> if str[i] == y: </line-10>
<line-11> tot_count += count_x </line-11>
<line-12> return tot_count </line-12>
<line-13> </line-13>
<line-14>t=int(input())</line-14>
<line-15>for _ in range(t):</line-15>
<line-16> n=int(input())</line-16>
<line-17> str=input()</line-17>
<line-18> x='0'</line-18>
<line-19> y='1'</line-19>
<line-20> x1='1'</line-20>
<line-21> y1='0'</line-21>
<line-22> c1=countSubstr(str,n,x,y)</line-22>
<line-24> print(c1+c2)</line-24>
|
{"code": "<line-3> tot_count = 0</line-3>\n<line-23> c2=countSubstr(str,n,x1,y1)</line-23>", "lines": [3, 23]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> if(c == '&'):</line-3>
<line-4> return a&b</line-4>
<line-5> elif(c == '^'):</line-5>
<line-6> return a^b</line-6>
<line-7> elif(c == '|'):</line-7>
<line-8> return a|b</line-8>
<line-9></line-9>
<line-10>def break_rules(n, operator):</line-10>
<line-11> if(len(n) == 1):</line-11>
<line-12> return n</line-12>
<line-13> elif(len(n) == 2):</line-13>
<line-14> return [value(n[0], n[1], operator[0])]</line-14>
<line-15> else:</line-15>
<line-16> cont_ans = []</line-16>
<line-17> for i in range(1,len(n)):</line-17>
<line-18> l1 = n[:i]</line-18>
<line-19> l2 = n[i:]</line-19>
<line-20> o1 = operator[:i]</line-20>
<line-21> o2 = operator[i:]</line-21>
<line-22> l1_ans = break_rules(l1, o1)</line-22>
<line-23> l2_ans = break_rules(l2, o2)</line-23>
<line-24> for k in l1_ans:</line-24>
<line-25> for j in l2_ans:</line-25>
<line-26> cont_ans.append(value(k, j, operator[i - 1]))</line-26>
<line-27> return cont_ans</line-27>
<line-28></line-28>
<line-29>t = int(input())</line-29>
<line-30>while t > 0 :</line-30>
<line-31> operator = []</line-31>
<line-32> num = []</line-32>
<line-33> exp = input()</line-33>
<line-34> temp = ''</line-34>
<line-35> for i in range(len(exp)):</line-35>
<line-36> if(ord(exp[i]) > 47 and ord(exp[i]) < 58):</line-36>
<line-37> temp = temp + exp[i]</line-37>
<line-38> else:</line-38>
<line-39> num.append(int(temp))</line-39>
<line-40> temp = ''</line-40>
<line-41> operator.append(exp[i])</line-41>
<line-42> if(i == len(exp) - 1):</line-42>
<line-43> num.append(int(temp))</line-43>
<line-44> t -= 1</line-44>
<line-46> print(max(break_rules(num, operator)))</line-46>
|
{"code": "<line-2>def value(a, b, c):</line-2>\n<line-45> # print(num,operator)</line-45>", "lines": [2, 45]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> m = list(map(int, input().strip().split(" ")))</line-3>
<line-4> if l:</line-4>
<line-5> return list(m)</line-5>
<line-6> else:</line-6>
<line-7> return m</line-7>
<line-8>def i():</line-8>
<line-9> return int(input().strip())</line-9>
<line-10>T = i()</line-10>
<line-11>L = []</line-11>
<line-12>"""for current in range(T):</line-12>
<line-13> line = ""</line-13>
<line-14> for i in range(current):</line-14>
<line-15> line+=str((T-i)%10)</line-15>
<line-16> for i in range(2*(T-current)-1):</line-16>
<line-17> line+=str((T-current)%10)</line-17>
<line-18> for i in range(current-1,-1,-1):</line-18>
<line-19> line+=str((T-i)%10)</line-19>
<line-20> L.append(line)</line-20>
<line-21>L += L[-2::-1]"""</line-21>
<line-22></line-22>
<line-23>if T >= 1:</line-23>
<line-24> L = ["1"]</line-24>
<line-25></line-25>
<line-26>for i in range(2,T+1):</line-26>
<line-27> nL = [str(i)+(2*i-2)*(" "+str(i))]</line-27>
<line-28> for l in L:</line-28>
<line-29> nL.append(str(i)+" "+l+" "+str(i))</line-29>
<line-30> nL.append(str(i)+(2*i-2)*(" "+str(i)))</line-30>
<line-31> L = nL</line-31>
<line-33> print(l)</line-33>
|
{"code": "<line-2>def read_i_l(l=False):</line-2>\n<line-32>for l in L:</line-32>", "lines": [2, 32]}
#### 0
|
<line-2>for i in range(number):</line-2>
<line-3> x = list(map(int, input().split(' ')))</line-3>
<line-4> print(x[0]%x[1])</line-4>
|
{"code": "<line-1>number = int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>from math import gcd</line-1>
<line-3>input=lambda : sys.stdin.readline().strip()</line-3>
<line-4>c=lambda x: 10**9 if(x=="?") else int(x)</line-4>
<line-5>def main():</line-5>
<line-6> for _ in range(int(input())):</line-6>
<line-7> s=list(input())[::-1]</line-7>
<line-8> l=['F','E','H','C']</line-8>
<line-9> i=0</line-9>
<line-10> while(i<len(s)):</line-10>
<line-11> if(i+3<len(s)):</line-11>
<line-12> f=True</line-12>
<line-13> for j in range(i,i+4):</line-13>
<line-14> if(l[j-i]==s[j] or s[j]=='?'):</line-14>
<line-15> pass</line-15>
<line-16> else:</line-16>
<line-17> f=False</line-17>
<line-18> break</line-18>
<line-19> if(f):</line-19>
<line-20> for j in range(i,i+4):</line-20>
<line-21> s[j]=l[j-i]</line-21>
<line-22> if(s[i]=="?"):</line-22>
<line-23> s[i]='A'</line-23>
<line-24> else:</line-24>
<line-25> if(s[i]=="?"):</line-25>
<line-26> s[i]="A"</line-26>
<line-27> i+=1</line-27>
<line-29></line-29>
<line-30> </line-30>
<line-31></line-31>
<line-32>main()</line-32>
|
{"code": "<line-2>import sys</line-2>\n<line-28> print(*s[::-1],sep='')</line-28>", "lines": [2, 28]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> N,M=map(int,input().split())</line-3>
<line-4> b=[]</line-4>
<line-5> for o in range(N):</line-5>
<line-6> b.append(input())</line-6>
<line-7> c=[]</line-7>
<line-8> for d in b:</line-8>
<line-9> f=[]</line-9>
<line-10> for e in range(len(d)):</line-10>
<line-11> if d[e]=='1':</line-11>
<line-12> f.append(e)</line-12>
<line-13> c.append(f)</line-13>
<line-14> i=[]</line-14>
<line-15> for g in range(len(c)):</line-15>
<line-16> for h in range(len(c[g])):</line-16>
<line-17> for j in range(len(c)):</line-17>
<line-18> for k in range(len(c[j])):</line-18>
<line-19> if (j>g) or(j==g and k>h):</line-19>
<line-20> if c[g][h]-c[j][k]>=0:</line-20>
<line-21> i.append(c[g][h]-c[j][k]+j-g)</line-21>
<line-22> else:</line-22>
<line-23> i.append(-1*(c[g][h]-c[j][k])+j-g)</line-23>
<line-24> l=[m for m in range(1,N+M-1)]</line-24>
<line-26> print(i.count(n),end=' ')</line-26>
|
{"code": "<line-2>for a in range(int(input())):</line-2>\n<line-25> for n in l:</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> n=[ele for ele in n]</line-3>
<line-4> l=len(n)</line-4>
<line-5> m=10**18+8</line-5>
<line-6> ini=1</line-6>
<line-7> for i in range(l-1,-1,-1):</line-7>
<line-8> if int(n[i])<=m:</line-8>
<line-9> if ini==1:</line-9>
<line-10> m=int(n[i])</line-10>
<line-11> else:</line-11>
<line-12> m=max(m,n[i])</line-12>
<line-13> else:</line-13>
<line-14> m=int(n[i])-1</line-14>
<line-15> n[i]=str(m)</line-15>
<line-16> for j in range(l-1,i,-1):</line-16>
<line-17> n[j]='9'</line-17>
<line-18> </line-18>
<line-19> i=0</line-19>
<line-20> while n[i]=='0':</line-20>
<line-22> print("".join(n[i:]))</line-22>
<line-23> </line-23>
|
{"code": "<line-2> n=input().rstrip()</line-2>\n<line-21> i+=1</line-21>", "lines": [2, 21]}
#### 0
|
<line-1># Fibonacci Series using </line-1>
<line-3></line-3>
<line-4># function that returns nth </line-4>
<line-5># Fibonacci number</line-5>
<line-6>MOD = 1000000007</line-6>
<line-7>def fib(n):</line-7>
<line-8> F = [[2, 2],</line-8>
<line-9> [1, 0]]</line-9>
<line-10> power(F, n - 1)</line-10>
<line-11> ans = [6, 2]</line-11>
<line-12> return (F[0][0] * 6 + F[0][1] * 2) % MOD</line-12>
<line-13> # return F[0][0]</line-13>
<line-14></line-14>
<line-15></line-15>
<line-16>def multiply(F, M):</line-16>
<line-17> x = (F[0][0] * M[0][0] +</line-17>
<line-18> F[0][1] * M[1][0]) % MOD</line-18>
<line-19> y = (F[0][0] * M[0][1] +</line-19>
<line-20> F[0][1] * M[1][1]) % MOD</line-20>
<line-21> z = (F[1][0] * M[0][0] +</line-21>
<line-22> F[1][1] * M[1][0]) % MOD</line-22>
<line-23> w = (F[1][0] * M[0][1] +</line-23>
<line-24> F[1][1] * M[1][1]) % MOD</line-24>
<line-25></line-25>
<line-26> F[0][0] = x</line-26>
<line-27> F[0][1] = y</line-27>
<line-28> F[1][0] = z</line-28>
<line-29> F[1][1] = w</line-29>
<line-30></line-30>
<line-31></line-31>
<line-32>def power(F, n):</line-32>
<line-33> if n == 0 or n == 1:</line-33>
<line-34> return</line-34>
<line-35> M = [[2, 2],</line-35>
<line-36> [1, 0]]</line-36>
<line-37></line-37>
<line-38> power(F, n // 2)</line-38>
<line-39> multiply(F, F)</line-39>
<line-40></line-40>
<line-41> if n % 2 != 0:</line-41>
<line-42> multiply(F, M)</line-42>
<line-43></line-43>
<line-44></line-44>
<line-45>for _ in range(int(input())):</line-45>
<line-46> n = int(input())</line-46>
<line-47> ans = 1</line-47>
<line-48> if n == 0:</line-48>
<line-49> ans = 1</line-49>
<line-50> elif n == 1:</line-50>
<line-51> ans = 2</line-51>
<line-52> elif n == 2:</line-52>
<line-53> ans = 6</line-53>
<line-54> else:</line-54>
<line-56> print(ans)</line-56>
|
{"code": "<line-2># Optimized Method </line-2>\n<line-55> ans = fib(n-1)</line-55>", "lines": [2, 55]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(t):</line-3>
<line-4> N, M=map(int,input().split())</line-4>
<line-5> if(N%2==0 or M%2==0):</line-5>
<line-6> print("YES")</line-6>
<line-8> print("NO")</line-8>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-7> else:</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>#Note that it's python3 Code. Here, we are using input() instead of raw_input().</line-1>
<line-3></line-3>
<line-4>#Read the number of test cases.</line-4>
<line-5>T = int(input())</line-5>
<line-6>for tc in range(T):</line-6>
<line-7> # Read integers a and b.</line-7>
<line-8> (a, b) = list(map(int, input().split(' ')))</line-8>
<line-9> </line-9>
<line-11> print(ans)</line-11>
|
{"code": "<line-2>#You can check on your local machine the version of python by typing \"python --version\" in the terminal.</line-2>\n<line-10>\tans = a + b</line-10>", "lines": [2, 10]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>class Animal:</line-3>
<line-4> def __init__(self):</line-4>
<line-5> start, end, starting_time = map(int, input().split())</line-5>
<line-6> </line-6>
<line-7> self.ending_time = starting_time + abs(start - end)</line-7>
<line-8> self.velocity = 1 if end >= start else -1 </line-8>
<line-9> </line-9>
<line-10> self.eaten_by = -1, 10 ** 10</line-10>
<line-11> </line-11>
<line-12> self.start = start </line-12>
<line-13> self.end = end </line-13>
<line-14> self.starting_time = starting_time </line-14>
<line-15> </line-15>
<line-16> def will_collide(self, z):</line-16>
<line-17> if self.starting_time > z.ending_time or self.ending_time < z.starting_time:</line-17>
<line-18> return False </line-18>
<line-19> </line-19>
<line-20> if self.velocity == z.velocity:</line-20>
<line-21> if self.starting_time > z.starting_time:</line-21>
<line-22> self, z = z, self</line-22>
<line-23> if z.start == self.start + self.velocity * (z.starting_time - self.starting_time):</line-23>
<line-24> return z.starting_time</line-24>
<line-25> else:</line-25>
<line-26> return False</line-26>
<line-27> </line-27>
<line-28> if self.velocity == -1:</line-28>
<line-29> self, z = z, self</line-29>
<line-30> </line-30>
<line-31> t = ( z.start - self.start + z.starting_time + self.starting_time ) / 2 </line-31>
<line-32> </line-32>
<line-33> return t if self.starting_time <= t <= self.ending_time and z.starting_time <= t <= z.ending_time else False</line-33>
<line-34> </line-34>
<line-35> </line-35>
<line-36> </line-36>
<line-37>def main():</line-37>
<line-38> for _ in range(int(input())):</line-38>
<line-39> no_cats, no_rats = map(int, input().split())</line-39>
<line-40> </line-40>
<line-41> Cats = [Animal() for i in range(no_cats)]</line-41>
<line-42> </line-42>
<line-43> for i in range(no_rats):</line-43>
<line-44> rat = Animal() </line-44>
<line-45> for j in range(no_cats):</line-45>
<line-46> time = rat.will_collide(Cats[j])</line-46>
<line-47> if time:</line-47>
<line-48> # print(time)</line-48>
<line-49> if time < rat.eaten_by[1]:</line-49>
<line-50> rat.eaten_by = j + 1, time </line-50>
<line-51> </line-51>
<line-52> </line-52>
<line-54> </line-54>
<line-55> </line-55>
<line-56> </line-56>
<line-57>main()</line-57>
<line-58> </line-58>
|
{"code": "<line-2># cook your dish here</line-2>\n<line-53> print(rat.eaten_by[0])</line-53>", "lines": [2, 53]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>while t>0:</line-3>
<line-4> n,q=list(map(int,input().split()))</line-4>
<line-5> blst=[0]</line-5>
<line-6> for i in range(1,65):</line-6>
<line-7> blst.append(0)</line-7>
<line-8> i=1</line-8>
<line-9> while n>0:</line-9>
<line-10> if n%2:</line-10>
<line-11> blst[i]=1</line-11>
<line-12> n//=2</line-12>
<line-13> i+=1</line-13>
<line-14> while q>0:</line-14>
<line-15> n=int(input())</line-15>
<line-16> if n==1:</line-16>
<line-17> p=int(input())</line-17>
<line-18> if blst[p]:</line-18>
<line-19> print('ON')</line-19>
<line-20> else:</line-20>
<line-21> print('OFF')</line-21>
<line-22> elif n==2:</line-22>
<line-23> p=int(input())</line-23>
<line-24> if blst[p]==0:</line-24>
<line-25> blst[p]=1</line-25>
<line-26> elif n==3:</line-26>
<line-27> p=int(input())</line-27>
<line-28> if blst[p]==1:</line-28>
<line-29> blst[p]=0</line-29>
<line-30> else:</line-30>
<line-31> p,r=list(map(int,input().split()))</line-31>
<line-32> if blst[p]!=blst[r]:</line-32>
<line-33> blst[p]+=1</line-33>
<line-34> blst[p]%=2</line-34>
<line-35> blst[r]+=1</line-35>
<line-36> blst[r]%=2</line-36>
<line-38> t-=1</line-38>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-37> q-=1</line-37>", "lines": [2, 37]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n=int(input())</line-3>
<line-4> r=int(n**(.5))</line-4>
<line-5> d=n-r*r</line-5>
<line-7> print('X'*m+'D'*(m>0)+'X'*(r-m)+'D'*(r+d//r))</line-7>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-6> m=d%r</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>import sys</line-1>
<line-3>def fout(s, end="\n"): sys.stdout.write(str(s)+end)</line-3>
<line-4></line-4>
<line-5>MOD = pow(10, 9)+7</line-5>
<line-6>t = int(input())</line-6>
<line-7>while t>0:</line-7>
<line-8> t -= 1</line-8>
<line-9> n, m = list(map(int, fin().split()))</line-9>
<line-10> if n == 1:</line-10>
<line-11> print(m%MOD)</line-11>
<line-12> continue</line-12>
<line-13> dp1 = m*(m-1)</line-13>
<line-14> dp2 = m</line-14>
<line-15> for i in range(3, n+1):</line-15>
<line-16> temp = dp2</line-16>
<line-17> dp2 = dp1 </line-17>
<line-19> print((dp1+dp2)%MOD)</line-19>
<line-20></line-20>
<line-21> </line-21>
<line-22></line-22>
|
{"code": "<line-2>def fin(): return sys.stdin.readline().strip()</line-2>\n<line-18> dp1 = (temp*(m-1))%MOD+(dp1*(m-1))%MOD</line-18>", "lines": [2, 18]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>j=0</line-3>
<line-4>while j<t:</line-4>
<line-5> n=int(input())</line-5>
<line-6> lst=list(map(int,input().split()))</line-6>
<line-7> s=set()</line-7>
<line-8> d=list()</line-8>
<line-9> for i in lst:</line-9>
<line-10> if i in s:</line-10>
<line-11> s.remove(i)</line-11>
<line-12> d.append(i)</line-12>
<line-13> else:</line-13>
<line-14> s.add(i)</line-14>
<line-15> x=len(d)</line-15>
<line-16> if x%2==0:</line-16>
<line-17> print(x//2)</line-17>
<line-18> else:</line-18>
<line-20> j+=1</line-20>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-19> print((x-1)//2)</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>gb = [0, 1, 2, 2, 3, 3]</line-1>
<line-3>gag = [0 for x in range(70)]</line-3>
<line-4>ga[0] = 1</line-4>
<line-5>gag[0] = 0</line-5>
<line-6></line-6>
<line-7>for i in range(1, 70):</line-7>
<line-8> if i % 4 == 0:</line-8>
<line-9> ga[i] = 1.5 * ga[i-1]</line-9>
<line-10> gag[i] = 0</line-10>
<line-11> else:</line-11>
<line-12> ga[i] = 2 * ga[i-1]</line-12>
<line-13> gag[i] = gag[i-1] + 1</line-13>
<line-14></line-14>
<line-15></line-15>
<line-16>def g(n):</line-16>
<line-17> if n < 6:</line-17>
<line-18> return gb[n]</line-18>
<line-19> else:</line-19>
<line-20> x = n / 6</line-20>
<line-21> a = 0</line-21>
<line-22> for i, k in enumerate(ga):</line-22>
<line-23> if k <= x:</line-23>
<line-24> a = i</line-24>
<line-25> else:</line-25>
<line-26> break</line-26>
<line-27> return gag[a]</line-27>
<line-28></line-28>
<line-29></line-29>
<line-30>t = int(input())</line-30>
<line-31>for q in range(t):</line-31>
<line-32> n = int(input())</line-32>
<line-33> a = list(map(int, input().split()))</line-33>
<line-34></line-34>
<line-35> res = g(a[0])</line-35>
<line-36> for i in range(1, n):</line-36>
<line-37> res ^= g(a[i])</line-37>
<line-38></line-38>
<line-39> if res == 0:</line-39>
<line-40> print("Derek")</line-40>
<line-42> print("Henry")</line-42>
|
{"code": "<line-2>ga = [0 for x in range(70)]</line-2>\n<line-41> else:</line-41>", "lines": [2, 41]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> def __init__(self):</line-3>
<line-4> [self.node_count, self.query_count] = read_line()</line-4>
<line-5> </line-5>
<line-6> def fill_nodes(self):</line-6>
<line-7> self.nodes = {n+1: [] for n in range(self.node_count)}</line-7>
<line-8> for i in range(self.node_count -1):</line-8>
<line-9> new_node_1, new_node_2 = read_line()</line-9>
<line-10> self.nodes[new_node_1].append(new_node_2)</line-10>
<line-11> self.nodes[new_node_2].append(new_node_1)</line-11>
<line-12> </line-12>
<line-13> def resolve_query(self, query):</line-13>
<line-14> a, d_a, b, d_b = query</line-14>
<line-15> suiting_a = self.find_nodes_with_distance(a, d_a)</line-15>
<line-16> suiting_b = self.find_nodes_with_distance(b, d_b)</line-16>
<line-17> fitting = [node for node in suiting_a if node in suiting_b]</line-17>
<line-18> </line-18>
<line-19> if len(fitting) == 0:</line-19>
<line-20> return -1</line-20>
<line-21> else:</line-21>
<line-22> return fitting[0]</line-22>
<line-23> </line-23>
<line-24> def find_nodes_with_distance(self, start_node, distance):</line-24>
<line-25> from_nodes = {start_node}</line-25>
<line-26> passed_nodes = from_nodes</line-26>
<line-27> </line-27>
<line-28> for i in range(distance):</line-28>
<line-29> to_nodes = set()</line-29>
<line-30> # add all adjacent nodes</line-30>
<line-31> for node in from_nodes:</line-31>
<line-32> to_nodes.update(self.nodes[node])</line-32>
<line-33> </line-33>
<line-34> # no backtracking</line-34>
<line-35> for node in passed_nodes:</line-35>
<line-36> if node in to_nodes:</line-36>
<line-37> to_nodes.remove(node)</line-37>
<line-38> </line-38>
<line-39> # update which nodes are passed</line-39>
<line-40> passed_nodes.update(to_nodes)</line-40>
<line-41> # go another round with the new nodes found</line-41>
<line-42> from_nodes = to_nodes</line-42>
<line-43> return list(from_nodes)</line-43>
<line-44></line-44>
<line-45>def read_line():</line-45>
<line-46> line = input()</line-46>
<line-47> return [int(s) for s in line.split(' ')]</line-47>
<line-48></line-48>
<line-49>num_testcases = int(input())</line-49>
<line-50>for i in range(num_testcases):</line-50>
<line-51> testcase = TestCase()</line-51>
<line-52> testcase.fill_nodes()</line-52>
<line-53> for q in range(testcase.query_count):</line-53>
<line-55> print(testcase.resolve_query(query))</line-55>
|
{"code": "<line-2>class TestCase:</line-2>\n<line-54> query = read_line()</line-54>", "lines": [2, 54]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> n = int(input())</line-4>
<line-5> dir = []</line-5>
<line-6> </line-6>
<line-7> for j in range(n):</line-7>
<line-8> dir.append(input().strip().split())</line-8>
<line-9> </line-9>
<line-10> for j in range(n-1):</line-10>
<line-11> if dir[j+1][0] == 'Right':</line-11>
<line-12> dir[j][0] = 'Left'</line-12>
<line-13> else:</line-13>
<line-14> dir[j][0] = 'Right'</line-14>
<line-15></line-15>
<line-16> dir[n-1][0] = 'Begin'</line-16>
<line-17></line-17>
<line-19> print(' '.join(j))</line-19>
<line-20></line-20>
<line-21></line-21>
<line-22> </line-22>
|
{"code": "<line-3>for i in range(t):</line-3>\n<line-18> for j in reversed(dir):</line-18>", "lines": [3, 18]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n,w1,w2,w3=map(int,input().split())</line-3>
<line-4> if n>=w1+w2+w3:</line-4>
<line-5> print(1)</line-5>
<line-6> elif n>=w1+w2 or n>=w2+w3:</line-6>
<line-7> print(2)</line-7>
<line-9> print(3)</line-9>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-8> else:</line-8>", "lines": [2, 8]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(x):</line-3>
<line-5> print(h.count('4'))</line-5>
|
{"code": "<line-2>x=int(input())</line-2>\n<line-4> h=input()</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>def res(s):</line-1>
<line-3> if s[0] == s[1]:</line-3>
<line-4> print("NO")</line-4>
<line-5> else:</line-5>
<line-6> print("YES")</line-6>
<line-7></line-7>
<line-8> elif s[0] != s[1]:</line-8>
<line-9> counte = 0</line-9>
<line-10> for i in range(2, len(s)):</line-10>
<line-11> if i % 2 == 0:</line-11>
<line-12> if s[i] != s[0]:</line-12>
<line-13> counte = 1</line-13>
<line-14> break</line-14>
<line-15> else:</line-15>
<line-16> if s[i] != s[1]:</line-16>
<line-17> counte = 1</line-17>
<line-18> break</line-18>
<line-19></line-19>
<line-20> if counte == 0:</line-20>
<line-21> print("YES")</line-21>
<line-22> else:</line-22>
<line-23> print("NO")</line-23>
<line-24> else:</line-24>
<line-25> print("NO")</line-25>
<line-26></line-26>
<line-27></line-27>
<line-28>def __starting_point():</line-28>
<line-29> t = int(input())</line-29>
<line-30> for _ in range(t):</line-30>
<line-31> stri = str(input())</line-31>
<line-33>__starting_point()</line-33>
|
{"code": "<line-2> if len(s) == 2:</line-2>\n<line-32> res(stri)</line-32>", "lines": [2, 32]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>from collections import OrderedDict</line-3>
<line-4>from itertools import zip_longest</line-4>
<line-5>dic = OrderedDict(zip(string.ascii_uppercase, range(0, 26)))</line-5>
<line-6>keys = [98, 57, 31, 45, 46]</line-6>
<line-7>t = int(input()) # number of test cases</line-7>
<line-8>s1 = []</line-8>
<line-9>for i in range(t):</line-9>
<line-10> s = input()</line-10>
<line-11> for i in s:</line-11>
<line-12> if i in dic.keys():</line-12>
<line-13> s1.append(int(i.replace(i, str(dic[i]))))</line-13>
<line-14> s2 = [sum(t) for t in zip_longest(s1, keys, fillvalue=0)]</line-14>
<line-15> inv_dic = {v:k for k,v in dic.items()}</line-15>
<line-16> s_1 = list()</line-16>
<line-17> for i in range(len(s1)):</line-17>
<line-18> s_1.append(s2[i]%26)</line-18>
<line-19> res= [inv_dic[i] for i in s_1]</line-19>
<line-20> print(''.join(res))</line-20>
<line-21> inv_dic.clear()</line-21>
<line-22> res.clear()</line-22>
<line-23> s1.clear()</line-23>
<line-25> s_1.clear()</line-25>
|
{"code": "<line-2>import string </line-2>\n<line-24> s2.clear()</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>counter = -1</line-1>
<line-3> nonlocal counter</line-3>
<line-4> if visited[node]==1:</line-4>
<line-5> return</line-5>
<line-6> else:</line-6>
<line-7> visited[node]=1</line-7>
<line-8> counter += 1</line-8>
<line-9> i_c[node] = counter</line-9>
<line-10></line-10>
<line-11> flat_tree[counter] = swt[node]</line-11>
<line-12></line-12>
<line-13> for i in graph[node]:</line-13>
<line-14> if visited[i]==0:</line-14>
<line-15> flattree(i)</line-15>
<line-16> counter += 1</line-16>
<line-17> o_c[node] = counter</line-17>
<line-18> flat_tree[counter] = -swt[node]</line-18>
<line-19> return</line-19>
<line-20></line-20>
<line-21></line-21>
<line-22>def getsum(BITTree, i):</line-22>
<line-23> s = 0 # initialize result</line-23>
<line-24> i = i + 1</line-24>
<line-25> while i > 0:</line-25>
<line-26> s += BITTree[i]</line-26>
<line-27> i -= i & (-i)</line-27>
<line-28> return s</line-28>
<line-29></line-29>
<line-30>def upd(BITTree, n, i, v):</line-30>
<line-31> i += 1</line-31>
<line-32> while i <= n:</line-32>
<line-33> BITTree[i] += v</line-33>
<line-34> i += i & (-i)</line-34>
<line-35></line-35>
<line-36>def construct(arr, n):</line-36>
<line-37> BITTree = [0] * (n + 1)</line-37>
<line-38> for i in range(n):</line-38>
<line-39> upd(BITTree, n, i, arr[i])</line-39>
<line-40> return BITTree</line-40>
<line-41></line-41>
<line-42>from collections import defaultdict</line-42>
<line-43>n = int(input())</line-43>
<line-44>swt = list(map(int, input().split()))</line-44>
<line-45>graph = defaultdict(list)</line-45>
<line-46></line-46>
<line-47>for i in range(n-1):</line-47>
<line-48> n1, n2 = list(map(int, input().split()))</line-48>
<line-49> graph[n1-1].append(n2-1)</line-49>
<line-50> graph[n2-1].append(n1-1)</line-50>
<line-51></line-51>
<line-52>flat_tree = [0]*(2*n+1)</line-52>
<line-53>i_c = [0]*n</line-53>
<line-54>o_c = [0]*n</line-54>
<line-55>visited = [0]*n</line-55>
<line-56>flattree(0)</line-56>
<line-57></line-57>
<line-58>tre = construct(flat_tree, 2*n)</line-58>
<line-59></line-59>
<line-60>q = int(input())</line-60>
<line-61>for i in range(q):</line-61>
<line-62> query = list(map(int, input().split()))</line-62>
<line-63> if query[0] == 1:</line-63>
<line-64> node = query[1] - 1</line-64>
<line-65> answer = getsum(tre, i_c[node])</line-65>
<line-66> print(answer)</line-66>
<line-67> else:</line-67>
<line-68> node = query[1]-1</line-68>
<line-70> upd(flat_tree, (2*n), o_c[node], -query[2])</line-70>
|
{"code": "<line-2>def flattree(node):</line-2>\n<line-69> upd(flat_tree, (2*n), i_c[node], query[2])</line-69>", "lines": [2, 69]}
#### 0
|
<line-1>for i in range(eval(input())):</line-1>
<line-3> rows=n</line-3>
<line-4> columns=m</line-4>
<line-5> hand_rest=n*(m+1)</line-5>
<line-6> if(m%2==0):</line-6>
<line-7> hand_rest -=max(0,n-l-r)</line-7>
<line-8> if(l+r+(2*b)<=hand_rest):</line-8>
<line-9> # print "kanu"</line-9>
<line-10> print(min(n*m,l+r+z+b))</line-10>
<line-11> else:</line-11>
<line-12> temp=l+r+(hand_rest-l-r)/2</line-12>
<line-14> print(min(n*m,temp+z))</line-14>
|
{"code": "<line-2> n,m,z,l,r,b = list(map(int, input().split()))</line-2>\n<line-13> # print \"parth\"</line-13>", "lines": [2, 13]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>s1=s[::-1]</line-3>
<line-4>arr=[]</line-4>
<line-5>cnt=0</line-5>
<line-6>for i in range(len(s1)):</line-6>
<line-7> arr.append(s1[i])</line-7>
<line-8>for i in range(len(arr)):</line-8>
<line-9> if(arr[i]=="1"):</line-9>
<line-10> for j in range(i,len(arr)):</line-10>
<line-11> if(arr[j]=="1"):</line-11>
<line-12> arr[j]="0"</line-12>
<line-13> else:</line-13>
<line-14> arr[j]="1"</line-14>
<line-16>print(cnt)</line-16>
|
{"code": "<line-2>s=input()</line-2>\n<line-15> cnt+=1</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>d = {}</line-1>
<line-3> char = chr(i+ord('a'))</line-3>
<line-4> d[char] = []</line-4>
<line-5>for i in range(26):</line-5>
<line-6> char = chr(i+ord('a'))</line-6>
<line-7> temp = list(map(int,input().strip().split()))</line-7>
<line-8> for j in range(26):</line-8>
<line-9> if (temp[j] == 1):</line-9>
<line-10> follow= chr(j+ord('a'))</line-10>
<line-11> d[follow].append(char)</line-11>
<line-12> </line-12>
<line-13>def f(char,i,n,count):</line-13>
<line-14> if (i==n):</line-14>
<line-15> return count+1</line-15>
<line-16> else:</line-16>
<line-17> ans = 0</line-17>
<line-18> for c in d[char]:</line-18>
<line-19> ans+=f(c,i+1,n,0)</line-19>
<line-20> ans%=(10**9+7)</line-20>
<line-21> return ans</line-21>
<line-22></line-22>
<line-23>for q in range(int(input().strip())):</line-23>
<line-24> c, n = input().strip().split()</line-24>
<line-26> print(f(c,1,n,0))</line-26>
|
{"code": "<line-2>for i in range(26):</line-2>\n<line-25> n = int(n)</line-25>", "lines": [2, 25]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.