question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1># cook your dish here</line-1>
<line-3> n,k=map(int,input().split())</line-3>
<line-4> a=[]</line-4>
<line-5> sr=[]</line-5>
<line-6> for i in range(k):</line-6>
<line-7> x,y=input().split()</line-7>
<line-8> y=int(y)</line-8>
<line-9> a.append([10**10-y,x])</line-9>
<line-10> sr.append(sorted(x))</line-10>
<line-11> for i in range(n-k):</line-11>
<line-12> x,y=input().split()</line-12>
<line-13> y=int(y)</line-13>
<line-14> x=sorted(x)</line-14>
<line-15> for j in range(k):</line-15>
<line-16> if x==sr[j]:</line-16>
<line-17> a[j][0]-=y</line-17>
<line-18> break</line-18>
<line-19> a.sort()</line-19>
<line-21> print(i[1],abs(i[0]-10**10))</line-21>
|
{"code": "<line-2>for t in range(int(input())):</line-2>\n<line-20> for i in a:</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>c=[]</line-3>
<line-4>for i in range(len(a)):</line-4>
<line-5> if a[i]==2:</line-5>
<line-6> c.append(1)</line-6>
<line-7> else:</line-7>
<line-9>print(*c)</line-9>
|
{"code": "<line-2>a=list(map(int,input().split()))</line-2>\n<line-8> c.append(a[i]^2)</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>def gcd(a, b):</line-1>
<line-3> return b</line-3>
<line-4> return(gcd(b % a, a))</line-4>
<line-5></line-5>
<line-6>t = int(input())</line-6>
<line-7>for T in range(t):</line-7>
<line-8> n = int(input())</line-8>
<line-9> l = [int(x) for x in input().split()]</line-9>
<line-10></line-10>
<line-11> ang = []</line-11>
<line-12> for i in range(1, n):</line-12>
<line-13> ang.append(l[i] - l[i - 1])</line-13>
<line-14> ang.append(360 - (l[-1] - l[0]))</line-14>
<line-15> ang.sort()</line-15>
<line-16> if ang == ang[::-1]:</line-16>
<line-17> print(0)</line-17>
<line-18> continue</line-18>
<line-19> </line-19>
<line-20> g = ang[0]</line-20>
<line-21> for i in range(1, n):</line-21>
<line-22> g = gcd(g, ang[i])</line-22>
<line-23></line-23>
<line-24> </line-24>
<line-25> total = 360 // g - len(ang)</line-25>
<line-27>## print(g, ang, total)</line-27>
<line-28></line-28>
<line-29></line-29>
|
{"code": "<line-2> if a == 0:</line-2>\n<line-26> print(total)</line-26>", "lines": [2, 26]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> s = input()</line-3>
<line-4> m = 0</line-4>
<line-5> p = 0</line-5>
<line-6> d = 0</line-6>
<line-7> l = []</line-7>
<line-8> for i in range(len(s)):</line-8>
<line-9> if(s[i] == "."):</line-9>
<line-10> m = m+1</line-10>
<line-11> elif(s[i] == "#"):</line-11>
<line-12> l.append(m)</line-12>
<line-13> m=0</line-13>
<line-14> for i in range(len(l)):</line-14>
<line-15> if(l[i]>p):</line-15>
<line-16> p = l[i]</line-16>
<line-18> print(d)</line-18>
<line-19> </line-19>
<line-20> </line-20>
<line-21> </line-21>
<line-22> </line-22>
|
{"code": "<line-2>for i in range(int(input())):</line-2>\n<line-17> d = d+1</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> a = list(map(int,input().split()))</line-3>
<line-4> for _ in range(m):</line-4>
<line-5> for i in range(1,n):</line-5>
<line-7> print(a[x-1]%(10**9+7))</line-7>
|
{"code": "<line-2> n,x,m = map(int,input().split())</line-2>\n<line-6> a[i] = a[i] + a[i-1]</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> num = list(N)</line-3>
<line-4> s=0</line-4>
<line-5> for n in num:</line-5>
<line-6> if n.isnumeric():</line-6>
<line-7> s+=int(n)</line-7>
<line-8> #print(s)</line-8>
<line-10> print(int(N)*10+int(x))</line-10>
|
{"code": "<line-2> N = input()</line-2>\n<line-9> x=(10-s%10)%10</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4> """Returns Nim-number of S[start:end]"""</line-4>
<line-5> key=(start,end)</line-5>
<line-6> try:</line-6>
<line-7> return C[key]</line-7>
<line-8> except KeyError:</line-8>
<line-9> pass</line-9>
<line-10> A=set()</line-10>
<line-11> for s in range(start,end):</line-11>
<line-12> for e in range(start+1,end+1):</line-12>
<line-13> if S[s:e] not in W: continue</line-13>
<line-14> A.add(mex(S,W,C,start,s)^mex(S,W,C,e,end))</line-14>
<line-15> a=0</line-15>
<line-16> while a in A: a+=1</line-16>
<line-17> C[key]=a</line-17>
<line-18> return a</line-18>
<line-19> </line-19>
<line-20></line-20>
<line-21>a=sys.stdin</line-21>
<line-22>#a=open('astrgame.txt','r')</line-22>
<line-23>T=int(a.readline())</line-23>
<line-24>for t in range(T):</line-24>
<line-25> S=a.readline().strip()</line-25>
<line-26> N=int(a.readline())</line-26>
<line-28> print('Teddy' if mex(S,W,{},0,len(S)) else 'Tracy')</line-28>
<line-29> </line-29>
|
{"code": "<line-3>def mex(S,W,C,start,end):</line-3>\n<line-27> W=set([a.readline().strip() for n in range(N)])</line-27>", "lines": [3, 27]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(int(input())):</line-3>
<line-4> a=list(map(int,input().split()))</line-4>
<line-5> x=input()</line-5>
<line-6> t=0</line-6>
<line-7> for i in range(ord('a'),ord('z')+1):</line-7>
<line-8> if chr(i) not in x:</line-8>
<line-10> print(t)</line-10>
|
{"code": "<line-2># cook your dish here</line-2>\n<line-9> t+=a[i-97]</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>def solve(a,n):</line-1>
<line-3> for i in range(1,n):</line-3>
<line-4> curr=max(a[i],curr+a[i])</line-4>
<line-5> max1=max(max1,curr)</line-5>
<line-6> return max1</line-6>
<line-7> </line-7>
<line-8>n,k = list(map(int,input().split()))</line-8>
<line-10>print(sum(a)-solve(a,n)+solve(a,n)/k)</line-10>
|
{"code": "<line-2> max1=curr=a[0]</line-2>\n<line-9>a = list(map(int,input().split()))</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>def binarySearch(arr, l, r, x):</line-1>
<line-3> while l <= r: </line-3>
<line-4> mid = l + (r - l)//2; </line-4>
<line-5> if arr[mid] == x: </line-5>
<line-6> return mid+1 </line-6>
<line-7> elif arr[mid] < x: </line-7>
<line-8> l = mid + 1</line-8>
<line-9> else: </line-9>
<line-10> r = mid - 1</line-10>
<line-11> if mid!=len(arr):</line-11>
<line-12> if arr[mid]<x:</line-12>
<line-13> return mid+1</line-13>
<line-14> return mid</line-14>
<line-15>s=input()</line-15>
<line-16>strt=[]</line-16>
<line-17>end=[]</line-17>
<line-18>plc=[]</line-18>
<line-19>landr=[]</line-19>
<line-20>l2r=[]</line-20>
<line-21>lr=[]</line-21>
<line-22>ans=0</line-22>
<line-23>n=len(s)</line-23>
<line-24>if n!=1:</line-24>
<line-25> for i in range(n):</line-25>
<line-26> strt.append([])</line-26>
<line-27> end.append([])</line-27>
<line-28> landr.append([0]*n)</line-28>
<line-29> l2r.append([0]*n)</line-29>
<line-30> for i in range(n): </line-30>
<line-31> for j in range(n):</line-31>
<line-32> if i-j<0 or i+j>=n:</line-32>
<line-33> break</line-33>
<line-34> if (s[i-j]==s[i+j]):</line-34>
<line-35> if i-j-1>=0:</line-35>
<line-36> strt[i-j-1].append(2*j+1)</line-36>
<line-37> if i+j+1<n:</line-37>
<line-38> end[i+j+1].append(2*j+1)</line-38>
<line-39> else:</line-39>
<line-40> break</line-40>
<line-41> for i in range(n):</line-41>
<line-42> for j in range(n):</line-42>
<line-43> if i-j<0 or i+j+1>=n:</line-43>
<line-44> break</line-44>
<line-45> if (s[i-j]==s[i+j+1]):</line-45>
<line-46> if i-j-1>=0:</line-46>
<line-47> strt[i-j-1].append(2*j+2)</line-47>
<line-48> if i+j+2<n:</line-48>
<line-49> end[i+j+2].append(2*j+2)</line-49>
<line-50> else:</line-50>
<line-51> break</line-51>
<line-52> for i in range(n):</line-52>
<line-53> end[i].sort()</line-53>
<line-54> strt[i].sort()</line-54>
<line-55> for i in range(n-1):</line-55>
<line-56> for j in range(i+1,n):</line-56>
<line-57> if s[i]==s[j]:</line-57>
<line-58> lr.append([i,j])</line-58>
<line-59> if i>0 and j<n-1:</line-59>
<line-60> landr[i][j]=landr[i-1][j+1]+1</line-60>
<line-61> else:</line-61>
<line-62> landr[i][j]=1</line-62>
<line-63> for i in lr:</line-63>
<line-64> tempans=1</line-64>
<line-65> l=i[0]</line-65>
<line-66> r=i[1]</line-66>
<line-67> length=r-l-1</line-67>
<line-68> tempans+=binarySearch(strt[l],0,len(strt[l])-1,length)</line-68>
<line-69> tempans+=binarySearch(end[r],0,len(end[r])-1,length)</line-69>
<line-70> l2r[l][r]=tempans</line-70>
<line-71> for i in range(n):</line-71>
<line-72> for j in range(n):</line-72>
<line-74>print(ans)</line-74>
|
{"code": "<line-2> mid=0</line-2>\n<line-73> ans+=l2r[i][j]*landr[i][j]</line-73>", "lines": [2, 73]}
#### 0
|
<line-1>import sys</line-1>
<line-3>inp=sys.stdin.readline</line-3>
<line-4>out=sys.stdout.write</line-4>
<line-5>flsh=sys.stdout.flush</line-5>
<line-6> </line-6>
<line-7>sys.setrecursionlimit(10**9)</line-7>
<line-8>inf = 10**20</line-8>
<line-9>eps = 1.0 / 10**10</line-9>
<line-10>mod = 10**9+7</line-10>
<line-11>dd = [(-1,0),(0,1),(1,0),(0,-1)]</line-11>
<line-12>ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]</line-12>
<line-13> </line-13>
<line-14>def MI(): return map(int, inp().strip().split())</line-14>
<line-15>def LI(): return list(map(int, inp().strip().split()))</line-15>
<line-16>def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]</line-16>
<line-17>def LI_(): return [int(x)-1 for x in inp().strip().split()]</line-17>
<line-18>def LF(): return [float(x) for x in inp().strip().split()]</line-18>
<line-19>def LS(): return inp().strip().split()</line-19>
<line-20>def I(): return int(inp().strip())</line-20>
<line-21>def F(): return float(inp().strip())</line-21>
<line-22>def S(): return inp().strip()</line-22>
<line-23>def pf(s): return out(s+'\n')</line-23>
<line-24>def JA(a, sep): return sep.join(map(str, a))</line-24>
<line-25>def JAA(a, s, t): return s.join(t.join(map(str, b)) for b in a)</line-25>
<line-26></line-26>
<line-27>def main():</line-27>
<line-28> from math import ceil</line-28>
<line-29> t = I()</line-29>
<line-30> l = []</line-30>
<line-31> for _ in range(t):</line-31>
<line-32> n,k=MI()</line-32>
<line-33> if n==0:</line-33>
<line-34> k-=1</line-34>
<line-35> ans = ((k)*((k+1)))%mod</line-35>
<line-36> l.append(ans)</line-36>
<line-37> else:</line-37>
<line-38> # if k==1:</line-38>
<line-39> # ans = ((((n)*((n-1)))%mod)+ n%mod)%mod</line-39>
<line-40> # l.append(ans)</line-40>
<line-41> # else:</line-41>
<line-42> # k-=1</line-42>
<line-43> # lr = (n%mod+((ceil(k/2)%mod))%mod</line-43>
<line-44> # ans = ((lr*((lr-1))%mod</line-44>
<line-45> # if k%2!=0:</line-45>
<line-46> # ans= (ans%mod + n%mod)%mod</line-46>
<line-47> # else:</line-47>
<line-48> # ans = ((ans%mod)+((lr+n)%mod))%mod</line-48>
<line-49> # l.append(ans)</line-49>
<line-50> if k%2!=0:</line-50>
<line-51> lr = k//2</line-51>
<line-52> l.append(((n*n)%mod+(lr*((2*n)%mod))%mod+(lr*(lr+1))%mod)%mod)</line-52>
<line-53> else:</line-53>
<line-54> lr = k//2</line-54>
<line-55> l.append(((n*n)%mod + (lr*(2*n)%mod)%mod + (lr*(lr-1))%mod)%mod)</line-55>
<line-56></line-56>
<line-57> for i in range(t):</line-57>
<line-58> pf(str(l[i]))</line-58>
<line-59></line-59>
<line-60>def __starting_point():</line-60>
<line-62>__starting_point()</line-62>
|
{"code": "<line-2>from random import choice,randint</line-2>\n<line-61> main()</line-61>", "lines": [2, 61]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(t):</line-3>
<line-4> n = int(input())</line-4>
<line-5> a = []</line-5>
<line-6> b = []</line-6>
<line-7> for i in range(n):</line-7>
<line-8> x,y = list(map(int, input().split()))</line-8>
<line-9> a.append(x)</line-9>
<line-10> b.append(y)</line-10>
<line-11> b.sort()</line-11>
<line-12> xcor = []</line-12>
<line-13> xcor.append(a[1]-a[0])</line-13>
<line-14> xcor.append(a[n-1]-a[n-2])</line-14>
<line-15> for i in range(1,n-1):</line-15>
<line-16> xcor.append(a[i+1]-a[i-1])</line-16>
<line-17> xcor.sort()</line-17>
<line-18> ans = 0</line-18>
<line-19> #print(xcor)</line-19>
<line-20> #print(b)</line-20>
<line-21> for i in range(n):</line-21>
<line-23> print(ans) </line-23>
|
{"code": "<line-2>t = int(input())</line-2>\n<line-22> ans = ans + xcor[i]*b[i]</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>n, k = list(map(int, input().split()))</line-1>
<line-3>maximum = max(A)</line-3>
<line-4>minimum = min(A)</line-4>
<line-5>if k == 0:</line-5>
<line-6> for i in A:</line-6>
<line-7> print(i, end=' ')</line-7>
<line-8>elif k&1:</line-8>
<line-9> for i in A:</line-9>
<line-10> print(maximum - i, end=' ')</line-10>
<line-11>else:</line-11>
<line-13> print(i - minimum, end=' ')</line-13>
|
{"code": "<line-2>A = list(map(int, input().split()))</line-2>\n<line-12> for i in A:</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>from collections import deque</line-1>
<line-3></line-3>
<line-4>for i in range(t):</line-4>
<line-5> n=int(input())</line-5>
<line-6> N=[i for i in range(1, n+1)]</line-6>
<line-7> w=list(map(int, input().split()))</line-7>
<line-8> max_sweetness=max(w)</line-8>
<line-9> sizes=[]</line-9>
<line-10> cnt=0</line-10>
<line-11> for i in range(n):</line-11>
<line-12> if w[i]!=max_sweetness:</line-12>
<line-13> cnt+= 1 </line-13>
<line-14> else:</line-14>
<line-15> sizes.append(cnt)</line-15>
<line-16> cnt=0</line-16>
<line-17> </line-17>
<line-18> if cnt!=0:</line-18>
<line-19> sizes[0]=(cnt+sizes[0])</line-19>
<line-20> </line-20>
<line-21> res=0</line-21>
<line-22> for i in range(len(sizes)):</line-22>
<line-24> </line-24>
<line-25> print(res)</line-25>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-23> res+=max(sizes[i]-n//2+1, 0)</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>import math</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>a = [-1, 0, 1]</line-5>
<line-6></line-6>
<line-7>for i in range(58):</line-7>
<line-8> temp = a[-1] + a[-2]</line-8>
<line-9> temp = temp%10</line-9>
<line-10> a.append(temp)</line-10>
<line-11> </line-11>
<line-12>for _ in range(t):</line-12>
<line-13> n = int(input())</line-13>
<line-14> </line-14>
<line-15> temp = len(bin(n)) - 3</line-15>
<line-16> temp = 2**temp</line-16>
<line-18> </line-18>
<line-19> print(a[temp])</line-19>
|
{"code": "<line-3>t = int(input())</line-3>\n<line-17> temp = temp%60</line-17>", "lines": [3, 17]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>x=[]</line-3>
<line-4>for _ in range(n):</line-4>
<line-5> a,b=map(int,input().split())</line-5>
<line-6> a=[a,a+b]</line-6>
<line-7> x.append(a)</line-7>
<line-8>x = sorted(x, key= lambda i:i[1])</line-8>
<line-9>y=-1</line-9>
<line-10>c=0</line-10>
<line-11>for i in range(len(x)):</line-11>
<line-12> if x[i][0]>y:</line-12>
<line-13> c+=1</line-13>
<line-15>print(c)</line-15>
|
{"code": "<line-2>n=(int(input()))</line-2>\n<line-14> y=x[i][1]</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>m= 9999999</line-1>
<line-3>p= ''</line-3>
<line-4>try:</line-4>
<line-5> s=input().split()</line-5>
<line-6> for i in s:</line-6>
<line-7> if(len(i) <= m):</line-7>
<line-8> m = len(i)</line-8>
<line-9> word = i</line-9>
<line-10> p = word</line-10>
<line-11> for i in s:</line-11>
<line-12> p+= (' '+i+' '+ word)</line-12>
<line-13> </line-13>
<line-14> print(p)</line-14>
<line-15></line-15>
<line-16> </line-16>
<line-18></line-18>
<line-19> pass</line-19>
|
{"code": "<line-2>word=''</line-2>\n<line-17>except EOFError:</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> s = 'zyxwvutsrqponmlkjihgfedcba'</line-3>
<line-4> r = ''</line-4>
<line-5> while True:</line-5>
<line-6> r = s[-N-1:] + r </line-6>
<line-7> if N < 26:</line-7>
<line-8> break</line-8>
<line-10> print(r)</line-10>
|
{"code": "<line-2> N = int(input())</line-2>\n<line-9> N -= 25</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> l = []</line-3>
<line-4> for k in range(r):</line-4>
<line-5> a = list(map(int,input().split()))</line-5>
<line-6> l.append(a)</line-6>
<line-7> ans = "Stable" </line-7>
<line-8> for i in range(r):</line-8>
<line-9> for j in range(c):</line-9>
<line-10> p = l[i][j]</line-10>
<line-11> count=0</line-11>
<line-12> if i-1>=0 and j>=0:</line-12>
<line-13> count+=1 </line-13>
<line-14> if i>=0 and j-1>=0:</line-14>
<line-15> count+=1 </line-15>
<line-16> if i+1<=r-1 and j<=c-1:</line-16>
<line-17> count+=1 </line-17>
<line-18> if i<=r-1 and j+1<=c-1:</line-18>
<line-19> count +=1</line-19>
<line-20> if count<=p:</line-20>
<line-21> ans = "Unstable"</line-21>
<line-23> print(ans) </line-23>
|
{"code": "<line-2> r,c = map(int,input().split())</line-2>\n<line-22> break</line-22>", "lines": [2, 22]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(test):</line-3>
<line-4> b=list(map(int,str(input()).split(' ')))</line-4>
<line-5> c=str(input())</line-5>
<line-6> li1=[0]</line-6>
<line-7> li2=[0]</line-7>
<line-8> for i1 in range(len(c)):</line-8>
<line-9> if c[i1]=='R':</line-9>
<line-10> li1.append(li1[len(li1)-1]+1)</line-10>
<line-11> elif c[i1]=='L':</line-11>
<line-12> li1.append(li1[len(li1)-1]-1)</line-12>
<line-13> elif c[i1]=='U':</line-13>
<line-14> li2.append(li2[len(li2)-1]+1)</line-14>
<line-15> else:</line-15>
<line-16> li2.append(li2[len(li2)-1]-1)</line-16>
<line-17> if (max(li1)-min(li1)+1)<=b[1] and (max(li2)-min(li2)+1)<=b[0]:</line-17>
<line-18> print('safe')</line-18>
<line-20> print('unsafe')</line-20>
|
{"code": "<line-2>test=int(input())</line-2>\n<line-19> else:</line-19>", "lines": [2, 19]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(T):</line-3>
<line-4> l = list(map(int, input().split()))</line-4>
<line-5> n, k, m, x = l[0], l[1], l[2], l[3]</line-5>
<line-6> if k == 1:</line-6>
<line-7> if n == m:</line-7>
<line-8> print("yes")</line-8>
<line-9> else:</line-9>
<line-10> print("no")</line-10>
<line-11> elif m % k > 1:</line-11>
<line-12> print("no")</line-12>
<line-13> elif k == 2:</line-13>
<line-14> stack = []</line-14>
<line-15> var = 0</line-15>
<line-16> while m != 0:</line-16>
<line-17> var += m % k</line-17>
<line-18> stack.append(m % k)</line-18>
<line-19> m //= k</line-19>
<line-20> if var > n:</line-20>
<line-21> print("no")</line-21>
<line-22> elif var == n:</line-22>
<line-23> print("yes")</line-23>
<line-24> else:</line-24>
<line-25> for p in range(100):</line-25>
<line-26> for q in range(2, len(stack)):</line-26>
<line-27> if stack[q - 1] == 0 and stack[q] >= 1:</line-27>
<line-28> stack[q-1] = 2</line-28>
<line-29> stack[q] -= 1</line-29>
<line-30> var += 1</line-30>
<line-31> if var == n:</line-31>
<line-32> print("yes")</line-32>
<line-33> if var < n:</line-33>
<line-34> print("no")</line-34>
<line-35> else:</line-35>
<line-36> temp = 0</line-36>
<line-37> rog = 1</line-37>
<line-38> while m != 0:</line-38>
<line-39> if m % k > 2:</line-39>
<line-40> rog = 0</line-40>
<line-41> print("no")</line-41>
<line-42> temp += m % k</line-42>
<line-43> m //= k</line-43>
<line-44> if rog:</line-44>
<line-45> if temp == n:</line-45>
<line-46> print("yes")</line-46>
<line-48> print("no")</line-48>
<line-49></line-49>
|
{"code": "<line-2>T = int(input())</line-2>\n<line-47> else:</line-47>", "lines": [2, 47]}
#### 0
|
<line-1>'''input</line-1>
<line-3>3</line-3>
<line-4>2 2 3</line-4>
<line-5>4</line-5>
<line-6>2 3 3 2</line-6>
<line-7>'''</line-7>
<line-8>import math</line-8>
<line-9></line-9>
<line-10>for _ in range(int(input())):</line-10>
<line-11> n = int(input())</line-11>
<line-12> a = list(map(int, input().split()))</line-12>
<line-13> count = 0</line-13>
<line-14> i = 0</line-14>
<line-15> while i < len(a):</line-15>
<line-16> if a[i] == 1:</line-16>
<line-17> count += 1</line-17>
<line-18> i += 1</line-18>
<line-19> continue</line-19>
<line-20> curr_gcd = a[i]</line-20>
<line-21> while i < len(a) and curr_gcd != 1:</line-21>
<line-22> curr_gcd = math.gcd(curr_gcd, a[i])</line-22>
<line-23> if curr_gcd == 1:</line-23>
<line-24> count += 1</line-24>
<line-25> i += 1</line-25>
<line-26> # print(i)</line-26>
<line-27> break</line-27>
<line-29> print(count)</line-29>
|
{"code": "<line-2>2</line-2>\n<line-28> i += 1</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> P = list(map(float, input().split()))</line-3>
<line-4> pr = 1</line-4>
<line-5> for p in P:</line-5>
<line-6> a = 100+p</line-6>
<line-7> pr = (pr*a)/100</line-7>
<line-8> pr = (pr-1)*100</line-8>
<line-9> x = 6-len(str(int(abs(pr))))</line-9>
<line-10> if (x==1):</line-10>
<line-11> if (pr==0):</line-11>
<line-12> print(0)</line-12>
<line-13> elif (pr>0):</line-13>
<line-14> print("+"+str("%.1f" % round(pr,x)))</line-14>
<line-15> else:</line-15>
<line-16> print(str("%.1f" % round(pr,x)))</line-16>
<line-17> elif (x==2):</line-17>
<line-18> if (pr==0):</line-18>
<line-19> print(0)</line-19>
<line-20> elif (pr>0):</line-20>
<line-21> print("+"+str("%.2f" % round(pr,x)))</line-21>
<line-22> else:</line-22>
<line-23> print(str("%.2f" % round(pr,x)))</line-23>
<line-24> elif (x==3):</line-24>
<line-25> if (pr==0):</line-25>
<line-26> print(0)</line-26>
<line-27> elif (pr>0):</line-27>
<line-28> print("+"+str("%.3f" % round(pr,x)))</line-28>
<line-29> else:</line-29>
<line-30> print(str("%.3f" % round(pr,x)))</line-30>
<line-31> elif (x==4):</line-31>
<line-32> if (pr==0):</line-32>
<line-33> print(0)</line-33>
<line-34> elif (pr>0):</line-34>
<line-35> print("+"+str("%.4f" % round(pr,x)))</line-35>
<line-36> else:</line-36>
<line-37> print(str("%.4f" % round(pr,x)))</line-37>
<line-38> elif (x==5):</line-38>
<line-39> if (pr==0):</line-39>
<line-40> print(0)</line-40>
<line-41> elif (pr>0):</line-41>
<line-42> print("+"+str("%.5f" % round(pr,x)))</line-42>
<line-43> else:</line-43>
<line-44> print(str("%.5f" % round(pr,x)))</line-44>
<line-45> elif (x==6):</line-45>
<line-46> if (pr==0):</line-46>
<line-47> print(0)</line-47>
<line-48> elif (pr>0):</line-48>
<line-49> print("+"+str("%.6f" % round(pr,x)))</line-49>
<line-51> print(str("%.6f" % round(pr,x)))</line-51>
|
{"code": "<line-2>\t n = int(input())</line-2>\n<line-50>\t\t else:</line-50>", "lines": [2, 50]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-2></line-2>
<line-4>while(t):</line-4>
<line-5> t=t-1</line-5>
<line-6> n,k=list(map(int,input().split()))</line-6>
<line-7> q=list(map(int,input().split()))</line-7>
<line-8> days,rem=0,0</line-8>
<line-9> for i in range(n):</line-9>
<line-10> rem+=q[i]</line-10>
<line-11> if(rem>=k):</line-11>
<line-12> rem-=k</line-12>
<line-13> else:</line-13>
<line-14> days=i+1</line-14>
<line-15> break</line-15>
<line-16> days+=1</line-16>
<line-17> if(rem>=k):</line-17>
<line-19> print(days)</line-19>
|
{"code": "<line-3>t=int(input())</line-3>\n<line-18> days+=(rem//k)+1</line-18>", "lines": [3, 18]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>while t>0:</line-3>
<line-4> n=int(input())</line-4>
<line-5> l=list(map(int,input().split()))</line-5>
<line-6> l1=[]</line-6>
<line-7> c=1</line-7>
<line-8> for i in range(len(l)):</line-8>
<line-9> if l[i]==1:</line-9>
<line-10> l1.append(i)</line-10>
<line-11> for j in range(len(l1)-1):</line-11>
<line-12> if l1[j+1]-l1[j]<6:</line-12>
<line-13> c=0</line-13>
<line-14> break</line-14>
<line-15> if c:</line-15>
<line-16> print("YES")</line-16>
<line-17> else:</line-17>
<line-19> </line-19>
<line-20> t-=1</line-20>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-18> print(\"NO\")</line-18>", "lines": [2, 18]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>for i in range(t):</line-5>
<line-6> n=int(input())</line-6>
<line-7> a=list(map(int,input().split()))</line-7>
<line-8> d={}</line-8>
<line-9> for i in range(n):</line-9>
<line-10> if a[i]-1 not in d:</line-10>
<line-11> d[a[i]-1]=[i]</line-11>
<line-12> else:</line-12>
<line-13> d[a[i]-1].append(i)</line-13>
<line-14> ans=False</line-14>
<line-15> d1={}</line-15>
<line-16> </line-16>
<line-17> for i in d:</line-17>
<line-18> if ans==True:</line-18>
<line-19> break</line-19>
<line-20> for j in d:</line-20>
<line-21> if i!=j:</line-21>
<line-22> if a[i]==a[j] and i!=j:</line-22>
<line-23> ans=True</line-23>
<line-24> break</line-24>
<line-25> if ans==True:</line-25>
<line-26> print('Truly Happy')</line-26>
<line-28> print('Poor Chef')</line-28>
|
{"code": "<line-3>t=int(input())</line-3>\n<line-27> else:</line-27>", "lines": [3, 27]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(t):</line-3>
<line-4> s=input()</line-4>
<line-5> fl=-1</line-5>
<line-6> n=len(s)</line-6>
<line-7> for i in range(n-2):</line-7>
<line-8> if(s[i:i+3]=="010" or s[i:i+3]=="101"):</line-8>
<line-9> fl=0</line-9>
<line-10> print("Good")</line-10>
<line-11> break</line-11>
<line-12></line-12>
<line-14> print("Bad")</line-14>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-13> if(fl==-1):</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>def check(s):</line-1>
<line-3> l=len(s)</line-3>
<line-4> f1=0</line-4>
<line-5> for i in range(1,l):</line-5>
<line-6> if arr==[]: arr.append(s[i])</line-6>
<line-7> elif arr[-1]!=s[i]:arr.append(s[i])</line-7>
<line-8> else: del arr[-1]</line-8>
<line-9> if arr==[]: return True</line-9>
<line-10> else: return False</line-10>
<line-11> </line-11>
<line-12>count = 0</line-12>
<line-13>for t in range(eval(input())):</line-13>
<line-14> s=input().strip()</line-14>
<line-16>print(count)</line-16>
|
{"code": "<line-2> arr=[s[0]]</line-2>\n<line-15> if check(s): count+=1</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>from itertools import permutations as p</line-1>
<line-3> for ai in a:</line-3>
<line-4> for bi in b:</line-4>
<line-5> if ai==bi:</line-5>
<line-6> return False</line-6>
<line-7> return True</line-7>
<line-8></line-8>
<line-9>for i in range(eval(input())):</line-9>
<line-10> n = eval(input())</line-10>
<line-11> arr = list(map(int,input().split()))</line-11>
<line-12> perms = list(p(arr))</line-12>
<line-13> m = eval(input())</line-13>
<line-14> offer = {}</line-14>
<line-15> for i in range(m):</line-15>
<line-16> dup = list(map(int,input().split()))</line-16>
<line-17> try:</line-17>
<line-18> offer[dup[0]].append(dup[1:])</line-18>
<line-19> except:</line-19>
<line-20> offer[dup[0]] = [dup[1:]]</line-20>
<line-21> ans = sum(arr)</line-21>
<line-22> if n==1:</line-22>
<line-23> print(ans)</line-23>
<line-24> elif n==2:</line-24>
<line-25> try:</line-25>
<line-26> if len(offer[2])>=1:</line-26>
<line-27> ans -= min(arr)</line-27>
<line-28> except:</line-28>
<line-29> pass</line-29>
<line-30> print(ans)</line-30>
<line-31> elif n==3:</line-31>
<line-32> try:</line-32>
<line-33> if len(offer[3])>=1:</line-33>
<line-34> ans -= min(arr)</line-34>
<line-35> except:</line-35>
<line-36> pass</line-36>
<line-37> try:</line-37>
<line-38> if len(offer[2])>=1:</line-38>
<line-39> value = 9999999999</line-39>
<line-40> for item in perms:</line-40>
<line-41> cur = 0</line-41>
<line-42> cur += item[0]</line-42>
<line-43> cur += max(item[1],item[2])</line-43>
<line-44> if cur<value:</line-44>
<line-45> value = cur</line-45>
<line-46> if value<ans:</line-46>
<line-47> ans = value</line-47>
<line-48> except:</line-48>
<line-49> pass</line-49>
<line-50> print(ans)</line-50>
<line-51> elif n==4:</line-51>
<line-52> try:</line-52>
<line-53> if len(offer[4])>=1:</line-53>
<line-54> ans -= min(arr)</line-54>
<line-55> except:</line-55>
<line-56> pass</line-56>
<line-57> #print ans</line-57>
<line-58> try:</line-58>
<line-59> if len(offer[3])>=1:</line-59>
<line-60> value = 9999999999</line-60>
<line-61> for item in perms:</line-61>
<line-62> cur = 0</line-62>
<line-63> cur = sum(item)</line-63>
<line-64> cur -= min(item[1],item[2],item[3])</line-64>
<line-65> if cur<value:</line-65>
<line-66> value = cur</line-66>
<line-67> if value<ans:</line-67>
<line-68> ans = value</line-68>
<line-69> except:</line-69>
<line-70> pass</line-70>
<line-71> #print ans</line-71>
<line-72> try:</line-72>
<line-73> if len(offer[2])>=1:</line-73>
<line-74> value = 9999999999</line-74>
<line-75> for item in perms:</line-75>
<line-76> cur = 0</line-76>
<line-77> cur = sum(item)</line-77>
<line-78> cur -= min(item[1],item[2])</line-78>
<line-79> if cur<value:</line-79>
<line-80> value = cur</line-80>
<line-81> if value<ans:</line-81>
<line-82> ans = value</line-82>
<line-83> #print ans</line-83>
<line-84> #print offer[2]</line-84>
<line-85> if len(offer[2])>=2:</line-85>
<line-86> flg = False</line-86>
<line-87> end = len(offer[2])</line-87>
<line-88> for i in range(end):</line-88>
<line-89> for j in range(i+1,end):</line-89>
<line-90> if disc(offer[2][i],offer[2][j]):</line-90>
<line-91> flg = True</line-91>
<line-92> break</line-92>
<line-93> #print flg</line-93>
<line-94> if flg:</line-94>
<line-95> value = 9999999999</line-95>
<line-96> for item in perms:</line-96>
<line-97> cur = 0</line-97>
<line-98> cur = sum(item)</line-98>
<line-99> cur -= min(item[1],item[0])</line-99>
<line-100> cur -= min(item[2],item[3])</line-100>
<line-101> if cur<value:</line-101>
<line-102> value = cur</line-102>
<line-103> if value<ans:</line-103>
<line-104> ans = value</line-104>
<line-105> except:</line-105>
<line-106> pass</line-106>
<line-107> print(ans)</line-107>
<line-108> elif n==5:</line-108>
<line-109> try:</line-109>
<line-110> if len(offer[5])>=1:</line-110>
<line-111> ans -= min(arr)</line-111>
<line-112> except:</line-112>
<line-113> pass</line-113>
<line-114> try:</line-114>
<line-115> if len(offer[4])>=1:</line-115>
<line-116> value = 9999999999</line-116>
<line-117> for item in perms:</line-117>
<line-118> cur = 0</line-118>
<line-119> cur = sum(item)</line-119>
<line-120> cur -= min(item[1],item[2],item[3],item[4])</line-120>
<line-121> if cur<value:</line-121>
<line-122> value = cur</line-122>
<line-123> if value<ans:</line-123>
<line-124> ans = value</line-124>
<line-125> except:</line-125>
<line-126> pass</line-126>
<line-127> try:</line-127>
<line-128> if len(offer[2])>=1:</line-128>
<line-129> value = 9999999999</line-129>
<line-130> for item in perms:</line-130>
<line-131> cur = 0</line-131>
<line-132> cur = sum(item)</line-132>
<line-133> cur -= min(item[1],item[2])</line-133>
<line-134> if cur<value:</line-134>
<line-135> value = cur</line-135>
<line-136> if value<ans:</line-136>
<line-137> ans = value</line-137>
<line-138> if len(offer[2])>=2:</line-138>
<line-139> flg = False</line-139>
<line-140> end = len(offer[2])</line-140>
<line-141> for i in range(end):</line-141>
<line-142> for j in range(i+1,end):</line-142>
<line-143> if disc(offer[2][i],offer[2][j]):</line-143>
<line-144> flg = True</line-144>
<line-145> break</line-145>
<line-146> if flg:</line-146>
<line-147> value = 9999999999</line-147>
<line-148> for item in perms:</line-148>
<line-149> cur = 0</line-149>
<line-150> cur = sum(item)</line-150>
<line-151> cur -= min(item[1],item[0])</line-151>
<line-152> cur -= min(item[2],item[3])</line-152>
<line-153> if cur<value:</line-153>
<line-154> value = cur</line-154>
<line-155> if value<ans:</line-155>
<line-156> ans = value</line-156>
<line-157> except:</line-157>
<line-158> pass</line-158>
<line-159> try:</line-159>
<line-160> if len(offer[3])>=1:</line-160>
<line-161> value = 9999999999</line-161>
<line-162> for item in perms:</line-162>
<line-163> cur = 0</line-163>
<line-164> cur = sum(item)</line-164>
<line-165> cur -= min(item[1],item[2],item[3])</line-165>
<line-166> if cur<value:</line-166>
<line-167> value = cur</line-167>
<line-168> if value<ans:</line-168>
<line-169> ans = value</line-169>
<line-170> except:</line-170>
<line-171> pass</line-171>
<line-172> try:</line-172>
<line-173> if len(offer[3])>=1 and len(offer[2])>=1:</line-173>
<line-174> flg = False</line-174>
<line-175> for i in offer[3]:</line-175>
<line-176> for j in offer[2]:</line-176>
<line-177> if disc(i,j):</line-177>
<line-178> flg = True</line-178>
<line-179> break</line-179>
<line-180> if flg:</line-180>
<line-181> value = 9999999999</line-181>
<line-182> for item in perms:</line-182>
<line-183> cur = 0</line-183>
<line-184> cur = sum(item)</line-184>
<line-185> cur -= min(item[1],item[0])</line-185>
<line-186> cur -= min(item[2],item[3],item[4])</line-186>
<line-187> if cur<value:</line-187>
<line-188> value = cur</line-188>
<line-189> if value<ans:</line-189>
<line-190> ans = value</line-190>
<line-191> except:</line-191>
<line-193> print(ans)</line-193>
<line-194></line-194>
<line-195></line-195>
|
{"code": "<line-2>def disc(a,b):</line-2>\n<line-192> pass</line-192>", "lines": [2, 192]}
#### 0
|
<line-1></line-1>
<line-2>t=int(input())</line-2>
<line-4> l=list(map(int,input().split(' ')))</line-4>
<line-5> a=l[0]</line-5>
<line-6> b=l[1]</line-6>
<line-7> </line-7>
<line-8> l1=list(map(int,input().split(' ')))</line-8>
<line-9> for i in range(b):</line-9>
<line-10> l2=list(map(int,input().split(' ')))</line-10>
<line-11> a1=l2[0]</line-11>
<line-12> b1=l2[1]</line-12>
<line-13> su=0</line-13>
<line-14> for j in range(a1-1,b1):</line-14>
<line-16> print(su) </line-16>
|
{"code": "<line-3>for i in range(t):</line-3>\n<line-15> su=(su+l1[j])%1000000000</line-15>", "lines": [3, 15]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-2></line-2>
<line-4> m, n = list(map(int, stdin.readline().split()))</line-4>
<line-5> final = []</line-5>
<line-6> arr = []</line-6>
<line-7> val = 0</line-7>
<line-8> extra = 0</line-8>
<line-9> for j in range(m):</line-9>
<line-10> ans = list(map(str, stdin.readline().split()))</line-10>
<line-11> if ans.count('N') == n:</line-11>
<line-12> val += 1</line-12>
<line-13> else:</line-13>
<line-14> if val%2 == 0:</line-14>
<line-15> arr.append(ans)</line-15>
<line-16> extra += val</line-16>
<line-17> else:</line-17>
<line-18> arr.append(['N']*n)</line-18>
<line-19> arr.append(ans)</line-19>
<line-20> extra += (val-1)</line-20>
<line-21> val = 0</line-21>
<line-22></line-22>
<line-23> for j in range(len(arr)):</line-23>
<line-24> ans = arr[j]</line-24>
<line-25> start = -1</line-25>
<line-26> for i in range(n):</line-26>
<line-27> if ans[i] == 'P':</line-27>
<line-28> start = i</line-28>
<line-29> break</line-29>
<line-30> if start != -1:</line-30>
<line-31> for i in range(n-1, -1, -1):</line-31>
<line-32> if ans[i] == 'P':</line-32>
<line-33> end = i</line-33>
<line-34> break</line-34>
<line-35> if start != -1:</line-35>
<line-36> if len(final) == 0:</line-36>
<line-37> final.append([start, end])</line-37>
<line-38> else:</line-38>
<line-39> if j%2 == 0:</line-39>
<line-40> if final[-1][0] > start:</line-40>
<line-41> final[-1][0] = start</line-41>
<line-42> else:</line-42>
<line-43> start = final[-1][0]</line-43>
<line-44> else:</line-44>
<line-45> if final[-1][1] < end:</line-45>
<line-46> final[-1][1] = end</line-46>
<line-47> else:</line-47>
<line-48> end = final[-1][1]</line-48>
<line-49> final.append([start, end])</line-49>
<line-50> else:</line-50>
<line-51> if len(final) != 0:</line-51>
<line-52> start, end = 0, n-1</line-52>
<line-53> if j%2 == 0:</line-53>
<line-54> if final[-1][0] > start:</line-54>
<line-55> final[-1][0] = start</line-55>
<line-56> else:</line-56>
<line-57> start = final[-1][0]</line-57>
<line-58> else:</line-58>
<line-59> if final[-1][1] < end:</line-59>
<line-60> final[-1][1] = end</line-60>
<line-61> else:</line-61>
<line-62> end = final[-1][1]</line-62>
<line-63> final.append([start, end])</line-63>
<line-64> if len(final) == 0:</line-64>
<line-65> print(0)</line-65>
<line-66> else:</line-66>
<line-67> count = 0</line-67>
<line-68> for ele in final:</line-68>
<line-70> print(count-1+extra)</line-70>
<line-71> </line-71>
|
{"code": "<line-3>for _ in range(int(stdin.readline())):</line-3>\n<line-69> count += (ele[1]-ele[0]+1)</line-69>", "lines": [3, 69]}
#### 0
|
<line-1>def CeilIndex(A, l, r, key): </line-1>
<line-2> </line-2>
<line-4> </line-4>
<line-5> m = l + (r - l)//2</line-5>
<line-6> if (A[m] >= key): </line-6>
<line-7> r = m </line-7>
<line-8> else: </line-8>
<line-9> l = m </line-9>
<line-10> return r </line-10>
<line-11> </line-11>
<line-12>def LongestIncreasingSubsequenceLength(A, size): </line-12>
<line-13> </line-13>
<line-14> # Add boundary case, </line-14>
<line-15> # when array size is one </line-15>
<line-16> </line-16>
<line-17> tailTable = [0 for i in range(size + 1)] </line-17>
<line-18> len = 0 # always points empty slot </line-18>
<line-19> </line-19>
<line-20> tailTable[0] = A[0] </line-20>
<line-21> len = 1</line-21>
<line-22> for i in range(1, size): </line-22>
<line-23> </line-23>
<line-24> if (A[i] < tailTable[0]): </line-24>
<line-25> </line-25>
<line-26> # new smallest value </line-26>
<line-27> tailTable[0] = A[i] </line-27>
<line-28> </line-28>
<line-29> elif (A[i] > tailTable[len-1]): </line-29>
<line-30> </line-30>
<line-31> # A[i] wants to extend </line-31>
<line-32> # largest subsequence </line-32>
<line-33> tailTable[len] = A[i] </line-33>
<line-34> len+= 1</line-34>
<line-35> </line-35>
<line-36> else: </line-36>
<line-37> # A[i] wants to be current </line-37>
<line-38> # end candidate of an existing </line-38>
<line-39> # subsequence. It will replace </line-39>
<line-40> # ceil value in tailTable </line-40>
<line-41> tailTable[CeilIndex(tailTable, -1, len-1, A[i])] = A[i] </line-41>
<line-42> </line-42>
<line-43> </line-43>
<line-44> return len</line-44>
<line-45>t=int(input())</line-45>
<line-46>for _ in range(t):</line-46>
<line-47> n=int(input())</line-47>
<line-48> a=[]</line-48>
<line-49> for i in range(n):</line-49>
<line-50> a.append(list(map(int,input().split())))</line-50>
<line-51> a.sort()</line-51>
<line-52> b=[0]*n</line-52>
<line-53> for i in range(n):</line-53>
<line-55> </line-55>
<line-56> print(LongestIncreasingSubsequenceLength(b, n)) </line-56>
|
{"code": "<line-3> while (r - l > 1): </line-3>\n<line-54> b[i]=a[i][1]</line-54>", "lines": [3, 54]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n,k=list(map(int,input().split(" ")))</line-3>
<line-4> arr=list(map(int,input().strip().split(" ")))[:n]</line-4>
<line-5> def maxCircularSum(arr, n, k):</line-5>
<line-6> if (n < k):</line-6>
<line-7> print("Invalid");</line-7>
<line-8> return;</line-8>
<line-9></line-9>
<line-10> sum = 0;</line-10>
<line-11> start = 0;</line-11>
<line-12> end = k - 1;</line-12>
<line-13></line-13>
<line-14> for i in range(k):</line-14>
<line-15> sum += arr[i];</line-15>
<line-16></line-16>
<line-17> ans = sum;</line-17>
<line-18></line-18>
<line-19> for i in range(k, n + k):</line-19>
<line-20> sum += arr[i % n] - arr[(i - k) % n];</line-20>
<line-21></line-21>
<line-22> if (sum > ans):</line-22>
<line-23> ans = sum;</line-23>
<line-24> start = (i - k + 1) % n;</line-24>
<line-25> end = i % n;</line-25>
<line-26></line-26>
<line-27> print(ans);</line-27>
<line-28></line-28>
<line-29> def __starting_point():</line-29>
<line-31>__starting_point()</line-31>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-30> maxCircularSum(arr, n, k);</line-30>", "lines": [2, 30]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3> l=list(map(int,input().split()))</line-3>
<line-4> k=l[0]+l[1]</line-4>
<line-5> k=k%(2*l[2])</line-5>
<line-6> </line-6>
<line-7> if k>=0 and k<l[2]:</line-7>
<line-8> print("CHEF")</line-8>
<line-10> print("COOK")</line-10>
|
{"code": "<line-2>for i in range(n):</line-2>\n<line-9> else:</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> a=list(map(int,input().split()))</line-3>
<line-4> def check(mid):</line-4>
<line-5> d,left={},0</line-5>
<line-6> for i in range(mid):</line-6>
<line-7> if a[i]>k:</line-7>
<line-8> if a[i] not in d: </line-8>
<line-9> d[a[i]]=1</line-9>
<line-10> else: </line-10>
<line-11> d[a[i]]+=1</line-11>
<line-12> if len(d)==1:</line-12>
<line-13> return True</line-13>
<line-14> for i in range(mid,n):</line-14>
<line-15> if a[left]>k:</line-15>
<line-16> d[a[left]]-=1</line-16>
<line-17> if d[a[left]]==0: </line-17>
<line-18> del d[a[left]]</line-18>
<line-19> if a[i]>k:</line-19>
<line-20> if a[i] not in d: </line-20>
<line-21> d[a[i]]=1</line-21>
<line-22> else: </line-22>
<line-23> d[a[i]]+=1</line-23>
<line-24> if len(d)==1: </line-24>
<line-25> return True</line-25>
<line-26> left+=1</line-26>
<line-27> return False</line-27>
<line-28> </line-28>
<line-29> lo,hi=0,n</line-29>
<line-30> while lo<=hi:</line-30>
<line-31> mid=(lo+hi)//2</line-31>
<line-32> #print(mid,lo,hi)</line-32>
<line-33> if check(mid):</line-33>
<line-34> res=mid</line-34>
<line-35> lo=mid+1</line-35>
<line-36> else:</line-36>
<line-38> print(res)</line-38>
<line-39> </line-39>
<line-40> </line-40>
<line-41> </line-41>
|
{"code": "<line-2> n,k=list(map(int,input().split()))</line-2>\n<line-37> hi=mid-1</line-37>", "lines": [2, 37]}
#### 0
|
<line-1>t = eval(input())</line-1>
<line-3> n = eval(input())</line-3>
<line-4> a = input().strip().split()</line-4>
<line-5> cb, cs = 0, ""</line-5>
<line-6> for i in range(len(a[0])):</line-6>
<line-7> for j in range(i+1,len(a[0])+1):</line-7>
<line-8> al = True</line-8>
<line-9> s = a[0][i:j]</line-9>
<line-10> for k in a[1:]:</line-10>
<line-11> if s not in k:</line-11>
<line-12> al = False</line-12>
<line-13> break</line-13>
<line-14> if al:</line-14>
<line-15> if j-i>=cb:</line-15>
<line-16> cb = max(cb, j-i)</line-16>
<line-17> if len(cs) < cb:</line-17>
<line-18> cs = a[0][i:j]</line-18>
<line-19> elif len(cs) == cb:</line-19>
<line-21> print(cs)</line-21>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-20> cs = min(cs,a[0][i:j])</line-20>", "lines": [2, 20]}
#### 0
|
<line-1># cook your dish here folding paper</line-1>
<line-3>def li():return [int(i) for i in input().rstrip('\n').split()]</line-3>
<line-4>def st():return input().rstrip('\n')</line-4>
<line-5>def val():return int(input().rstrip('\n'))</line-5>
<line-6>def dist(a,b):return ((a[0]-b[0])**2+(a[1]-b[1])**2)**0.5</line-6>
<line-7>for _ in range(val()):</line-7>
<line-8> n,m,w,h=li()</line-8>
<line-9> s=Counter(st())</line-9>
<line-10> l=[]</line-10>
<line-11> for i in range(m):</line-11>
<line-12> l.append(li())</line-12>
<line-13> ans=float('inf')</line-13>
<line-14> l.sort(key=lambda x:x[0])</line-14>
<line-15> for j in range(1,50):</line-15>
<line-16> for i in range(j,m):</line-16>
<line-17> ans=min(ans,dist(l[i-j],l[i]))</line-17>
<line-18> for i in l:</line-18>
<line-19> if s['D'] or s['U']>1:ans=min(ans,2*i[1])</line-19>
<line-20> if s['U'] or s['D']>1:ans=min(ans,2*(h-i[1]))</line-20>
<line-21> if s['L'] or s['R']>1:ans=min(ans,2*i[0])</line-21>
<line-23> print(ans)</line-23>
|
{"code": "<line-2>from collections import Counter</line-2>\n<line-22> if s['R'] or s['L']>1:ans=min(ans,2*(w-i[0]))</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3>for i in range(t):</line-3>
<line-4> list_to_tri.append(int(input()))</line-4>
<line-5>list_to_tri.sort()</line-5>
<line-7> print(i)</line-7>
|
{"code": "<line-2>list_to_tri = []</line-2>\n<line-6>for i in list_to_tri:</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>for _ in range(eval(input())):</line-1>
<line-3> mod=1000000007</line-3>
<line-4> f1,f2=[0]*101000,[0]*101000</line-4>
<line-5> f1[1]=0</line-5>
<line-6> f1[2]=2</line-6>
<line-7> f1[3]=3</line-7>
<line-8> f2[1]=1</line-8>
<line-9> f2[2]=1</line-9>
<line-10> f2[3]=2;</line-10>
<line-11> for i in range(4,100001):</line-11>
<line-12> f1[i]=f1[i-1]%mod+f1[i-2]%mod+f1[i-3]%mod</line-12>
<line-14> print(f1[n]%mod,f2[n]%mod) </line-14>
|
{"code": "<line-2> n=eval(input())</line-2>\n<line-13> f2[i]=f2[i-1]%mod+f2[i-2]%mod+f2[i-3]%mod</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>def subCount(arr, n, k):</line-1>
<line-2></line-2>
<line-4> for i in range(k + 1):</line-4>
<line-5> mod.append(0)</line-5>
<line-6></line-6>
<line-7></line-7>
<line-8> cumSum = 0</line-8>
<line-9> for i in range(n):</line-9>
<line-10> cumSum = cumSum + arr[i]</line-10>
<line-11></line-11>
<line-12> # as the sum can be negative,</line-12>
<line-13> # taking modulo twice</line-13>
<line-14> mod[((cumSum % k) + k) % k] = mod[((cumSum % k) + k) % k] + 1</line-14>
<line-15></line-15>
<line-16> result = 0 # Initialize result</line-16>
<line-17></line-17>
<line-18> for i in range(k):</line-18>
<line-19></line-19>
<line-20></line-20>
<line-21> if (mod[i] > 1):</line-21>
<line-22> result = result + (mod[i] * (mod[i] - 1)) // 2</line-22>
<line-23></line-23>
<line-24></line-24>
<line-25> result = result + mod[0]</line-25>
<line-26></line-26>
<line-27> return result</line-27>
<line-28>t=int(input())</line-28>
<line-29>while t:</line-29>
<line-30> t=t-1</line-30>
<line-31> n=int(input())</line-31>
<line-32> a=list(map(int,input().split()))</line-32>
<line-33> for i in range(n):</line-33>
<line-34> if a[i]==100000000:</line-34>
<line-35> a[i]=1</line-35>
<line-36> elif a[i]==900000000:</line-36>
<line-37> a[i]=9</line-37>
<line-39></line-39>
<line-40> print(subCount(a,n,s))</line-40>
|
{"code": "<line-3> mod = []</line-3>\n<line-38> s=10</line-38>", "lines": [3, 38]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> bStr=''</line-3>
<line-4> for i in range(bits):</line-4>
<line-5> if n>0:</line-5>
<line-6> bStr=bStr+str(n%2)</line-6>
<line-7> else:</line-7>
<line-8> bStr=bStr+'0'</line-8>
<line-9> n=n>>1</line-9>
<line-10> return int(bStr,2)</line-10>
<line-11> </line-11>
<line-12>for i in range(t):</line-12>
<line-13> k,msg=input().split()</line-13>
<line-14> k=int(k)</line-14>
<line-15> newmsg=[]</line-15>
<line-16> for j in msg:</line-16>
<line-17> newmsg.append(j)</line-17>
<line-18> for j in range(len(msg)):</line-18>
<line-20> print(''.join(newmsg))</line-20>
<line-21> </line-21>
<line-22> </line-22>
|
{"code": "<line-2>def reversebinary(bits,n):</line-2>\n<line-19> newmsg[reversebinary(k,j)]=msg[j]</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>import math</line-1>
<line-3>n,k=list(map(int,input().split()))</line-3>
<line-5>print(c%p)</line-5>
|
{"code": "<line-2>p=7+10**9</line-2>\n<line-4>c=math.factorial(n+k-1)//((math.factorial(k))*(math.factorial(n-1)))</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>t =int(input()) #no. of test cases</line-1>
<line-3> t=t-1</line-3>
<line-4> str=input()</line-4>
<line-5> size=len(str)</line-5>
<line-6> pos=str.find('W')</line-6>
<line-7> left=pos</line-7>
<line-8> right=size-pos-1</line-8>
<line-9> arr = [[0 for i in range(right+1)] for j in range(left+1)]</line-9>
<line-10> #arr[i,j] = 1 if with i black cells on left and j on right 1st player can win, 0 otherwise.</line-10>
<line-11> #Recursion: arr[i][j]= or(arr[x][y])</line-11>
<line-12> arr[0][0]=0</line-12>
<line-13> for i in range(left+1):</line-13>
<line-14> for j in range(right+1):</line-14>
<line-15> if i==j:</line-15>
<line-16> arr[i][j]=0</line-16>
<line-17> else:</line-17>
<line-18> arr[i][j]=1</line-18>
<line-19> if(arr[left][right]==1):</line-19>
<line-20> print("Aleksa")</line-20>
<line-22> print("Chef")</line-22>
|
{"code": "<line-2>while t>0:</line-2>\n<line-21> else:</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>import sys</line-1>
<line-3>import heapq</line-3>
<line-4>def half(n):</line-4>
<line-5> return n//2</line-5>
<line-6>def main(arr,m):</line-6>
<line-7> a,b,c=arr</line-7>
<line-8> </line-8>
<line-9> while m!=0:</line-9>
<line-10> </line-10>
<line-11> </line-11>
<line-12> </line-12>
<line-13> s=max(a,b,c)</line-13>
<line-14> </line-14>
<line-15> if s==a:</line-15>
<line-16> a=half(a)</line-16>
<line-17> elif s==b:</line-17>
<line-18> b=half(b)</line-18>
<line-19> else:</line-19>
<line-20> c=half(c)</line-20>
<line-21> m-=1</line-21>
<line-22> return max(a,b,c)</line-22>
<line-23> </line-23>
<line-24> </line-24>
<line-25> </line-25>
<line-26> </line-26>
<line-27> </line-27>
<line-28></line-28>
<line-29>for i in range(int(input())):</line-29>
<line-30> r,g,b,m=list(map(int,input().split()))</line-30>
<line-31> arr=[]</line-31>
<line-32> for j in range(3):</line-32>
<line-33> c=max(list(map(int,input().split())))</line-33>
<line-35> </line-35>
<line-36> print(main(arr,m))</line-36>
|
{"code": "<line-2>import math</line-2>\n<line-34> arr.append(c)</line-34>", "lines": [2, 34]}
#### 0
|
<line-1>dt, a = None, None</line-1>
<line-3> r = [{}, {}];ln = len(dt[z])</line-3>
<line-4> if ln == 0:r[0][0] = 0;r[1][1 << a[z]] = 1</line-4>
<line-5> elif ln == 1:</line-5>
<line-6> l = dfs(dt[z][0]);r[0] = l[1]</line-6>
<line-7> for m in l[0]: r[1][(1 << a[z]) | m] = min(r[1][(1 << a[z]) | m], l[0][m] + 1) if (1 << a[z]) | m in r[1] else l[0][m] + 1</line-7>
<line-8> for m in l[1]: r[1][(1 << a[z]) | m] = min(r[1][(1 << a[z]) | m], l[1][m] + 1) if (1 << a[z]) | m in r[1] else l[1][m] + 1</line-8>
<line-9> elif ln == 2:</line-9>
<line-10> l0 = dfs(dt[z][0]);l1 = dfs(dt[z][1])</line-10>
<line-11> for i0 in range(2):</line-11>
<line-12> for i1 in range(2):</line-12>
<line-13> for m0 in l0[i0]:</line-13>
<line-14> for m1 in l1[i1]:r[1][(1 << a[z]) | m0 | m1] = min(r[1][(1 << a[z]) | m0 | m1], l0[i0][m0] + l1[i1][m1] + 1) if (1 << a[z]) | m0 | m1 in r[1] else l0[i0][m0] + l1[i1][m1] + 1</line-14>
<line-15> for m0 in l0[1]:</line-15>
<line-16> for m1 in l1[1]: r[0][m0 | m1] = min(r[0][m0 | m1], l0[1][m0] + l1[1][m1]) if m0 | m1 in r[0] else l0[1][m0] + l1[1][m1]</line-16>
<line-17> return r</line-17>
<line-18>for i in range(int(input())):</line-18>
<line-19> n, m, k = map(int, input().split());a = [0] + [int(x) - 1 for x in input().split()];dt = [[] for i in range(n + 1)];</line-19>
<line-20> for i in range(m):u, v = map(int, input().split());dt[u].append(v)</line-20>
<line-21> r = dfs(1);k = (1 << k) - 1</line-21>
<line-22> if (k in r[0]): v = min(r[0][k], r[1][k])</line-22>
<line-23> elif (k in r[1]): v = r[1][k]</line-23>
<line-25> print(v)</line-25>
|
{"code": "<line-2>def dfs(z):</line-2>\n<line-24> else: v = -1</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>a, b = [int(x) for x in input().split()]</line-1>
<line-3>if r[0] == "1":</line-3>
<line-4> r[0] = "2"</line-4>
<line-5>else:</line-5>
<line-7>print("".join(r))</line-7>
|
{"code": "<line-2>r = list(str(a-b))</line-2>\n<line-6> r[0]=\"1\"</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3> i=1</line-3>
<line-4> a,b=(int(i) for i in input().split())</line-4>
<line-5> if (b+1)%(i<<a)==0:</line-5>
<line-6> print("ON")</line-6>
<line-7> else:</line-7>
<line-9> n=n-1</line-9>
|
{"code": "<line-2>while n>0:</line-2>\n<line-8> print(\"OFF\")</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3> t=int(input())</line-3>
<line-4> x=[]</line-4>
<line-5> for i in range(t):</line-5>
<line-6> x.append(int(input()))</line-6>
<line-7> print(max(x))</line-7>
<line-8> return</line-8>
<line-10> do()</line-10>
|
{"code": "<line-2>def do():</line-2>\n<line-9>for i in range(n):</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>string=input()</line-1>
<line-3>for i in range(len(string)):</line-3>
<line-4> var_occur=0</line-4>
<line-5> check_no=str()</line-5>
<line-6> j=i</line-6>
<line-7> while(j<len(string) and var_occur<2 ):</line-7>
<line-8> if(string[j].isalpha()):</line-8>
<line-9> if(var_occur==0):</line-9>
<line-10> check_no+='9'</line-10>
<line-11> var_occur+=1</line-11>
<line-12> else:</line-12>
<line-13> var_occur+=1</line-13>
<line-14> else:</line-14>
<line-15> check_no+=string[j]</line-15>
<line-16> j+=1</line-16>
<line-17> #print(check_no)</line-17>
<line-19>print(max_no)</line-19>
|
{"code": "<line-2>max_no=0</line-2>\n<line-18> max_no=max(max_no,int(check_no))</line-18>", "lines": [2, 18]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>def solve(arr, n, k):</line-3>
<line-4> ans = 0</line-4>
<line-5> dict1 = {}</line-5>
<line-6> mod = 1000000007</line-6>
<line-7> </line-7>
<line-8> for i in range(n):</line-8>
<line-9> if arr[i] in dict1:</line-9>
<line-10> dict1[arr[i]] += 1 </line-10>
<line-11> else:</line-11>
<line-12> dict1[arr[i]] = 1</line-12>
<line-13> l1 = [0]+list(dict1.keys())</line-13>
<line-14> v = min(k, len(l1))</line-14>
<line-15> dp = [[0 for _ in range(v+1)]for _ in range(len(l1))]</line-15>
<line-16> dp[0][0] = 1</line-16>
<line-17> for i in range(1, len(l1)):</line-17>
<line-18> dp[i][0] = 1</line-18>
<line-19> for j in range(1, v+1):</line-19>
<line-20> dp[i][j] = dp[i-1][j] + dp[i-1][j-1]*dict1[l1[i]]</line-20>
<line-21> for i in range(v+1):</line-21>
<line-22> ans += dp[len(l1)-1][i]</line-22>
<line-23> ans = ans%mod</line-23>
<line-24> return ans</line-24>
<line-25> </line-25>
<line-26></line-26>
<line-27>n, k = map(int, input().strip().split())</line-27>
<line-29>print(solve(arr, n, k))</line-29>
|
{"code": "<line-2>from collections import Counter</line-2>\n<line-28>arr = list(map(int, input().strip().split()))</line-28>", "lines": [2, 28]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>a = list(map(int, input().split()))</line-3>
<line-4>n = a[0]</line-4>
<line-5>t = a[1]</line-5>
<line-6>q = list(combinations(a[2:], 4))</line-6>
<line-7>total = 0</line-7>
<line-8>for i in q:</line-8>
<line-9> if sum(i) == t:</line-9>
<line-11>print(total)</line-11>
|
{"code": "<line-2>from itertools import combinations</line-2>\n<line-10> total += 1</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-3></line-3>
<line-5> return sys.stdin.readline().strip()</line-5>
<line-6></line-6>
<line-7></line-7>
<line-8>for i in range(int(input())):</line-8>
<line-9> n, k = map(int, input().split())</line-9>
<line-10> arr = []</line-10>
<line-11> if k == 2 or k == 4 or n % 2 != 0 or n == k:</line-11>
<line-12> arr.append('-1')</line-12>
<line-13> elif k % 2 != 0:</line-13>
<line-14> for i in range(int(n / 2)):</line-14>
<line-15> arr.append('(')</line-15>
<line-16> for i in range(int(n / 2)):</line-16>
<line-17> arr.append(')')</line-17>
<line-18> elif int(n / (k - 2)) == 1:</line-18>
<line-19> if (n - 2) % 4 == 0:</line-19>
<line-20> for i in range(int((n - 2) / 4)):</line-20>
<line-21> arr.append('(')</line-21>
<line-22> for i in range(int((n - 2) / 4)):</line-22>
<line-23> arr.append(')')</line-23>
<line-24> arr.append('()')</line-24>
<line-25> for i in range(int((n - 2) / 4)):</line-25>
<line-26> arr.append('(')</line-26>
<line-27> for i in range(int((n - 2) / 4)):</line-27>
<line-28> arr.append(')')</line-28>
<line-29> else:</line-29>
<line-30> for i in range(int((n - 4) / 4)):</line-30>
<line-31> arr.append('(')</line-31>
<line-32> for i in range(int((n - 4) / 4)):</line-32>
<line-33> arr.append(')')</line-33>
<line-34> arr.append('(())')</line-34>
<line-35> for i in range(int((n - 4) / 4)):</line-35>
<line-36> arr.append('(')</line-36>
<line-37> for i in range(int((n - 4) / 4)):</line-37>
<line-38> arr.append(')')</line-38>
<line-39> else:</line-39>
<line-40> for i in range(int((n % (k - 2)) / 2)):</line-40>
<line-41> arr.append('(')</line-41>
<line-42> for i in range(int(n / (k - 2))):</line-42>
<line-43> for j in range(int((k - 2) / 2)):</line-43>
<line-44> arr.append('(')</line-44>
<line-45> for j in range(int((k - 2) / 2)):</line-45>
<line-46> arr.append(')')</line-46>
<line-47> for i in range(int((n % (k - 2)) / 2)):</line-47>
<line-49></line-49>
<line-50> print("".join(arr))</line-50>
|
{"code": "<line-4>def input():</line-4>\n<line-48> arr.append(')')</line-48>", "lines": [4, 48]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> print("Case "+str(_+1)+":")</line-3>
<line-4> for i in range(m):</line-4>
<line-5> s=input()</line-5>
<line-6> ls=len(s)</line-6>
<line-7> if ls>n:</line-7>
<line-8> print("0")</line-8>
<line-9> else:</line-9>
<line-11> print((k*pow(26,n-ls,1000000007))%1000000007)</line-11>
|
{"code": "<line-2> n,m=map(int,input().split())</line-2>\n<line-10> k=(n-ls+1)</line-10>", "lines": [2, 10]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(t):</line-3>
<line-4> st=input()</line-4>
<line-5> s=set(st)</line-5>
<line-6> a=[]</line-6>
<line-7> f1=f2=0</line-7>
<line-8> for i in s:</line-8>
<line-9> a.append(st.count(i))</line-9>
<line-10> a.sort()</line-10>
<line-11> if len(a)>=3:</line-11>
<line-12> for i in range(2,len(a)):</line-12>
<line-13> if a[i]!=a[i-1]+a[i-2]:</line-13>
<line-14> f1=1</line-14>
<line-15> break</line-15>
<line-16> x=a[0]</line-16>
<line-17> a[0]=a[1]</line-17>
<line-18> a[1]=x</line-18>
<line-19> for i in range(2,len(a)):</line-19>
<line-20> if a[i]!=a[i-1]+a[i-2]:</line-20>
<line-21> f2=1</line-21>
<line-22> break</line-22>
<line-23> if f1==1 and f2==1:</line-23>
<line-24> print("Not")</line-24>
<line-25> else:</line-25>
<line-26> print("Dynamic")</line-26>
<line-28> print("Dynamic")</line-28>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-27> else:</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>def gcd(a,b):</line-1>
<line-3> else:return gcd(b,a%b)</line-3>
<line-4>def lcm(a,b):</line-4>
<line-5> m=a*b</line-5>
<line-6> g=gcd(a,b)</line-6>
<line-7> return int(m/g)</line-7>
<line-8>for _ in range(int(input())):</line-8>
<line-9> x,y=[int(x) for x in input().split()]</line-9>
<line-10> l=lcm(x,y)</line-10>
<line-11> s=int(l/x)</line-11>
<line-13> print(s+t-2)</line-13>
|
{"code": "<line-2>\tif b==0:return a</line-2>\n<line-12>\tt=int(l/y)</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>d={}</line-3>
<line-4>val_desc=[0]*n</line-4>
<line-5>visited=set()</line-5>
<line-6>visited.add(0)</line-6>
<line-7>dfstack=[]</line-7>
<line-8>desc = [[False for i in range(n)] for i in range(n)]</line-8>
<line-9>for i in range(n):</line-9>
<line-10> cost.append(int(input()))</line-10>
<line-11> d[i]=[]</line-11>
<line-12></line-12>
<line-13>for i in range(n-1):</line-13>
<line-14> j,k=list(map(int,input().split()))</line-14>
<line-15> d[j-1].append(k-1)</line-15>
<line-16> d[k-1].append(j-1)</line-16>
<line-17></line-17>
<line-18>def dfs(u):</line-18>
<line-19> val_desc[u]+=cost[u]</line-19>
<line-20> dfstack.append(u)</line-20>
<line-21> for i in dfstack:</line-21>
<line-22> desc[u][i]=True</line-22>
<line-23> for i in d[u]:</line-23>
<line-24> if i not in visited:</line-24>
<line-25> visited.add(i)</line-25>
<line-26> dfs(i)</line-26>
<line-27> val_desc[u]+=val_desc[i] </line-27>
<line-28> dfstack.pop(-1)</line-28>
<line-29></line-29>
<line-30>dfs(0)</line-30>
<line-31>mp=10**9</line-31>
<line-32>coco=sum(cost)</line-32>
<line-33>for i in range(n):</line-33>
<line-34> for j in range(i+1,n):</line-34>
<line-35> vali=val_desc[i]</line-35>
<line-36> valj=val_desc[j]</line-36>
<line-37> if desc[i][j]:</line-37>
<line-38> valj-=val_desc[i]</line-38>
<line-39> if desc[j][i]:</line-39>
<line-40> vali-=val_desc[j]</line-40>
<line-41> p=max(vali,valj,coco-vali-valj)</line-41>
<line-42> mp=min(mp,p)</line-42>
<line-43>#print(desc)</line-43>
<line-44>#print(val_desc)</line-44>
<line-46>print(mp)</line-46>
<line-47></line-47>
<line-48></line-48>
<line-49> </line-49>
|
{"code": "<line-2>cost=[]</line-2>\n<line-45>#print</line-45>", "lines": [2, 45]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> time = 0.0</line-3>
<line-4> for i in range(n):</line-4>
<line-5> if time < c[i]:</line-5>
<line-6> time = c[i]</line-6>
<line-7> time += mid # cannon cooling</line-7>
<line-8> elif time >= c[i] and time <= c[i] + d:</line-8>
<line-9> time += mid # cannon cooling</line-9>
<line-10> else:</line-10>
<line-11> return False</line-11>
<line-12> return True</line-12>
<line-13></line-13>
<line-14>t = int(input())</line-14>
<line-15>while t != 0:</line-15>
<line-16> n, d = list(map(int, input().split()))</line-16>
<line-17> c = list(map(int, input().split()))[:n]</line-17>
<line-18> ans = -1</line-18>
<line-19> c.sort()</line-19>
<line-20> low, high = 0, 10 ** 10</line-20>
<line-21> while (high - low) > 0.000001:</line-21>
<line-22> mid = (low + high) / 2</line-22>
<line-23> if isValid(mid):</line-23>
<line-24> ans = mid</line-24>
<line-25> low = mid</line-25>
<line-26> else:</line-26>
<line-27> high = mid </line-27>
<line-29> t -= 1</line-29>
|
{"code": "<line-2>def isValid(mid):</line-2>\n<line-28> print(\"{0:.6f}\".format(ans))</line-28>", "lines": [2, 28]}
#### 0
|
<line-1></line-1>
<line-2></line-2>
<line-3>d = 10**9 + 7</line-3>
<line-4></line-4>
<line-6>while t:</line-6>
<line-7> t-=1</line-7>
<line-8> n =int(input())</line-8>
<line-9> p =list(map(int, input().strip().split()))</line-9>
<line-10> a =list(map(int, input().strip().split()))</line-10>
<line-11> b =list(map(int, input().strip().split()))</line-11>
<line-12> ans = 1</line-12>
<line-13> for i in range(n):</line-13>
<line-14> c = a[i] - b[i] + 1</line-14>
<line-15> tmp = (( pow(p[i],b[i],d) * ((pow(p[i],c,d) - 1 + d)%d) * pow(p[i]-1 , d-2, d)%d))</line-15>
<line-16> ans *= tmp</line-16>
<line-18></line-18>
<line-19> print(ans)</line-19>
|
{"code": "<line-5>t = int(input())</line-5>\n<line-17> ans = ans%d</line-17>", "lines": [5, 17]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-2></line-2>
<line-4> friends = int(input())</line-4>
<line-5> candies = list(map(int,input().split()))</line-5>
<line-6> if (sum(candies) % friends == 0):</line-6>
<line-7> print("Yes")</line-7>
<line-9> print("No")</line-9>
|
{"code": "<line-3>for _ in range(int(input())):</line-3>\n<line-8> else:</line-8>", "lines": [3, 8]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> k = int(input())</line-4>
<line-5> num = int(k/n)</line-5>
<line-6> x = max(n*(1+num) - k, 0)</line-6>
<line-7> diff = abs(x - (n-x))</line-7>
<line-8> if diff == 0:</line-8>
<line-9> number = 2*x - 1</line-9>
<line-10> else:</line-10>
<line-12> print(number)</line-12>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-11> number = min(x, n-x)*2</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>from sys import stdin,stdout</line-1>
<line-3>from datetime import date</line-3>
<line-4>from collections import Counter,deque,defaultdict</line-4>
<line-5>L=lambda:list(map(int, stdin.readline().strip().split()))</line-5>
<line-6>M=lambda:list(map(int, stdin.readline().strip().split()))</line-6>
<line-7>I=lambda:int(stdin.readline().strip())</line-7>
<line-8>S=lambda:stdin.readline().strip()</line-8>
<line-9>C=lambda:stdin.readline().strip().split()</line-9>
<line-10>def pr(a):return("".join(list(map(str,a))))</line-10>
<line-11>#_________________________________________________#</line-11>
<line-12></line-12>
<line-13>def solve():</line-13>
<line-14> s = list(S())</line-14>
<line-15> a=[s[0]]</line-15>
<line-16> for i in range(1,len(s)):</line-16>
<line-17> if a and a[-1]==s[i]:</line-17>
<line-18> a.pop()</line-18>
<line-19> else:</line-19>
<line-20> a.append(s[i])</line-20>
<line-21> print(len(a))</line-21>
<line-22> </line-22>
<line-24> solve()</line-24>
|
{"code": "<line-2>import math,bisect</line-2>\n<line-23>for _ in range(I()): </line-23>", "lines": [2, 23]}
#### 0
|
<line-1>"""</line-1>
<line-3> Team : CodeDiggers</line-3>
<line-4>"""</line-4>
<line-5>import sys,math</line-5>
<line-6>input = sys.stdin.readline</line-6>
<line-7>############ ---- USER DEFINED INPUT FUNCTIONS ---- ############</line-7>
<line-8>def inp():</line-8>
<line-9> return(int(input()))</line-9>
<line-10>def inlt():</line-10>
<line-11> return(list(map(int,input().split())))</line-11>
<line-12>def insr():</line-12>
<line-13> s = input()</line-13>
<line-14> return(s[:len(s) - 1])</line-14>
<line-15>def invr():</line-15>
<line-16> return(map(int,input().split()))</line-16>
<line-17>################################################################</line-17>
<line-18>############ ---- THE ACTUAL CODE STARTS BELOW ---- ############</line-18>
<line-19>t = 1</line-19>
<line-20>t = inp()</line-20>
<line-21>for tt in range(t):</line-21>
<line-22> n,s = invr()</line-22>
<line-23> if n == 2 and s > 1:</line-23>
<line-24> print(s - 1)</line-24>
<line-25> elif n > 2 and s > 1:</line-25>
<line-26> print(0)</line-26>
<line-27> elif n == 1:</line-27>
<line-28> print(s)</line-28>
<line-30> print(-1)</line-30>
|
{"code": "<line-2> Author : thekushalghosh</line-2>\n<line-29> else:</line-29>", "lines": [2, 29]}
#### 0
|
<line-1>n,q=list(map(int,input().split()))</line-1>
<line-3>height=list(map(int,input().split()))</line-3>
<line-4>for k in range(0,q):</line-4>
<line-5> b=input().split()</line-5>
<line-6> if int(b[0])==1:</line-6>
<line-7> step=int(b[1])-1</line-7>
<line-8> for k in range(0,int(b[2])):</line-8>
<line-9> temp = 0</line-9>
<line-10> j=1</line-10>
<line-11> while j in range(1,101) and temp==0 and step+j<n:</line-11>
<line-12> if height[step+j]>height[step]:</line-12>
<line-13> step=step+j</line-13>
<line-14> temp=1</line-14>
<line-15> j+=1</line-15>
<line-16> final.append(step+1)</line-16>
<line-17> elif int(b[0])==2:</line-17>
<line-18> for k in range(int(b[1])-1,int(b[2])):</line-18>
<line-19> height[k]=height[k]+int(b[3])</line-19>
<line-21> print(final[l])</line-21>
|
{"code": "<line-2>final=[]</line-2>\n<line-20>for l in range(0,len(final)):</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>def main():</line-1>
<line-3> rows,column = map(int,input().split())</line-3>
<line-4> arr = []</line-4>
<line-5> for i in range(rows):</line-5>
<line-6> arr.append(list(input()))</line-6>
<line-7> string = input()</line-7>
<line-8> last = string[-1]</line-8>
<line-9> operation = Find(string,last)</line-9>
<line-10> for i in string[0]+operation:</line-10>
<line-11> if i == "L":</line-11>
<line-12> arr = Left(arr)</line-12>
<line-13> if i == "R":</line-13>
<line-14> arr = Right(arr)</line-14>
<line-15> if i == "U":</line-15>
<line-16> arr = Transpose(arr)</line-16>
<line-17> arr = Left(arr)</line-17>
<line-18> arr = Transpose(arr)</line-18>
<line-19> if i == "D":</line-19>
<line-20> arr = Transpose(arr)</line-20>
<line-21> arr = Right(arr)</line-21>
<line-22> arr = Transpose(arr)</line-22>
<line-23> for i in arr:</line-23>
<line-24> print(i)</line-24>
<line-25>def Left(arr):</line-25>
<line-26> for i in range(len(arr)):</line-26>
<line-27> ans = arr[i].count("1")</line-27>
<line-28> arr[i] = "1"*ans + (len(arr[i]) - ans)*"0"</line-28>
<line-29> return arr</line-29>
<line-30>def Right(arr):</line-30>
<line-31> for i in range(len(arr)):</line-31>
<line-32> ans = arr[i].count("1")</line-32>
<line-33> arr[i] = (len(arr[i]) - ans)*"0"+"1"*ans</line-33>
<line-34> return arr</line-34>
<line-35>def Transpose(arr):</line-35>
<line-36> ansss = []</line-36>
<line-37> ans = list(map(list, zip(*arr)))</line-37>
<line-38> for i in ans:</line-38>
<line-39> ass = i</line-39>
<line-40> hello = ""</line-40>
<line-41> for j in ass:</line-41>
<line-42> hello += j</line-42>
<line-43> ansss.append(hello)</line-43>
<line-44> return ansss </line-44>
<line-45>def Find(string,last):</line-45>
<line-46> for i in string[-2::-1]: </line-46>
<line-47> if last == "L":</line-47>
<line-48> if i in ["D","U"]:</line-48>
<line-49> last = i + last</line-49>
<line-50> break</line-50>
<line-51> if last == "R":</line-51>
<line-52> if i in ["D","U"]:</line-52>
<line-53> last = i + last</line-53>
<line-54> break</line-54>
<line-55> if last == "D":</line-55>
<line-56> if i in ["L","R"]:</line-56>
<line-57> last = i + last</line-57>
<line-58> break</line-58>
<line-59> if last == "U":</line-59>
<line-60> if i in ["L","R"]:</line-60>
<line-61> last = i + last</line-61>
<line-62> break</line-62>
<line-63> return last</line-63>
<line-64> </line-64>
<line-65>def __starting_point():</line-65>
<line-67>__starting_point()</line-67>
|
{"code": "<line-2> for _ in range(int(input())):</line-2>\n<line-66> main()</line-66>", "lines": [2, 66]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from math import gcd</line-3>
<line-4># import re</line-4>
<line-5># from heapq import *</line-5>
<line-6># from collections import defaultdict as dd</line-6>
<line-7># from collections import OrderedDict as odict</line-7>
<line-8># from collections import Counter as cc</line-8>
<line-9># from collections import deque</line-9>
<line-10># sys.setrecursionlimit(10**5)#thsis is must</line-10>
<line-11># mod = 10**9+7; md = 998244353</line-11>
<line-12># m = 2**32</line-12>
<line-13>input = lambda: sys.stdin.readline().strip()</line-13>
<line-14>inp = lambda: list(map(int,sys.stdin.readline().strip().split()))</line-14>
<line-15># def C(n,r,mod):</line-15>
<line-16># if r>n:</line-16>
<line-17># return 0</line-17>
<line-18># num = den = 1</line-18>
<line-19># for i in range(r):</line-19>
<line-20># num = (num*(n-i))%mod</line-20>
<line-21># den = (den*(i+1))%mod</line-21>
<line-22># return (num*pow(den,mod-2,mod))%mod</line-22>
<line-23># M = 1000000+1</line-23>
<line-24># pfc = [i for i in range(M+1)]</line-24>
<line-25># def pfcs(M):</line-25>
<line-26># for i in range(2,M+1):</line-26>
<line-27># if pfc[i]==i:</line-27>
<line-28># for j in range(i+i,M+1,i):</line-28>
<line-29># if pfc[j]==j:</line-29>
<line-30># pfc[j] = i</line-30>
<line-31># return</line-31>
<line-32>#______________________________________________________</line-32>
<line-33>for _ in range(int(input())):</line-33>
<line-34> n,k = map(int,input().split())</line-34>
<line-35> d = [[] for i in range(k+1)]</line-35>
<line-36> for i in range(n):</line-36>
<line-37> l,r,p = map(int,input().split())</line-37>
<line-38> d[p].append([l,r])</line-38>
<line-39> ans = 0</line-39>
<line-40> for i in d:</line-40>
<line-41> if len(i)==0:</line-41>
<line-42> continue</line-42>
<line-43> ans+=1</line-43>
<line-44> t = sorted(i,key = lambda x:(x[1],x[0]))</line-44>
<line-45> final = t[0][1]</line-45>
<line-46> for j in range(1,len(t)):</line-46>
<line-47> if t[j][0]>=final:</line-47>
<line-48> ans+=1</line-48>
<line-50> print(ans) </line-50>
|
{"code": "<line-2># import math</line-2>\n<line-49> final = t[j][1]</line-49>", "lines": [2, 49]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> for i in range(int(input())):</line-3>
<line-4> n=int(input())</line-4>
<line-5> l=[int(j) for j in input().split()][:n]</line-5>
<line-6> d={}</line-6>
<line-7> for j in l:</line-7>
<line-8> d[j]=d.get(j,0)+1</line-8>
<line-9> a=len(d)</line-9>
<line-10> c=0</line-10>
<line-11> for j in list(d.keys()):</line-11>
<line-12> while(d[j]>=3):</line-12>
<line-13> d[j]=(d[j]//3)+(d[j]%3)</line-13>
<line-14> if(d[j]==2):</line-14>
<line-15> c=c+1</line-15>
<line-16> if(c&1):</line-16>
<line-17> s=0</line-17>
<line-18> for j in list(d.values()):</line-18>
<line-19> s=s+j</line-19>
<line-20> print(s-c-1)</line-20>
<line-21> else:</line-21>
<line-22> s=0</line-22>
<line-23> for j in list(d.values()):</line-23>
<line-24> s=s+j</line-24>
<line-25> print(s-c)</line-25>
<line-27> pass</line-27>
<line-28> </line-28>
|
{"code": "<line-2>try:</line-2>\n<line-26>except:</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>t=eval(input())</line-1>
<line-3> t=t-1</line-3>
<line-4> s1=input().lower()</line-4>
<line-5> s2=input().lower()</line-5>
<line-6> res="equal"</line-6>
<line-7> for i in range(len(s1)):</line-7>
<line-8> if(s1[i]!=s2[i]):</line-8>
<line-9> </line-9>
<line-10> res="first" if s1[i]<s2[i] else "second"</line-10>
<line-12> print(res)</line-12>
|
{"code": "<line-2>while t:</line-2>\n<line-11> break</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>def game(n,l,p):</line-1>
<line-3> return 0</line-3>
<line-4> l.sort()</line-4>
<line-5> if(len(l)>=1 and p<l[0]):</line-5>
<line-6> return 0</line-6>
<line-7> l.sort()</line-7>
<line-8> c=0</line-8>
<line-9> </line-9>
<line-10> </line-10>
<line-11> ma=set()</line-11>
<line-12> ma.add(0)</line-12>
<line-13> while(len(l)):</line-13>
<line-14> if(p>=l[0]):</line-14>
<line-15> p-=l[0]</line-15>
<line-16> </line-16>
<line-17> c+=1</line-17>
<line-18> ma.add(c)</line-18>
<line-19> l=l[1:]</line-19>
<line-20> else:</line-20>
<line-21> if(c>0):</line-21>
<line-22> c-=1</line-22>
<line-23> ma.add(c)</line-23>
<line-24> p+=l[-1]</line-24>
<line-25> l=l[:-1]</line-25>
<line-26> else:</line-26>
<line-27> return max(ma)</line-27>
<line-28> return max(ma)</line-28>
<line-29>n=int(input())</line-29>
<line-30>l=list(map(int,input().split()))</line-30>
<line-32>print(game(n,l,p))</line-32>
|
{"code": "<line-2> if(len(l)==0):</line-2>\n<line-31>p=int(input())</line-31>", "lines": [2, 31]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(x):</line-3>
<line-4> s=list(map(int,input().split()))</line-4>
<line-6> print(s[1])</line-6>
<line-7> </line-7>
<line-8> </line-8>
|
{"code": "<line-2>x=int(input())</line-2>\n<line-5> s.sort()</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>def __starting_point():</line-1>
<line-3> for _ in range(t):</line-3>
<line-4> n,k,v=map(int,input().split())</line-4>
<line-5> li=list(map(int,input().split()))</line-5>
<line-6> sumn=0</line-6>
<line-7> for i in range(n):</line-7>
<line-8> sumn=sumn+li[i]</line-8>
<line-9> sumk=v*(n+k)-sumn</line-9>
<line-10> e=int(sumk/k)</line-10>
<line-11> r=sumk%k</line-11>
<line-12> if e<=0:</line-12>
<line-13> print(-1)</line-13>
<line-14> elif r!=0:</line-14>
<line-15> print(-1)</line-15>
<line-16> else:</line-16>
<line-18>__starting_point()</line-18>
|
{"code": "<line-2> t=int(input())</line-2>\n<line-17> print(e)</line-17>", "lines": [2, 17]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>if(n%4==0):</line-3>
<line-4> print(n+1)</line-4>
<line-6> print(n-1)</line-6>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-5>else:</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>def matrixScore(A):</line-1>
<line-3> :type A: List[List[int]]</line-3>
<line-4> :rtype: int</line-4>
<line-5> """</line-5>
<line-6> m,n = len(A),len(A[0])</line-6>
<line-7> # 行变换</line-7>
<line-8> for i in range(m):</line-8>
<line-9> if A[i][0] == 1: continue</line-9>
<line-10> for j in range(n):</line-10>
<line-11> A[i][j] = 1 - A[i][j]</line-11>
<line-12></line-12>
<line-13> # 列变换</line-13>
<line-14> res = 0</line-14>
<line-15> for rows in zip(*A):</line-15>
<line-16> # 始终使1的个数是更大的</line-16>
<line-17> cnt1 = max(rows.count(1), rows.count(0))</line-17>
<line-18> res += cnt1 * 2**(n-1)</line-18>
<line-19> n -= 1</line-19>
<line-20> return res</line-20>
<line-21>m, n = [int(s) for s in input().split(" ")]</line-21>
<line-22>arr = [[int(s) for s in input().split(" ")] for i in range(m)]</line-22>
<line-24>print(ans)</line-24>
|
{"code": "<line-2> \"\"\"</line-2>\n<line-23>ans = matrixScore(arr)</line-23>", "lines": [2, 23]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(t):</line-3>
<line-4> n=int(input())</line-4>
<line-5> array=list(map(int, input().split()))</line-5>
<line-6> list_sub=[]</line-6>
<line-7> idx=0</line-7>
<line-8> counter=0</line-8>
<line-9> for i in range(n-1):</line-9>
<line-10> if counter%2==0 and array[i]<=array[i+1]:</line-10>
<line-11> counter+=1 </line-11>
<line-12> elif counter%2==1 and array[i]>=array[i+1]:</line-12>
<line-13> counter+=1 </line-13>
<line-14> else:</line-14>
<line-15> list_sub.append((idx,i))</line-15>
<line-16> if counter%2==1:</line-16>
<line-17> idx=i </line-17>
<line-18> counter=1</line-18>
<line-19> else:</line-19>
<line-20> idx=i+1 </line-20>
<line-21> counter=0</line-21>
<line-22> list_sub.append((idx, n-1))</line-22>
<line-23> massimo=0</line-23>
<line-24> if len(list_sub)==1:</line-24>
<line-25> massimo=list_sub[0][1]-list_sub[0][0]+2</line-25>
<line-26> for i in range(len(list_sub)-1):</line-26>
<line-27> if list_sub[i][1]==list_sub[i+1][0]:</line-27>
<line-28> massimo=max(massimo, list_sub[i][1]-list_sub[i][0]+2+list_sub[i+1][1]-list_sub[i+1][0])</line-28>
<line-29> else:</line-29>
<line-31> print(massimo)</line-31>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-30> massimo=max(massimo, list_sub[i][1]-list_sub[i][0]+3+list_sub[i+1][1]-list_sub[i+1][0])</line-30>", "lines": [2, 30]}
#### 0
|
<line-1>#binarr</line-1>
<line-3> a.sort(reverse=True)</line-3>
<line-4> arr = [0]*k</line-4>
<line-5> for i in range(k):</line-5>
<line-6> arr[i] = a[i]</line-6>
<line-7> if sum(arr) <= s:</line-7>
<line-8> return binarr(a, k+1, s)</line-8>
<line-9> return len(arr)</line-9>
<line-10></line-10>
<line-11>try:</line-11>
<line-12> n, k, s = list(map(int, input().split()))</line-12>
<line-13> a = list(map(int, input().split()))</line-13>
<line-14> print(binarr(a, k+1, s))</line-14>
<line-16> pass</line-16>
|
{"code": "<line-2>def binarr(a, k, s):</line-2>\n<line-15>except Exception:</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> if n == 1 or n == 2 or n == 145 or n == 40585:</line-4>
<line-5> print(1)</line-5>
<line-7> print(0)</line-7>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-6> else:</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>try:</line-1>
<line-3> t,x=list(map(int,input().split()))</line-3>
<line-4> for _ in range(t):</line-4>
<line-5> n=int(input())</line-5>
<line-6> if(n<0):</line-6>
<line-7> print("no")</line-7>
<line-8> else:</line-8>
<line-9> diff=(x/100)*n</line-9>
<line-10> ans=int(sqrt(n))</line-10>
<line-11> ans1=ans**2</line-11>
<line-12> if(n-ans1<=diff):</line-12>
<line-13> print("yes")</line-13>
<line-14> else:</line-14>
<line-15> print("no")</line-15>
<line-17> pass</line-17>
|
{"code": "<line-2> from math import sqrt</line-2>\n<line-16>except:</line-16>", "lines": [2, 16]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> d = int(input().strip())</line-3>
<line-4> L, R = map(int, input().strip().split(" "))</line-4>
<line-5> if L % 2 == 0:</line-5>
<line-6> L += 1</line-6>
<line-7> sum = (((((R - L + 2)//2)//d)+1)//2) - 1</line-7>
<line-9> print(sum%1000000007)</line-9>
|
{"code": "<line-2>for t in range(int(input().strip())):</line-2>\n<line-8> sum = (sum * 2 * d * (sum + 1) * d) + (sum+1) *d * (L + d -1)</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>def least_rotation(S: str) -> int:</line-1>
<line-3> f = [-1] * len(S) # Failure function</line-3>
<line-4> k = 0 # Least rotation of string found so far</line-4>
<line-5> for j in range(1, len(S)):</line-5>
<line-6> sj = S[j]</line-6>
<line-7> i = f[j - k - 1]</line-7>
<line-8> while i != -1 and sj != S[k + i + 1]:</line-8>
<line-9> if sj < S[k + i + 1]:</line-9>
<line-10> k = j - i - 1</line-10>
<line-11> i = f[i]</line-11>
<line-12> if sj != S[k + i + 1]: # if sj != S[k+i+1], then i == -1</line-12>
<line-13> if sj < S[k]: # k+i+1 = k</line-13>
<line-14> k = j</line-14>
<line-15> f[j - k] = -1</line-15>
<line-16> else:</line-16>
<line-17> f[j - k] = i + 1</line-17>
<line-18> return k</line-18>
<line-19></line-19>
<line-20></line-20>
<line-21>for _ in range(int(input())):</line-21>
<line-22> l, s = input().split()</line-22>
<line-23> if int(l) == 1:</line-23>
<line-24> l = len(s)</line-24>
<line-25> s += s</line-25>
<line-26> k = least_rotation(s)</line-26>
<line-27> print(s[k:k+l])</line-27>
<line-29> print(''.join(sorted(s)))</line-29>
|
{"code": "<line-2> \"\"\"Booth's algorithm.\"\"\"</line-2>\n<line-28> else:</line-28>", "lines": [2, 28]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3></line-3>
<line-4>fball = [ [0]*101 for _ in range(101) ]</line-4>
<line-5></line-5>
<line-6>cric = [ [0]*101 for _ in range(101) ] </line-6>
<line-7></line-7>
<line-8></line-8>
<line-9></line-9>
<line-10>def calSNum(n, r):</line-10>
<line-11> if n == r or r == 1:</line-11>
<line-12> fball[r][n] = 1</line-12>
<line-13> return</line-13>
<line-14> if n > 0 and r > 0 and n > r:</line-14>
<line-15> fball[r][n] = (fball[r-1][n-1]%MOD + (r*fball[r][n-1])%MOD )%MOD</line-15>
<line-16> return</line-16>
<line-17> fball[r][n] = 0</line-17>
<line-18> </line-18>
<line-19></line-19>
<line-20>def calASNum(n, r):</line-20>
<line-21> if n == 0 and r == 0 :</line-21>
<line-22> cric[r][n] = 0</line-22>
<line-23> return</line-23>
<line-24> if n >= 2 and r == 1:</line-24>
<line-25> cric[r][n] = 1</line-25>
<line-26> return </line-26>
<line-27> if r > 0 and n > 0 and n >= 2*r:</line-27>
<line-28> cric[r][n] = ((r*cric[r][n-1])%MOD + ((n-1)*cric[r-1][n-2])%MOD )%MOD</line-28>
<line-29> return</line-29>
<line-30> cric[r][n] = 0</line-30>
<line-31> </line-31>
<line-32></line-32>
<line-33>def preCompute():</line-33>
<line-34> for r in range(1,101):</line-34>
<line-35> for n in range(1, 101):</line-35>
<line-36> calSNum(n, r)</line-36>
<line-37> calASNum(n, r)</line-37>
<line-38></line-38>
<line-39> </line-39>
<line-40>def main():</line-40>
<line-41> </line-41>
<line-42> preCompute()</line-42>
<line-43> for _ in range(int(input())):</line-43>
<line-44> f, c, r = list(map(int, input().split()))</line-44>
<line-45></line-45>
<line-46> ans = 0</line-46>
<line-47> </line-47>
<line-48> if f + (c//2) >= r:</line-48>
<line-49> minv = min(f, r)</line-49>
<line-50> </line-50>
<line-51> for i in range(1, minv+1):</line-51>
<line-52> if r-i <= c//2:</line-52>
<line-53> ans = (ans + (fball[i][f] * cric[r-i][c])%MOD )%MOD</line-53>
<line-54> </line-54>
<line-55> print(ans)</line-55>
<line-56> </line-56>
<line-57>def __starting_point():</line-57>
<line-59></line-59>
<line-60>__starting_point()</line-60>
|
{"code": "<line-2>MOD = 998244353</line-2>\n<line-58> main()</line-58>", "lines": [2, 58]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(t):</line-3>
<line-4> n,m=list(map(int,input().split()))</line-4>
<line-5> r=list(map(int,input().split()))</line-5>
<line-6> rating=[[r[i]]*(m) for i in range(n)]</line-6>
<line-7> ranking=[[0]*m for i in range(n)]</line-7>
<line-8> for i in range(n):</line-8>
<line-9> diff=list(map(int,input().split()))</line-9>
<line-10> for j in range(m):</line-10>
<line-11> rating[i][j]+=diff[j]</line-11>
<line-12> if j+1<m:</line-12>
<line-13> rating[i][j+1]=rating[i][j]</line-13>
<line-14> </line-14>
<line-15> for i in range(m):</line-15>
<line-16> rate=[[j,rating[j][i]] for j in range(n)]</line-16>
<line-17> rate=sorted(rate,key=lambda x: x[1],reverse=True)</line-17>
<line-18> c=1</line-18>
<line-19> gap=0</line-19>
<line-20> for j in range(n):</line-20>
<line-21> if j>0 and rate[j-1][1]==rate[j][1]:</line-21>
<line-22> gap+=1</line-22>
<line-23> if j>0 and rate[j-1][1]!=rate[j][1]:</line-23>
<line-24> c+=1+gap</line-24>
<line-25> gap=0</line-25>
<line-26> ranking[rate[j][0]][i]=c </line-26>
<line-27> </line-27>
<line-28> count=0</line-28>
<line-29> for i in range(n):</line-29>
<line-30> rate=rating[i].copy()</line-30>
<line-31> i1=rate.index(max(rate))</line-31>
<line-32> rank=ranking[i].copy()</line-32>
<line-33> i2=rank.index(min(rank))</line-33>
<line-34> if i1!=i2:</line-34>
<line-36> print(count)</line-36>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-35> count+=1</line-35>", "lines": [2, 35]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>for _ in range(t):</line-5>
<line-6> s = ''</line-6>
<line-7> n = int(input())</line-7>
<line-8> if n==1:</line-8>
<line-9> print(1)</line-9>
<line-10> continue</line-10>
<line-11> for i in range(1, n+1):</line-11>
<line-12> s = s + str(i)</line-12>
<line-13> print(s)</line-13>
<line-14> </line-14>
<line-15> p = 1</line-15>
<line-16> for i in range(n-1):</line-16>
<line-17> s = ''</line-17>
<line-18> for j in range(n):</line-18>
<line-19> s = s + str(p + n)</line-19>
<line-21> </line-21>
<line-22> print(s)</line-22>
<line-23> </line-23>
|
{"code": "<line-3>t = int(input())</line-3>\n<line-20> p = p+1</line-20>", "lines": [3, 20]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> nd = list(map(int, input().split()))</line-3>
<line-4> n = nd[0]</line-4>
<line-5> d = nd[1]</line-5>
<line-6> cutOff = []</line-6>
<line-7> x = d</line-7>
<line-8> buses = list(map(int, input().split()))</line-8>
<line-9> for i in range(len(buses)-1,-1,-1):</line-9>
<line-11> print(x)</line-11>
<line-12></line-12>
<line-13></line-13>
<line-14></line-14>
<line-15></line-15>
<line-16></line-16>
<line-17></line-17>
<line-18></line-18>
<line-19></line-19>
<line-20></line-20>
<line-21></line-21>
<line-22></line-22>
<line-23> </line-23>
<line-24></line-24>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-10> x = x - x%buses[i]</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>def max_sum(arr):</line-1>
<line-3> max_till_now = -1000000 #minimum possible number </line-3>
<line-4> current_sum = 0</line-4>
<line-5> for i in range(len(arr)):</line-5>
<line-6> if current_sum < 0:</line-6>
<line-7> # If sum of previous elements is negative, then ignore them. Start fresh</line-7>
<line-8> # with `current_sum = 0`</line-8>
<line-9> current_sum = 0</line-9>
<line-10> </line-10>
<line-11> current_sum += arr[i]</line-11>
<line-12> </line-12>
<line-13> # Update max</line-13>
<line-14> if max_till_now < current_sum:</line-14>
<line-15> max_till_now = current_sum</line-15>
<line-16> </line-16>
<line-17> return max_till_now</line-17>
<line-18></line-18>
<line-19></line-19>
<line-20>def solve(A, k):</line-20>
<line-21> if k == 1:</line-21>
<line-22> return max_sum(A)</line-22>
<line-23> # Find sum of elements of A</line-23>
<line-24> sum_A = 0</line-24>
<line-25> for i in range(len(A)):</line-25>
<line-26> sum_A += A[i]</line-26>
<line-27> </line-27>
<line-28> Max_Suffix_Sum = -1000000</line-28>
<line-29> current = 0</line-29>
<line-30> for i in range(len(A)):</line-30>
<line-31> current += A[-i-1]</line-31>
<line-32> if current > Max_Suffix_Sum:</line-32>
<line-33> Max_Suffix_Sum = current</line-33>
<line-34></line-34>
<line-35> Max_Prefix_Sum = -1000000</line-35>
<line-36> current = 0</line-36>
<line-37> for i in range(len(A)):</line-37>
<line-38> current += A[i]</line-38>
<line-39> if current > Max_Prefix_Sum:</line-39>
<line-40> Max_Prefix_Sum = current</line-40>
<line-41></line-41>
<line-42> if sum_A <= 0:</line-42>
<line-43> # Check two cases:</line-43>
<line-44></line-44>
<line-45> # Case 1 : Check the max_sum of A</line-45>
<line-46> case_1_max_sum = max_sum(A)</line-46>
<line-47> </line-47>
<line-48> # Case 2 : Check the max_sum of A + A</line-48>
<line-49> case_2_max_sum = Max_Suffix_Sum + Max_Prefix_Sum</line-49>
<line-50></line-50>
<line-51> # Return the maximum of the two cases</line-51>
<line-52> return max([case_1_max_sum, case_2_max_sum])</line-52>
<line-53></line-53>
<line-54> else: # if sum_A > 0</line-54>
<line-55> #Check two cases:</line-55>
<line-56></line-56>
<line-57> # Case 1 : Check the max_sum of A</line-57>
<line-58> case_1_max_sum = max_sum(A)</line-58>
<line-59></line-59>
<line-60> # Case 2</line-60>
<line-61> # Max sum = Max_Suffix_Sum + (k - 2)*sum_A + Max_Prefix_Sum </line-61>
<line-62> </line-62>
<line-63> case_2_max_sum = Max_Suffix_Sum + (k - 2)*sum_A + Max_Prefix_Sum</line-63>
<line-64> </line-64>
<line-65> # Return the maximum of the two cases</line-65>
<line-66> return max([case_1_max_sum, case_2_max_sum])</line-66>
<line-67></line-67>
<line-68></line-68>
<line-69># Main</line-69>
<line-70>T = int(input()) # No of test cases</line-70>
<line-71>for i in range(T):</line-71>
<line-72> [N, k] = list(map(int, input().split(" ")))</line-72>
<line-73> A = list(map(int, input().split(" ")))</line-73>
<line-74> </line-74>
<line-76> print(answer)</line-76>
|
{"code": "<line-2> # Finds the maximum sum of sub-arrays of arr</line-2>\n<line-75> answer = solve(A,k)</line-75>", "lines": [2, 75]}
#### 0
|
<line-1>T = int(input())</line-1>
<line-3> N, M, K = [int(x) for x in input().split()]</line-3>
<line-4> UV = [[int(x) for x in input().split()] for _ in range(M)]</line-4>
<line-5> Q = int(input())</line-5>
<line-6> AB = [[int(x) for x in input().split()] for _ in range(Q)]</line-6>
<line-7> </line-7>
<line-8> X = [[i] for i in range(N)]</line-8>
<line-9> for u, v in UV:</line-9>
<line-10> X[u - 1] += [v - 1]</line-10>
<line-11> X[v - 1] += [u - 1]</line-11>
<line-12> </line-12>
<line-13> A = [[1 if i > 0 or j == 0 else 0 for j in range(N)] for i in range(K + 1)]</line-13>
<line-14> for a, b in AB:</line-14>
<line-15> A[b] = [1 if i == a - 1 else 0 for i in range(N)]</line-15>
<line-16> </line-16>
<line-17> if A[0][0] == 1:</line-17>
<line-18> for k in range(K - 1, -1, -1):</line-18>
<line-19> for i in range(N):</line-19>
<line-20> if A[k][i] != 0:</line-20>
<line-22> </line-22>
<line-23> print(A[0][0])</line-23>
|
{"code": "<line-2>for _ in range(T):</line-2>\n<line-21> A[k][i] = sum(A[k + 1][j] for j in X[i])</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>def gcd(a,b):</line-1>
<line-3> return a</line-3>
<line-4> else:</line-4>
<line-5> return gcd(b,a%b)</line-5>
<line-6> </line-6>
<line-7>def main():</line-7>
<line-8> t=int(input())</line-8>
<line-9> while t!=0:</line-9>
<line-10> t=t-1</line-10>
<line-11> n=int(input())</line-11>
<line-12> if n==1:</line-12>
<line-13> print(input())</line-13>
<line-14> else:</line-14>
<line-15> a=list(map(int,input().split(" ")))</line-15>
<line-16> p=a[0]</line-16>
<line-17> for i in range(1,n):</line-17>
<line-18> p=gcd(p,a[i])</line-18>
<line-19> if p==1:</line-19>
<line-20> break</line-20>
<line-21> print(n*p)</line-21>
<line-22>def __starting_point():</line-22>
<line-24> </line-24>
<line-25> </line-25>
<line-26></line-26>
<line-27>__starting_point()</line-27>
|
{"code": "<line-2> if b==0:</line-2>\n<line-23> main()</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> l1=list(map(int,input().split()))</line-3>
<line-4> l2=list(map(int,input().split()))</line-4>
<line-5> m=[]</line-5>
<line-6> n=[]</line-6>
<line-7> for i in range(len(l1)):</line-7>
<line-8> if l2[i]==0:</line-8>
<line-9> m.append(l1[i])</line-9>
<line-10> else:</line-10>
<line-11> n.append(l1[i])</line-11>
<line-12> if len(m)>0 and len(n)>0:</line-12>
<line-13> if 100-s>=(min(m)+min(n)):</line-13>
<line-14> print("yes")</line-14>
<line-15> else:</line-15>
<line-16> print("no")</line-16>
<line-18> print("no")</line-18>
|
{"code": "<line-2> n,s =map(int,input().split())</line-2>\n<line-17> else:</line-17>", "lines": [2, 17]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(int(input())):</line-3>
<line-4> x1,y1,x2,y2=list(map(float,input().split()))</line-4>
<line-5> m=(y2-y1)/(x2-x1)</line-5>
<line-6> c=y2-m*x2</line-6>
<line-7> print('Test case : ',i+1)</line-7>
<line-8> q=int(input())</line-8>
<line-9> for i in range(q):</line-9>
<line-10> x3,y3=list(map(float,input().split()))</line-10>
<line-11> if(y3-m*x3-c==0):</line-11>
<line-12> print("YES")</line-12>
<line-13> else:</line-13>
<line-14> d=(abs(y3-m*x3-c))/sqrt(1+m*m)</line-14>
<line-16> print("%.6f" % d)</line-16>
|
{"code": "<line-2>from math import sqrt</line-2>\n<line-15> print(\"NO\")</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>from math import gcd</line-1>
<line-3>from itertools import combinations as c</line-3>
<line-4>t=int(input())</line-4>
<line-5>for _ in range(t):</line-5>
<line-6> n,m,a,d=list(map(int,input().split()))</line-6>
<line-7> </line-7>
<line-8> l=[]</line-8>
<line-9> for i in range(5):</line-9>
<line-10> l.append(a+i*d)</line-10>
<line-11> ans=m-n+1</line-11>
<line-12> for i in range(1,6):</line-12>
<line-13> x=list(c(l,i))</line-13>
<line-14> for j in x:</line-14>
<line-15> e=j[0]</line-15>
<line-16> for v in j:</line-16>
<line-17> e=(e*v)//gcd(e,v)</line-17>
<line-18> #print(e)</line-18>
<line-19> if i%2:</line-19>
<line-20> ans-=m//e-(n-1)//e</line-20>
<line-21> else:</line-21>
<line-23> print(ans)</line-23>
<line-24> </line-24>
<line-25> </line-25>
|
{"code": "<line-2>from math import ceil</line-2>\n<line-22> ans+=m//e-(n-1)//e</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>import numpy as np</line-1>
<line-3> ans = np.float('inf')</line-3>
<line-4> n, m = (int(x) for x in input().split())</line-4>
<line-5> sig = np.zeros((n,m))</line-5>
<line-6> img = np.zeros((3*n,3*m))</line-6>
<line-7> for row in range(n):</line-7>
<line-8> sig[row,:] = np.array([int(x) for x in input()])</line-8>
<line-9> for row in range(n):</line-9>
<line-10> img[row+n,m:2*m] = np.array([int(x) for x in input()])</line-10>
<line-11> for i in range(2*n):</line-11>
<line-12> for j in range(2*m):</line-12>
<line-14> print(ans)</line-14>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-13> ans = min(ans, np.abs(np.sum(img[i:n+i, j:m+j] != sig)))</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>import math</line-1>
<line-3> return math.ceil(math.log(y,2))==math.floor(math.log(y,2))</line-3>
<line-4>t=int(input())</line-4>
<line-5>for i in range(t):</line-5>
<line-6> n=int(input())</line-6>
<line-7> </line-7>
<line-8> a=[]</line-8>
<line-9> if(ispoweroftwo(n) and n!=1):</line-9>
<line-10> print(-1,end=" ")</line-10>
<line-11> if(n==1):</line-11>
<line-12> print(1)</line-12>
<line-13> </line-13>
<line-14> if(n>=3 and not(ispoweroftwo(n))):</line-14>
<line-15> a.append(2)</line-15>
<line-16> a.append(3)</line-16>
<line-17> a.append(1)</line-17>
<line-18> if(n>3 and not ispoweroftwo(n)):</line-18>
<line-19> i=4</line-19>
<line-20> while(i<=n):</line-20>
<line-21> if(ispoweroftwo(i)):</line-21>
<line-22> a.append(i+1)</line-22>
<line-23> a.append(i)</line-23>
<line-24> i+=2</line-24>
<line-25> else:</line-25>
<line-26> a.append(i)</line-26>
<line-28> print(*a)</line-28>
<line-29> </line-29>
|
{"code": "<line-2>def ispoweroftwo(y):</line-2>\n<line-27> i+=1</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>from collections import Counter</line-1>
<line-2></line-2>
<line-4> n=int(input())</line-4>
<line-5> l=[i for i in input().split()]</line-5>
<line-6> ll=[]</line-6>
<line-7> c=Counter(l)</line-7>
<line-8> cc=[]</line-8>
<line-9> m=0</line-9>
<line-10> for l,count in c.most_common(len(l)-1):</line-10>
<line-11> if m==0:</line-11>
<line-12> ll.append(l)</line-12>
<line-13> cc.append(count)</line-13>
<line-14> </line-14>
<line-15> if m==count:</line-15>
<line-16> ll.append(l)</line-16>
<line-17> cc.append(count)</line-17>
<line-18> if count<m:</line-18>
<line-19> break</line-19>
<line-20> m=count</line-20>
<line-21> k=set(cc)</line-21>
<line-22> leng=len(list(k))</line-22>
<line-23> if leng==1:</line-23>
<line-24> sor=sorted(ll)</line-24>
<line-25> print(sor[0])</line-25>
<line-27> print(ll[0])</line-27>
|
{"code": "<line-3>for _ in range(int(input())):</line-3>\n<line-26> else:</line-26>", "lines": [3, 26]}
#### 0
|
<line-1>import sys</line-1>
<line-3>a,b,c = list(map(int,sys.stdin.readline().split()))</line-3>
<line-5>print(d.strftime("%A"))</line-5>
|
{"code": "<line-2>import datetime</line-2>\n<line-4>d = datetime.date(c,b,a)</line-4>", "lines": [2, 4]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>while test_case :</line-3>
<line-4> n_people = int(input())</line-4>
<line-5> array = list(map(int, input().strip().split()))</line-5>
<line-6> sums =[0 for i in range(n_people)]</line-6>
<line-7> </line-7>
<line-8> sums[0] = array[0]</line-8>
<line-9> </line-9>
<line-10> for i in range(1, n_people) :</line-10>
<line-11> sums[i] = sums[i-1] + array[i]</line-11>
<line-12> </line-12>
<line-13> # print(sums)</line-13>
<line-14></line-14>
<line-15> k = 1 </line-15>
<line-16> count = 0</line-16>
<line-17> i = 0 </line-17>
<line-18> while(k < n_people) :</line-18>
<line-19> k = k + sums[i]</line-19>
<line-20> # print(k)</line-20>
<line-21> i = i + sums[i]</line-21>
<line-22> count = count + 1</line-22>
<line-23> print(count)</line-23>
<line-24> </line-24>
<line-25> </line-25>
<line-26> test_case -= 1</line-26>
<line-27> </line-27>
<line-28> # 2 1 1 5 5 5 5</line-28>
<line-30> # 0 1 2 3 4 5 6 </line-30>
<line-31> </line-31>
<line-32> </line-32>
<line-33> </line-33>
<line-34> </line-34>
<line-35> </line-35>
<line-36> </line-36>
<line-37> </line-37>
<line-38> </line-38>
|
{"code": "<line-2>test_case = int(input())</line-2>\n<line-29> # [2, 3, 4, 9, 14, 19, 24]</line-29>", "lines": [2, 29]}
#### 0
|
<line-1>t=eval(input())</line-1>
<line-2> </line-2>
<line-4>b=[]</line-4>
<line-5> </line-5>
<line-6>top=-1</line-6>
<line-7> </line-7>
<line-8>for __ in range(0,t):</line-8>
<line-9> </line-9>
<line-10> x=input().split()</line-10>
<line-11> </line-11>
<line-12> if(x[0]!="-1" and x[0]!="0"):</line-12>
<line-13> </line-13>
<line-14> add=int(x[0])</line-14>
<line-15> </line-15>
<line-16> if top!=-1 and add>a[top][0] :</line-16>
<line-17> </line-17>
<line-18> b[top]+=1</line-18>
<line-19> </line-19>
<line-20> else:</line-20>
<line-21> a.append((add,x[1]))</line-21>
<line-22> </line-22>
<line-23> b.append(0)</line-23>
<line-24> top+=1</line-24>
<line-25> </line-25>
<line-26> </line-26>
<line-27> elif (x[0]=="-1"):</line-27>
<line-28> </line-28>
<line-29> #print("%s %s" %(b[top],a[top][1]))</line-29>
<line-30> print((b[top]), end=' ')</line-30>
<line-31> print(a[top][1])</line-31>
<line-32> foo=a.pop()</line-32>
<line-34> top-=1</line-34>
|
{"code": "<line-3>a=[]</line-3>\n<line-33> bar=b.pop()</line-33>", "lines": [3, 33]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3>ans = []</line-3>
<line-4>for i in range(t):</line-4>
<line-5> (n,m) = tuple(map(int,input().split()))</line-5>
<line-6> a = list(map(int,input().split()))</line-6>
<line-7> b = list(map(int,input().split()))</line-7>
<line-8> suma = sum(a)</line-8>
<line-9> sumb = sum(b)</line-9>
<line-10> q = int(input())</line-10>
<line-11> for j in range(q):</line-11>
<line-12> l1 = list(map(int,input().split()))</line-12>
<line-13> if l1[0] == 1:</line-13>
<line-14> l = l1[1]</line-14>
<line-15> r = l1[2]</line-15>
<line-16> x = l1[3]</line-16>
<line-17> suma = suma + (r-l+1)*x</line-17>
<line-18> elif l1[0] == 2:</line-18>
<line-19> l = l1[1]</line-19>
<line-20> r = l1[2]</line-20>
<line-21> x = l1[3]</line-21>
<line-22> sumb = sumb + (r-l+1)*x</line-22>
<line-23> else:</line-23>
<line-24> ans.append((suma*sumb)%998244353)</line-24>
<line-26> print(ans[i])</line-26>
|
{"code": "<line-2>l,r,x = 0,0,0</line-2>\n<line-25>for i in range(len(ans)):</line-25>", "lines": [2, 25]}
#### 0
|
<line-1></line-1>
<line-2>from math import ceil</line-2>
<line-4>from bisect import bisect_left as b_l</line-4>
<line-5>ar = list(map(int , input().split()))</line-5>
<line-6>a = [int(ceil((ar[1]-int(x)+1)/ar[2])) for x in input().split()]</line-6>
<line-7>s = sum(a)</line-7>
<line-8>ar[1] = max(a)</line-8>
<line-9>m = ar[1] - (s-ar[1])%2</line-9>
<line-11>print(int( (m-mi)//2 +1)%(10**9+7))</line-11>
<line-12></line-12>
|
{"code": "<line-3>from bisect import bisect_right as b_r</line-3>\n<line-10>mi = s%2 </line-10>", "lines": [3, 10]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3></line-3>
<line-4>l,r=-1,-1</line-4>
<line-5>for i in range(n):</line-5>
<line-6> if a[i]!=i+1:</line-6>
<line-7> l=i</line-7>
<line-8> break</line-8>
<line-9></line-9>
<line-10>for i in range(n-1,-1,-1):</line-10>
<line-11> if a[i]!=i+1:</line-11>
<line-12> r=i</line-12>
<line-13> break</line-13>
<line-14></line-14>
<line-15>j=r+1</line-15>
<line-16></line-16>
<line-17>for i in range(l,r+1):</line-17>
<line-18> if a[i]==j:</line-18>
<line-19> j-=1</line-19>
<line-20> continue</line-20>
<line-21> else:</line-21>
<line-22> print(0,0)</line-22>
<line-24></line-24>
<line-25>print(l+1,r+1)</line-25>
|
{"code": "<line-2>a=list(map(int,input().split()))</line-2>\n<line-23> return</line-23>", "lines": [2, 23]}
#### 0
|
<line-2>a = int(input())</line-2>
<line-3>print(a)</line-3>
|
{"code": "<line-1># cook your dish here</line-1>", "lines": [1]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> </line-3>
<line-4># Function to find the Largest </line-4>
<line-5># Odd Divisor Game to check </line-5>
<line-6># which player wins </line-6>
<line-7>def findWinner(n, k): </line-7>
<line-8> </line-8>
<line-9> cnt = 0; </line-9>
<line-10> </line-10>
<line-11> # Check if n == 1 then </line-11>
<line-12> # player 2 will win </line-12>
<line-13> if (n == 1): </line-13>
<line-14> print("Grinch"); </line-14>
<line-15> </line-15>
<line-16> # Check if n == 2 or n is odd </line-16>
<line-17> elif ((n & 1) or n == 2): </line-17>
<line-18> print("Me"); </line-18>
<line-19> </line-19>
<line-20> else: </line-20>
<line-21> tmp = n; </line-21>
<line-22> val = 1; </line-22>
<line-23> </line-23>
<line-24> # While n is greater than k and </line-24>
<line-25> # divisible by 2 keep </line-25>
<line-26> # incrementing tha val </line-26>
<line-27> while (tmp > k and tmp % 2 == 0): </line-27>
<line-28> tmp //= 2; </line-28>
<line-29> val *= 2; </line-29>
<line-30> </line-30>
<line-31> # Loop to find greatest </line-31>
<line-32> # odd divisor </line-32>
<line-33> for i in range(3, int(math.sqrt(tmp)) + 1): </line-33>
<line-34> while (tmp % i == 0): </line-34>
<line-35> cnt += 1; </line-35>
<line-36> tmp //= i; </line-36>
<line-37> </line-37>
<line-38> if (tmp > 1): </line-38>
<line-39> cnt += 1; </line-39>
<line-40> </line-40>
<line-41> # Check if n is a power of 2 </line-41>
<line-42> if (val == n): </line-42>
<line-43> print("Grinch"); </line-43>
<line-44> </line-44>
<line-45> elif (n / tmp == 2 and cnt == 1): </line-45>
<line-46> print("Grinch"); </line-46>
<line-47> </line-47>
<line-48> # Check if cnt is not one </line-48>
<line-49> # then player 1 wins </line-49>
<line-50> else: </line-50>
<line-51> print("Me"); </line-51>
<line-52> </line-52>
<line-53># Driver code </line-53>
<line-54>def __starting_point(): </line-54>
<line-55> for i in range(int(input())):</line-55>
<line-56> n=int(input()) </line-56>
<line-58>__starting_point()</line-58>
|
{"code": "<line-2>import math </line-2>\n<line-57> findWinner(n, 1); </line-57>", "lines": [2, 57]}
#### 0
|
<line-1># https://www.codechef.com/problems/RECTLIT</line-1>
<line-2></line-2>
<line-4> EWct = 0</line-4>
<line-5> NSct = 0</line-5>
<line-6> for a,b in points:</line-6>
<line-7> EW = (a == 0 or a == sq)</line-7>
<line-8> NS = (b == 0 or b == sq)</line-8>
<line-9> if EW and NS:</line-9>
<line-10> return 'yes'</line-10>
<line-11> EWct += EW</line-11>
<line-12> NSct += NS</line-12>
<line-13> if NSct + EWct == 0 or len(points) == 1:</line-13>
<line-14> return 'no'</line-14>
<line-15> if EWct >= 2 or NSct >= 2:</line-15>
<line-16> return 'yes'</line-16>
<line-17> if len(points) == 2:</line-17>
<line-18> return 'no'</line-18>
<line-19> # now 3 points</line-19>
<line-20> if NSct == 1 and EWct == 1:</line-20>
<line-21> return 'yes'</line-21>
<line-22> # 3 points, one on edge</line-22>
<line-23> x = -1</line-23>
<line-24> for a,b in points:</line-24>
<line-25> if EWct > 0:</line-25>
<line-26> if a == 0 or a == sq:</line-26>
<line-27> e = b</line-27>
<line-28> elif x == -1:</line-28>
<line-29> x = b</line-29>
<line-30> else:</line-30>
<line-31> y = b</line-31>
<line-32> else:</line-32>
<line-33> if b == 0 or b == sq:</line-33>
<line-34> e = a</line-34>
<line-35> elif x == -1:</line-35>
<line-36> x = a</line-36>
<line-37> else:</line-37>
<line-38> y = a</line-38>
<line-39> if (e-x)*(e-y) < 0: # edge splits mids</line-39>
<line-40> return 'no'</line-40>
<line-41> else:</line-41>
<line-42> return 'yes'</line-42>
<line-43></line-43>
<line-44></line-44>
<line-45>for ti in range(int(input())):</line-45>
<line-46> k,n = map(int, input().split())</line-46>
<line-47> if k > 3:</line-47>
<line-48> for ki in range(k):</line-48>
<line-49> input()</line-49>
<line-50> print('yes')</line-50>
<line-51> else:</line-51>
<line-53> print(assess(n-1,pos))</line-53>
<line-54></line-54>
|
{"code": "<line-3>def assess(sq,points):</line-3>\n<line-52> pos = [tuple(map(int, input().split())) for ki in range(k)]</line-52>", "lines": [3, 52]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.