question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1>for j in range(int(input())):</line-1>
<line-3> a = list(map(int,input().split()))</line-3>
<line-4> marks = 0</line-4>
<line-5> backlok = 0</line-5>
<line-6> top_marks = max(a)</line-6>
<line-7> topper = []</line-7>
<line-8> for i in range(len(a)):</line-8>
<line-9> if(a[i] >= 31):</line-9>
<line-10> marks+=a[i]</line-10>
<line-11> if(a[i]<31):</line-11>
<line-12> backlok+=1</line-12>
<line-13> if(a[i] == top_marks):</line-13>
<line-14> topper.append(i)</line-14>
<line-15> print(backlok, "{:0.2f}".format(marks/len(a),2))</line-15>
<line-16> topper.sort(reverse=True)</line-16>
<line-17> for i in topper:</line-17>
<line-18> print(i," ")</line-18>
<line-20> print(top_marks-i)</line-20>
<line-21></line-21>
|
{"code": "<line-2> input()</line-2>\n<line-19> for i in a:</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>ip = sys.stdin </line-4>
<line-5></line-5>
<line-6>def solve(C, n, x):</line-6>
<line-7> if n==1:</line-7>
<line-8> return (1, 0)</line-8>
<line-9></line-9>
<line-10> b1, b2 = 1, 1</line-10>
<line-11> a , b = C[0], C[-1]</line-11>
<line-12> while b1 + b2 < n:</line-12>
<line-13> if a < b*x:</line-13>
<line-14> a += C[b1]</line-14>
<line-15> b1 += 1</line-15>
<line-16> elif a > b*x:</line-16>
<line-17> b2 += 1</line-17>
<line-18> b += C[n-b2] </line-18>
<line-19> else:</line-19>
<line-20> if b1 >= b2:</line-20>
<line-21> a += C[b1]</line-21>
<line-22> b1 += 1</line-22>
<line-23> else:</line-23>
<line-24> b2 += 1</line-24>
<line-25> b += C[b2]</line-25>
<line-26> return (b1, b2)</line-26>
<line-27></line-27>
<line-28>t = int(ip.readline())</line-28>
<line-29></line-29>
<line-30>for _ in range(t):</line-30>
<line-31> n = int(ip.readline())</line-31>
<line-32> C = list(map(int, ip.readline().split()))</line-32>
<line-33> x = int(ip.readline())</line-33>
<line-34></line-34>
<line-36> print(*ans)</line-36>
|
{"code": "<line-3># stdin = open(\"testdata.txt\", \"r\")</line-3>\n<line-35> ans = solve(C, n, x)</line-35>", "lines": [3, 35]}
#### 0
|
<line-1>from itertools import permutations</line-1>
<line-2></line-2>
<line-4> N,K=list(map(int,input().split()))</line-4>
<line-5> arr=list(map(int,input().split()))</line-5>
<line-6> arr1=[]</line-6>
<line-7> arr2=[]</line-7>
<line-8> for i in range(1,len(arr)+1):</line-8>
<line-9> arr1.append(i)</line-9>
<line-10> indexzero=[]</line-10>
<line-11> for i in range(0,len(arr)):</line-11>
<line-12> if(arr[i]==0):</line-12>
<line-13> indexzero.append(i)</line-13>
<line-14> else:</line-14>
<line-15> arr2.append(arr[i])</line-15>
<line-16> # arr3 = [x for x in arr1 if x not in arr2]</line-16>
<line-17> arr3= list(set(arr1)-set(arr2))</line-17>
<line-18> result=permutations(arr3)</line-18>
<line-19> perm=[]</line-19>
<line-20> for i in result:</line-20>
<line-21> perm.append(i)</line-21>
<line-22> step=0</line-22>
<line-23> count=0</line-23>
<line-24> for p in range(0,len(perm)):</line-24>
<line-25> temp=[]</line-25>
<line-26> for q in range(0,len(arr)):</line-26>
<line-27> if(arr[q]==0):</line-27>
<line-28> temp.append(perm[p][step])</line-28>
<line-29> step+=1 </line-29>
<line-30> else:</line-30>
<line-31> temp.append(arr[q])</line-31>
<line-32> k=0</line-32>
<line-33> step=0</line-33>
<line-34> for m in range(0,len(temp)-1):</line-34>
<line-35> if(temp[m]<temp[m+1]):</line-35>
<line-36> k+=1</line-36>
<line-37> if(k==K):</line-37>
<line-39> print(count)</line-39>
<line-40> </line-40>
<line-41> </line-41>
<line-42> </line-42>
<line-43> </line-43>
<line-44> </line-44>
<line-45> </line-45>
<line-46> </line-46>
|
{"code": "<line-3>for _ in range(int(input())):</line-3>\n<line-38> count+=1 </line-38>", "lines": [3, 38]}
#### 0
|
<line-1>a,b=[int(_) for _ in input().split()]</line-1>
<line-3> print(a)</line-3>
<line-4>else: </line-4>
<line-5> l=[]</line-5>
<line-6> a=str(a)</line-6>
<line-7> for i in range(len(a)):</line-7>
<line-8> l.append(a[i])</line-8>
<line-9> for i in range(len(l)):</line-9>
<line-10> if b==0:</line-10>
<line-11> break</line-11>
<line-12> if l[i]=='9':</line-12>
<line-13> continue</line-13>
<line-14> else:</line-14>
<line-15> l[i]='9'</line-15>
<line-16> b-=1</line-16>
<line-17> s=''</line-17>
<line-18> for i in l:</line-18>
<line-20> print(s) </line-20>
<line-21> </line-21>
|
{"code": "<line-2>if b==0:</line-2>\n<line-19> s+=i</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>from math import ceil</line-1>
<line-3>for i in range(t):</line-3>
<line-4> p=int(input())</line-4>
<line-5> l=list(map(int,input().split()))</line-5>
<line-6> maxx=1</line-6>
<line-7> for i in range(len(l)):</line-7>
<line-8> maxx=max(maxx,l.count(l[i]))</line-8>
<line-9> if(maxx*2>p):</line-9>
<line-10> print(maxx)</line-10>
<line-11> else:</line-11>
<line-12> q=p-maxx*2</line-12>
<line-14> print(maxx)</line-14>
<line-15> </line-15>
<line-16> </line-16>
<line-17> </line-17>
<line-18></line-18>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-13> maxx+=ceil(q/2)</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>def permutate(arr):</line-1>
<line-3> yield arr</line-3>
<line-4> for x in range(len(arr)):</line-4>
<line-5> for perm in permutate(arr[:x] + arr[x+1:]):</line-5>
<line-6> yield [arr[x]] + perm</line-6>
<line-7></line-7>
<line-8>vals = [int(x) for x in input().split()]</line-8>
<line-9></line-9>
<line-10>founded = False</line-10>
<line-11>for val in permutate(vals):</line-11>
<line-12> if (val[0] / float(val[1]) == val[2] / float(val[3])):</line-12>
<line-13> print("Possible")</line-13>
<line-14> founded = True </line-14>
<line-15> break</line-15>
<line-17> print("Impossible")</line-17>
|
{"code": "<line-2> if len(arr) == 1:</line-2>\n<line-16>if not founded:</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> m = 100</line-4>
<line-5> for i in range(0, n):</line-5>
<line-6> str = input()</line-6>
<line-7> p = min(str.count("a",0,len(str)),str.count("b",0,len(str)))</line-7>
<line-8> if (m > p):</line-8>
<line-9> m = p</line-9>
<line-11> t = t-1</line-11>
|
{"code": "<line-2>for j in range(0, t):</line-2>\n<line-10> print(m)</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>def outOfIndex(boys,girls,COST):</line-1>
<line-3> return len(boys)</line-3>
<line-4> else:</line-4>
<line-5> total_cost = [ abs(x-y) for x,y in zip(boys,girls)]</line-5>
<line-6> total_cost = sum(total_cost)</line-6>
<line-7> return total_cost</line-7>
<line-8></line-8>
<line-9>for _ in range(int(input())):</line-9>
<line-10> COST = int(input())</line-10>
<line-11> queue = input()</line-11>
<line-12> B = queue.count('B')</line-12>
<line-13> G = queue.count('G')</line-13>
<line-14> boys=[]</line-14>
<line-15> girls = []</line-15>
<line-16> if (abs(B-G)>1):</line-16>
<line-17> print(-1)</line-17>
<line-18> else:</line-18>
<line-19> if B > G:</line-19>
<line-20> for c in range(len(queue)):</line-20>
<line-21> if c%2!=0 and queue[c]=='B':</line-21>
<line-22> boys.append(c)</line-22>
<line-23> if c%2==0 and queue[c] =='G':</line-23>
<line-24> girls.append(c)</line-24>
<line-25> print(outOfIndex(boys,girls,COST))</line-25>
<line-26> boys.clear()</line-26>
<line-27> girls.clear()</line-27>
<line-28> elif B < G:</line-28>
<line-29> for c in range(len(queue)):</line-29>
<line-30> if c%2!=0 and queue[c]=='G':</line-30>
<line-31> girls.append(c)</line-31>
<line-32> if c%2==0 and queue[c] =='B':</line-32>
<line-33> boys.append(c)</line-33>
<line-34> print(outOfIndex(boys,girls,COST))</line-34>
<line-35> boys.clear()</line-35>
<line-36> girls.clear()</line-36>
<line-37> else:</line-37>
<line-38> for c in range(len(queue)):</line-38>
<line-39> if c%2!=0 and queue[c]=='B':</line-39>
<line-40> boys.append(c)</line-40>
<line-41> if c%2==0 and queue[c] =='G':</line-41>
<line-42> girls.append(c)</line-42>
<line-43> attempt1 = outOfIndex(boys,girls,COST)</line-43>
<line-44> boys.clear()</line-44>
<line-45> girls.clear()</line-45>
<line-46> for c in range(len(queue)):</line-46>
<line-47> if c%2!=0 and queue[c]=='G':</line-47>
<line-48> girls.append(c)</line-48>
<line-49> if c%2==0 and queue[c] =='B':</line-49>
<line-50> boys.append(c)</line-50>
<line-51> attempt2 = outOfIndex(boys,girls,COST)</line-51>
<line-52> print(min(attempt1,attempt2))</line-52>
<line-54> girls.clear() </line-54>
|
{"code": "<line-2> if COST == 0:</line-2>\n<line-53> boys.clear()</line-53>", "lines": [2, 53]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>for i in range(n):</line-3>
<line-4> l[i]=int(input())</line-4>
<line-5>l.sort()</line-5>
<line-6>s=0</line-6>
<line-7>i=n-1</line-7>
<line-8>while i>=0:</line-8>
<line-9> x=2*l[i]</line-9>
<line-10> if l[-1]>=x:</line-10>
<line-11> j=i</line-11>
<line-12> while j<len(l):</line-12>
<line-13> if l[j]>=x:</line-13>
<line-14> l.pop(j)</line-14>
<line-15> l.pop(i)</line-15>
<line-16> s+=1</line-16>
<line-17> break</line-17>
<line-18> j+=1</line-18>
<line-19> i-=1</line-19>
<line-21>print(s)</line-21>
|
{"code": "<line-2>l=[0]*n</line-2>\n<line-20>s+=len(l)</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n=int(input())</line-3>
<line-4> lis=list(map(int,input().split()))</line-4>
<line-5> lis2=[]</line-5>
<line-6> for j in range(0,10):</line-6>
<line-7> lis2.append(0)</line-7>
<line-8> for j in range(0,len(lis)):</line-8>
<line-9> lis2[lis[j]]+=1;</line-9>
<line-10> s=sum(lis)</line-10>
<line-11> while s%3!=0:</line-11>
<line-12> if s%3==2:</line-12>
<line-13> if lis2[2]>=1:</line-13>
<line-14> lis2[2]-=1</line-14>
<line-15> s=s-2</line-15>
<line-16> elif lis2[5]>=1:</line-16>
<line-17> lis2[5]-=1</line-17>
<line-18> s=s-5</line-18>
<line-19> elif lis2[8]>=1:</line-19>
<line-20> lis2[8]-=1</line-20>
<line-21> s=s-8</line-21>
<line-22> elif lis2[1]>=2:</line-22>
<line-23> lis2[1]-=2</line-23>
<line-24> s=s-2</line-24>
<line-25> elif lis2[1]>=1 and lis2[4]>=1:</line-25>
<line-26> lis2[1]-=1</line-26>
<line-27> lis2[4]-=1</line-27>
<line-28> s=s-5</line-28>
<line-29> elif lis2[4]>=2:</line-29>
<line-30> lis2[4]-=2</line-30>
<line-31> s=s-8</line-31>
<line-32> elif lis2[1]>=1 and lis2[7]>=1:</line-32>
<line-33> lis2[1]-=1</line-33>
<line-34> lis2[7]-=1</line-34>
<line-35> s=s-8</line-35>
<line-36> elif lis2[4]>=1 and lis2[7]>=1:</line-36>
<line-37> lis2[4]-=1</line-37>
<line-38> lis2[7]-=1</line-38>
<line-39> s=s-11</line-39>
<line-40> elif lis2[7]>=2:</line-40>
<line-41> lis2[7]-=2</line-41>
<line-42> s=s-14</line-42>
<line-43> elif s%3==1:</line-43>
<line-44> if lis2[1]>=1:</line-44>
<line-45> lis2[1]-=1</line-45>
<line-46> s=s-1</line-46>
<line-47> elif lis2[4]>=1:</line-47>
<line-48> lis2[4]-=1</line-48>
<line-49> s=s-4</line-49>
<line-50> elif lis2[7]>=1:</line-50>
<line-51> lis2[7]-=1</line-51>
<line-52> s=s-7</line-52>
<line-53> elif lis2[2]>=2:</line-53>
<line-54> lis2[2]-=2</line-54>
<line-55> s=s-4</line-55>
<line-56> elif lis2[5]>=1 and lis2[2]>=1:</line-56>
<line-57> lis2[2]-=1</line-57>
<line-58> lis2[5]-=1</line-58>
<line-59> s=s-7</line-59>
<line-60> elif lis2[5]>=2:</line-60>
<line-61> lis2[5]-=2</line-61>
<line-62> s=s-10</line-62>
<line-63> elif lis2[2]>=1 and lis2[8]>=1:</line-63>
<line-64> lis2[2]-=1</line-64>
<line-65> lis2[8]-=1</line-65>
<line-66> s=s-10</line-66>
<line-67> elif lis2[8]>=1 and lis2[5]>=1:</line-67>
<line-68> lis2[8]-=1</line-68>
<line-69> lis2[5]-=1</line-69>
<line-70> s=s-13</line-70>
<line-71> elif lis2[8]>=2:</line-71>
<line-72> lis2[8]-=2</line-72>
<line-73> s=s-16</line-73>
<line-74> lis3=[]</line-74>
<line-75> for j in range(1,10):</line-75>
<line-76> if lis2[j]>=1:</line-76>
<line-77> for k in range(0,lis2[j]):</line-77>
<line-78> lis3.append(j)</line-78>
<line-79> lis3.reverse()</line-79>
<line-80> for k in range(0,lis2[0]):</line-80>
<line-81> lis3.append(0)</line-81>
<line-82> sol=''</line-82>
<line-83> for k in range(0,len(lis3)):</line-83>
<line-85> print(sol)</line-85>
|
{"code": "<line-2>for i in range(0,t):</line-2>\n<line-84> sol+=str(lis3[k])</line-84>", "lines": [2, 84]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(int(input())):</line-3>
<line-4> s=input()</line-4>
<line-5> ind=1</line-5>
<line-6> level=1</line-6>
<line-7> for i in range(len(s)):</line-7>
<line-8> if s[i]=='l':</line-8>
<line-9> if level%2==1:</line-9>
<line-10> ind=ind*2</line-10>
<line-11> else:</line-11>
<line-12> ind=ind*2-1</line-12>
<line-13> if s[i]=='r':</line-13>
<line-14> if level%2==1:</line-14>
<line-15> ind=ind*2+2</line-15>
<line-16> else:</line-16>
<line-17> ind=ind*2+1</line-17>
<line-18> level+=1</line-18>
<line-20> print(ind)</line-20>
|
{"code": "<line-2>MOD=10**9+7</line-2>\n<line-19> ind%=MOD</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>for t in range(int(input())):</line-1>
<line-3> mx = -1</line-3>
<line-4> for i in range(n):</line-4>
<line-5> h, m, s = list(map(int,input().split(":")))</line-5>
<line-6> h %= 12</line-6>
<line-7> m %= 60</line-7>
<line-8> s %= 60</line-8>
<line-9> ha = h*30 + m*0.5 + s*0.5/60</line-9>
<line-10> ma = m*6 + s*0.1</line-10>
<line-11> sa = s*6</line-11>
<line-12> </line-12>
<line-13> hm1 = abs(ha - ma)</line-13>
<line-14> hm2 = 360 - hm1</line-14>
<line-15> hm3 = abs(hm1 - hm2)</line-15>
<line-16> hm = min(hm1, hm2, hm3)</line-16>
<line-17> </line-17>
<line-18> ms1 = abs(ma - sa)</line-18>
<line-19> ms2 = 360 - ms1</line-19>
<line-20> ms3 = abs(ms1 - ms2)</line-20>
<line-21> ms = min(ms1, ms2, ms3)</line-21>
<line-22> </line-22>
<line-23> sh1 = abs(sa - ha)</line-23>
<line-24> sh2 = 360 - sh1</line-24>
<line-25> sh3 = abs(sh1 - sh2)</line-25>
<line-26> sh = min(sh1, sh2, sh3)</line-26>
<line-27> </line-27>
<line-28> avg = (hm + ms + sh) / 3</line-28>
<line-29> if (mx < avg):</line-29>
<line-30> ans = i+1</line-30>
<line-32> print(ans)</line-32>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-31> mx = avg</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>def Testcase():</line-1>
<line-3> </line-3>
<line-4> h = h-1</line-4>
<line-5> yt = h//y +1</line-5>
<line-6> # print(yt)</line-6>
<line-7> flag=0</line-7>
<line-8> ans = 100000000009</line-8>
<line-9> </line-9>
<line-10> for i in range(0,yt):</line-10>
<line-11> temp = x+i*y</line-11>
<line-12> if h%temp==0:</line-12>
<line-13> flag = 1</line-13>
<line-14> cl =i+int(h/temp)</line-14>
<line-15> # print(temp,cl)</line-15>
<line-16> ans = min(ans,cl)</line-16>
<line-17> # print(temp,ans,i)</line-17>
<line-18> print(ans if flag==1 else '-1')</line-18>
<line-19> </line-19>
<line-20> </line-20>
<line-21>t = int(input())</line-21>
<line-22>while t>0:</line-22>
<line-24> </line-24>
<line-25> t-=1</line-25>
|
{"code": "<line-2> h,x,y = [int(x) for x in input().strip().split()]</line-2>\n<line-23> Testcase()</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>from sys import stdin,stdout</line-1>
<line-3>from collections import Counter,deque,defaultdict</line-3>
<line-4>L=lambda:list(map(int, stdin.readline().strip().split()))</line-4>
<line-5>M=lambda:list(map(int, stdin.readline().strip().split()))</line-5>
<line-6>I=lambda:int(stdin.readline().strip())</line-6>
<line-7>S=lambda:stdin.readline().strip()</line-7>
<line-8>C=lambda:stdin.readline().strip().split()</line-8>
<line-9>def pr(a):return(" ".join(list(map(str,a))))</line-9>
<line-10>#_________________________________________________#</line-10>
<line-11></line-11>
<line-12></line-12>
<line-13>def solve():</line-13>
<line-14> n, m = M()</line-14>
<line-15> a = []</line-15>
<line-16> for i in range(n):</line-16>
<line-17> a += [L()]</line-17>
<line-18> s = S()</line-18>
<line-19> p, q = M()</line-19>
<line-20> ans = [[0,0] for i in range(n+m)]</line-20>
<line-21> for i in range(n):</line-21>
<line-22> for j in range(m):</line-22>
<line-23> if a[i][j]==0:</line-23>
<line-24> ans[i+j][0]+=1</line-24>
<line-25> else:</line-25>
<line-26> ans[i+j][1]+=1</line-26>
<line-27> c = 0</line-27>
<line-28> for i in range(n+m-1):</line-28>
<line-29> A,B,C,D = 0,0,0,0</line-29>
<line-30> if s[i]=='0':</line-30>
<line-31> A = ans[i][1]*p</line-31>
<line-32> B = q + ans[i][0]*p</line-32>
<line-33> c+=min(A,B)</line-33>
<line-34> else:</line-34>
<line-35> C = ans[i][0]*p</line-35>
<line-36> D = q + ans[i][1]*p</line-36>
<line-37> c+=min(C,D)</line-37>
<line-38> print(c)</line-38>
<line-40> solve()</line-40>
|
{"code": "<line-2>import math,bisect</line-2>\n<line-39>for _ in range(I()):</line-39>", "lines": [2, 39]}
#### 0
|
<line-1>try:</line-1>
<line-3> s=input()</line-3>
<line-4> balance=0</line-4>
<line-5> max_balance=0</line-5>
<line-6> for i in s:</line-6>
<line-7> if i=='(':balance+=1</line-7>
<line-8> else:</line-8>
<line-9> balance-=1</line-9>
<line-10> max_balance=max(max_balance,balance)</line-10>
<line-11> print('('*max_balance,')'*max_balance,sep="")</line-11>
<line-13> print(e)</line-13>
<line-14> </line-14>
|
{"code": "<line-2> for i in range(int(input())):</line-2>\n<line-12>except Exception as e:</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>import os,sys</line-1>
<line-3></line-3>
<line-4>def ii(): return int(input())</line-4>
<line-5>def si(): return input()</line-5>
<line-6>def mi(): return list(map(int,input().split()))</line-6>
<line-7>def li(): return list(mi())</line-7>
<line-8>import math </line-8>
<line-9></line-9>
<line-10>import collections </line-10>
<line-11></line-11>
<line-12>def CountFrequency(arr): </line-12>
<line-13> return collections.Counter(arr) </line-13>
<line-14></line-14>
<line-15>for i in range(1):</line-15>
<line-16> n,q=mi()</line-16>
<line-17> p=pow(2,n+1)-2 </line-17>
<line-18> t=1 </line-18>
<line-19> b=pow(2,n)</line-19>
<line-20> s=n+1</line-20>
<line-21> for i in range(q):</line-21>
<line-22> a=li()</line-22>
<line-23> if len(a)==2:</line-23>
<line-24> if a[1]==1 or a[1]==2:</line-24>
<line-25> p*=2 </line-25>
<line-26> p+=s</line-26>
<line-27> t*=2 </line-27>
<line-28> b*=2</line-28>
<line-29> else:</line-29>
<line-30> p*=2 </line-30>
<line-31> if a[1]==3:</line-31>
<line-32> p+=t</line-32>
<line-33> t=b </line-33>
<line-34> s*=2</line-34>
<line-35> else:</line-35>
<line-36> p+=b</line-36>
<line-37> b=t</line-37>
<line-38> s*=2</line-38>
<line-40> print(p%1000000007)</line-40>
|
{"code": "<line-2>from io import BytesIO, IOBase</line-2>\n<line-39> else:</line-39>", "lines": [2, 39]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> S=set(input().strip())</line-3>
<line-4> n=int(input().strip())</line-4>
<line-5> a=set(input().strip().split(" "))</line-5>
<line-6> g=True</line-6>
<line-7> for i in S:</line-7>
<line-8> if(i not in a):</line-8>
<line-9> g=False</line-9>
<line-10> if(g):</line-10>
<line-11> print(1)</line-11>
<line-13> print(0)</line-13>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-12> else:</line-12>", "lines": [2, 12]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>N=int(input())</line-3>
<line-4>for i in range(N):</line-4>
<line-5> a,b=list(map(int,input().split()))</line-5>
<line-7> print(c)</line-7>
<line-8> </line-8>
|
{"code": "<line-2>import math</line-2>\n<line-6> c=a//math.gcd(a,b)*b//math.gcd(a,b)</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> previ,num,_s,dic = s[0],0,[],{}</line-3>
<line-4> for i in s:</line-4>
<line-5> if previ == i:</line-5>
<line-6> num+=1</line-6>
<line-7> continue</line-7>
<line-8> _s.append((previ, num))</line-8>
<line-9> if previ not in dic or dic[previ]<num:dic[previ] = num</line-9>
<line-10> previ,num = i,1</line-10>
<line-11> _s.append((previ, num))</line-11>
<line-12> if previ not in dic or dic[previ]<num:dic[previ] = num</line-12>
<line-13> sum1 = sum(dic.values())</line-13>
<line-14> del dic, s</line-14>
<line-15> l,dicc = [i for (i, j) in _s],{}</line-15>
<line-16> congr = [(l[i], l[i+1]) for i in range(len(l)-1)]</line-16>
<line-17> for i in range(len(congr)):</line-17>
<line-18> if congr[i] not in dicc:dicc[congr[i]] = set()</line-18>
<line-19> dicc[congr[i]].add( (_s[i][1], _s[i+1][1]) ) </line-19>
<line-20> sum2,ll = 0,[]</line-20>
<line-21> for i in dicc.keys():</line-21>
<line-22> sortedset,deleted = sorted(list(dicc[i])),[]</line-22>
<line-23> for k in range(1, len(sortedset)):</line-23>
<line-24> j = sortedset[k] </line-24>
<line-26> ind = k - 1</line-26>
|
{"code": "<line-2> n,s = int(input()),input().strip()</line-2>\n<line-25> if j[1]>sortedset[k-1][1]:</line-25>", "lines": [2, 25]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-2></line-2>
<line-4>l = list(map(int, input().strip().split(" ")))</line-4>
<line-5></line-5>
<line-6>depth = 0</line-6>
<line-7>max_depth = 0</line-7>
<line-8>max_depth_index = 0</line-8>
<line-9></line-9>
<line-10>max_l=0</line-10>
<line-11>max_l_index=0</line-11>
<line-12>last_zero=-1</line-12>
<line-13></line-13>
<line-14>for i in range(T):</line-14>
<line-15> if l[i] == 1:</line-15>
<line-16> depth += 1</line-16>
<line-17> if depth > max_depth:</line-17>
<line-18> max_depth = depth</line-18>
<line-19> max_depth_index = i + 1</line-19>
<line-20> else:</line-20>
<line-21> depth-=1</line-21>
<line-22> if depth == 0:</line-22>
<line-23> length = i - last_zero</line-23>
<line-24> if length > max_l:</line-24>
<line-25> max_l = length</line-25>
<line-26> max_l_index = last_zero + 2</line-26>
<line-27> last_zero = i</line-27>
<line-28> </line-28>
<line-29>print(max_depth, max_depth_index, max_l, max_l_index)</line-29>
<line-30></line-30>
<line-31>"""</line-31>
<line-33>"""</line-33>
|
{"code": "<line-3>T = int(input())</line-3>\n<line-32>2 4 6 9</line-32>", "lines": [3, 32]}
#### 0
|
<line-1>import sys,os,io,time,copy,math,queue,bisect</line-1>
<line-3>from functools import lru_cache</line-3>
<line-4></line-4>
<line-5>if os.path.exists('input.txt'):</line-5>
<line-6> sys.stdin = open('input.txt', 'r')</line-6>
<line-7> sys.stdout = open('output.txt', 'w') </line-7>
<line-8></line-8>
<line-9>sys.setrecursionlimit(100000000)</line-9>
<line-10></line-10>
<line-11>def main():</line-11>
<line-12> n,m=map(int,input().split())</line-12>
<line-13> mat=[]</line-13>
<line-14> for _ in range(n):</line-14>
<line-15> s=input()</line-15>
<line-16> a=[]</line-16>
<line-17> for i in s:</line-17>
<line-18> a.append(int(i))</line-18>
<line-19> mat.append(a)</line-19>
<line-20> </line-20>
<line-21> Q=int(input())</line-21>
<line-22> ans=[[0 for i in range(m+1)] for j in range(n+1)]</line-22>
<line-23> for i in range(Q):</line-23>
<line-24> x1,y1,x2,y2=map(int,input().split())</line-24>
<line-25> x1-=1</line-25>
<line-26> y1-=1</line-26>
<line-27> x2-=1</line-27>
<line-28> y2-=1</line-28>
<line-29> ans[x1][y1]+=1</line-29>
<line-30> ans[x2+1][y1]-=1</line-30>
<line-31> ans[x1][y2+1]-=1</line-31>
<line-32> ans[x2+1][y2+1]+=1</line-32>
<line-33> for j in range(m+1):</line-33>
<line-34> for i in range(1,n+1):</line-34>
<line-35> ans[i][j]=ans[i-1][j]+ans[i][j]</line-35>
<line-36> for i in range(n+1):</line-36>
<line-37> for j in range(1,m+1):</line-37>
<line-38> ans[i][j]=ans[i][j-1]+ans[i][j]</line-38>
<line-39> </line-39>
<line-40> for i in range(n):</line-40>
<line-41> for j in range(m):</line-41>
<line-42> mat[i][j]=(ans[i][j]+mat[i][j])%2</line-42>
<line-43> for m in mat:</line-43>
<line-44> for i in m:</line-44>
<line-45> print(i,end="")</line-45>
<line-47></line-47>
<line-48> </line-48>
<line-49>main()</line-49>
|
{"code": "<line-2>from collections import deque</line-2>\n<line-46> print(\"\")</line-46>", "lines": [2, 46]}
#### 0
|
<line-1>#dt = {} for i in x: dt[i] = dt.get(i,0)+1</line-1>
<line-3>inp,ip = lambda :int(input()),lambda :[int(w) for w in input().split()]</line-3>
<line-4></line-4>
<line-5>N = 100001</line-5>
<line-6>p = 998244353</line-6>
<line-7>factorialNumInverse = [0]*(N+1) </line-7>
<line-8>naturalNumInverse = [0]*(N+1)</line-8>
<line-9>fact = [0]*(N+1)</line-9>
<line-10> </line-10>
<line-11>def InverseofNumber(p): </line-11>
<line-12> naturalNumInverse[0] = naturalNumInverse[1] = 1</line-12>
<line-13> for i in range(2,N+1): </line-13>
<line-14> naturalNumInverse[i] = (naturalNumInverse[p % i] * (p - (p // i)) % p)</line-14>
<line-15> </line-15>
<line-16>def InverseofFactorial(p): </line-16>
<line-17> factorialNumInverse[0] = factorialNumInverse[1] = 1</line-17>
<line-18> for i in range(2,N+1): </line-18>
<line-19> factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p </line-19>
<line-20> </line-20>
<line-21>def factorial(p): </line-21>
<line-22> fact[0] = 1</line-22>
<line-23> for i in range(1, N + 1): </line-23>
<line-24> fact[i] = (fact[i - 1] * i) % p</line-24>
<line-25></line-25>
<line-26>def f(num,den1,den2):</line-26>
<line-27> # n C r = n!*inverse(r!)*inverse((n-r)!) </line-27>
<line-28> #ans = ((fact[N] * factorialNumInverse[R])% p * factorialNumInverse[N-R])% p</line-28>
<line-29> ans = ((fact[num]*factorialNumInverse[den1])%p*factorialNumInverse[den2])%p</line-29>
<line-30> return ans </line-30>
<line-31></line-31>
<line-32>InverseofNumber(p) </line-32>
<line-33>InverseofFactorial(p) </line-33>
<line-34>factorial(p)</line-34>
<line-35></line-35>
<line-36>for _ in range(inp()):</line-36>
<line-37> n,m,x1,y1,x2,y2 = ip()</line-37>
<line-38> tot = f(m+n,m,n)</line-38>
<line-39> a = f(m-y1+n-x1,m-y1,n-x1)</line-39>
<line-40> aa = f(x1+y1,x1,y1)</line-40>
<line-41> b = f(m-y2+n-x2,m-y2,n-x2)</line-41>
<line-42> bb = f(x2+y2,x2,y2)</line-42>
<line-43> c = f(y2-y1+x2-x1,y2-y1,x2-x1)</line-43>
<line-45> print(ans)</line-45>
|
{"code": "<line-2>import sys;input = sys.stdin.readline</line-2>\n<line-44> ans = (tot - a*aa - b*bb + c*aa*b)%p</line-44>", "lines": [2, 44]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n=int(input())</line-3>
<line-4> if n==1:</line-4>
<line-5> print("0")</line-5>
<line-6> else:</line-6>
<line-7> s=[]</line-7>
<line-8> for i in range(n):</line-8>
<line-9> s.append(str(i))</line-9>
<line-10> print(''.join(s))</line-10>
<line-11> p=1</line-11>
<line-12> for i in range(n-1):</line-12>
<line-13> s.pop(n-1)</line-13>
<line-14> s=[str(p)]+s</line-14>
<line-16> p+=1</line-16>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-15> print(''.join(s))</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>#for _ in range(int(input()):</line-1>
<line-3>#x = [int(w) for w in input().split()]</line-3>
<line-4>#n = int(input())</line-4>
<line-5>#x = [int(input()) for _ in range(n)]</line-5>
<line-6>#for i in range(n):</line-6>
<line-7>#dt = {} for i in x:dt[i] = dt.get(i,0)+1</line-7>
<line-8>#dt = {k:v for k,v in sorted(x.items(), key=lambda i: i[1])}</line-8>
<line-9></line-9>
<line-10>m,n = map(int,input().split()) # top,right,bottom,left</line-10>
<line-11>x = []</line-11>
<line-12>for i in range(m):</line-12>
<line-13> x.append([])</line-13>
<line-14> for j in range(n):</line-14>
<line-15> clr = [w for w in input().split()]</line-15>
<line-16> x[i].append(clr)</line-16>
<line-17></line-17>
<line-18>import queue as Q </line-18>
<line-19>dp = [float('inf')]*m</line-19>
<line-20>for i in range(m):</line-20>
<line-21> dp[i] = [float('inf')]*n</line-21>
<line-22>dp[m-1][n-1] = 0</line-22>
<line-23>pq = Q.PriorityQueue()</line-23>
<line-24>pq.put([dp[m-1][n-1],m-1,n-1])</line-24>
<line-25>visited = set()</line-25>
<line-26>xx,yy = [-1,0,1,0],[0,1,0,-1] # top,right,bottom,left</line-26>
<line-27>while not pq.empty():</line-27>
<line-28> pop = pq.get()</line-28>
<line-29> cx,cy = pop[1],pop[2]</line-29>
<line-30> if (cx,cy) not in visited:</line-30>
<line-31> visited.add((cx,cy))</line-31>
<line-32> for k in range(4):</line-32>
<line-33> nx,ny = cx+xx[k],cy+yy[k]</line-33>
<line-34> if 0<=nx<m and 0<=ny<n and (nx,ny) not in visited:</line-34>
<line-35> clr = x[cx][cy][k]</line-35>
<line-36> #print("*",nx,ny,"_",k,clr)</line-36>
<line-37> ind = x[nx][ny].index(clr)</line-37>
<line-38> cost = (k-(ind+2)%4)%4</line-38>
<line-39> #print(cost)</line-39>
<line-40> if dp[cx][cy]+cost < dp[nx][ny]:</line-40>
<line-41> dp[nx][ny] = dp[cx][cy]+cost</line-41>
<line-42> pq.put([dp[nx][ny],nx,ny])</line-42>
<line-43> #print("#############")</line-43>
<line-45>print(dp[0][0])</line-45>
|
{"code": "<line-2>#n,m = map(int,input().split())</line-2>\n<line-44>#print(dp)</line-44>", "lines": [2, 44]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> c = 0</line-3>
<line-4> for i in s:</line-4>
<line-5> if i.isalpha() and i.isupper():</line-5>
<line-7> print(c)</line-7>
|
{"code": "<line-2> s = input()</line-2>\n<line-6> c += 1</line-6>", "lines": [2, 6]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(int(input())) :</line-3>
<line-4> n,k=map(int,input().split())</line-4>
<line-5> #reading the string </line-5>
<line-6> s=input()</line-6>
<line-7> i,j=0,0</line-7>
<line-8> q=0</line-8>
<line-9> while(i<n and j<n) :</line-9>
<line-10> if(s[i]=='M') :</line-10>
<line-11> if(s[j]=='I') :</line-11>
<line-12> cnt=0</line-12>
<line-13> if(i>j) :</line-13>
<line-14> p=s[j:i]</line-14>
<line-15> cnt=p.count(':')</line-15>
<line-16> else :</line-16>
<line-17> p=s[i:j]</line-17>
<line-18> cnt=p.count(':')</line-18>
<line-19> t=k+1-abs(i-j)-cnt</line-19>
<line-20> if(t>0) :</line-20>
<line-21> q+=1</line-21>
<line-22> i+=1</line-22>
<line-23> j+=1</line-23>
<line-24> else:</line-24>
<line-25> if(i<j) :</line-25>
<line-26> i+=1</line-26>
<line-27> else:</line-27>
<line-28> j+=1</line-28>
<line-29> elif(s[j]=='X') :</line-29>
<line-30> j+=1</line-30>
<line-31> i=j</line-31>
<line-32> else:</line-32>
<line-33> j+=1</line-33>
<line-34> elif(s[i]=='X') :</line-34>
<line-35> i+=1</line-35>
<line-36> j=i</line-36>
<line-37> else:</line-37>
<line-39> print(q) </line-39>
|
{"code": "<line-2># cook your dish here</line-2>\n<line-38> i+=1</line-38>", "lines": [2, 38]}
#### 0
|
<line-1>cases = int(input())</line-1>
<line-3> rows, cols = map(int, input().split())</line-3>
<line-4> if (cols - 1) % 3 == 0 and (rows - 1) % 4 == 0: print('Vanya')</line-4>
<line-5> elif (cols - 1) % 3 != 0 and (rows - 1) % 4 == 0: print('Tuzik')</line-5>
<line-6> elif (cols - 1) % 3 == 0 and (rows - 1) % 4 != 0: print('Tuzik')</line-6>
<line-7> else:</line-7>
<line-8> if (cols - 1) % 3 == 1 and (rows - 1) % 4 == 1: print('Vanya')</line-8>
<line-10> else: print('Tuzik')</line-10>
|
{"code": "<line-2>for _ in range(cases):</line-2>\n<line-9> elif (cols - 1) % 3 == 2 and (rows - 1) % 4 == 2: print('Vanya')</line-9>", "lines": [2, 9]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> X=list(map(int, input().split()))</line-3>
<line-4>except:</line-4>
<line-5> X=[0,0]</line-5>
<line-6>ch=[]</line-6>
<line-7>chnew=[]</line-7>
<line-8>par={}</line-8>
<line-9>par[1]=0</line-9>
<line-10>for i in range(X[0]+1):</line-10>
<line-11> ch.append([])</line-11>
<line-12> chnew.append([])</line-12>
<line-13>for i in range(X[0]-1):</line-13>
<line-14> Y=list(map(int, input().split()))</line-14>
<line-15> #par[Y[1]]=[Y[0],Y[2]]</line-15>
<line-16> ch[Y[0]].append([Y[1],Y[2]])</line-16>
<line-17> ch[Y[1]].append([Y[0],Y[2]])</line-17>
<line-18>tre=[1]</line-18>
<line-19>while(len(tre)):</line-19>
<line-20> cr=tre[-1]</line-20>
<line-21> tre=tre[:-1]</line-21>
<line-22> for i in ch[cr]:</line-22>
<line-23> chnew[cr].append(i)</line-23>
<line-24> par[i[0]]=[cr,i[1]]</line-24>
<line-25> tre.append(i[0])</line-25>
<line-26> for j in ch[i[0]]:</line-26>
<line-27> if(j[0]==cr):</line-27>
<line-28> ch[i[0]].remove(j)</line-28>
<line-29> break</line-29>
<line-30>ch=chnew</line-30>
<line-31>def goup(par,nd):</line-31>
<line-32> if(nd==1):</line-32>
<line-33> return 0</line-33>
<line-34> else:</line-34>
<line-35> p=par[nd]</line-35>
<line-36> ans=p[1]+goup(par,p[0])</line-36>
<line-37> return (max([ans,0]))</line-37>
<line-38></line-38>
<line-39>def godown(ch,nd):</line-39>
<line-40> ans=0</line-40>
<line-41> for i in ch[nd]:</line-41>
<line-42> ans=max([(i[1]+godown(ch,i[0])),ans])</line-42>
<line-43> return(ans)</line-43>
<line-44></line-44>
<line-45>for i in range(X[1]):</line-45>
<line-46> Z=list(map(int,input().split()))</line-46>
<line-47> r=Z[0]</line-47>
<line-48> s=Z[1]</line-48>
<line-49> nans=0</line-49>
<line-50> while(r!=s):</line-50>
<line-51> if(r>s):</line-51>
<line-52> nans=nans+par[r][1]</line-52>
<line-53> r=par[r][0]</line-53>
<line-54> else:</line-54>
<line-55> nans=nans+par[s][1]</line-55>
<line-56> s=par[s][0]</line-56>
<line-57> if((r==Z[0]) or (r==Z[1])):</line-57>
<line-58> if(Z[0]<Z[1]):</line-58>
<line-59> nans=nans+2*max(goup(par,Z[0]),godown(ch,Z[1]))</line-59>
<line-60> else:</line-60>
<line-61> nans=nans+2*max(goup(par,Z[1]),godown(ch,Z[0]))</line-61>
<line-62> else:</line-62>
<line-64> print(nans)</line-64>
|
{"code": "<line-2>try:</line-2>\n<line-63> nans=nans+2*goup(par,r)</line-63>", "lines": [2, 63]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> if a == 0 and b == 0 and c == 0 and x == 0 and y == 0 and z == 0:</line-3>
<line-4> print(0)</line-4>
<line-5> continue</line-5>
<line-6> ans = 0</line-6>
<line-7> if a == 0 and b == 0 and c == 0:</line-7>
<line-8> st = set((abs(x-a)%2,abs(y-b)%2,abs(z-c)%2))</line-8>
<line-9> if st == {0,1}:</line-9>
<line-10> ans = 1</line-10>
<line-11> else:</line-11>
<line-12> ans = 2</line-12>
<line-13> else:</line-13>
<line-14> if x == 0 and y == 0 and z == 0:</line-14>
<line-15> st = set((abs(x-a)%2,abs(y-b)%2,abs(z-c)%2))</line-15>
<line-16> if st == {0,1}:</line-16>
<line-17> ans = 1</line-17>
<line-18> else:</line-18>
<line-19> ans = 2</line-19>
<line-20> else:</line-20>
<line-21> st = set((abs(x-a)%2,abs(y-b)%2,abs(z-c)%2))</line-21>
<line-22> if st == {0,1}:</line-22>
<line-24> print(ans)</line-24>
|
{"code": "<line-2> a,b,c,x,y,z = list(map(int,input().split()))</line-2>\n<line-23> ans = 1 </line-23>", "lines": [2, 23]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> start=(ord(string[0])-96)*100</line-3>
<line-4> sum=0</line-4>
<line-5> #print(start)</line-5>
<line-6> for i in range(len(string)):</line-6>
<line-8> print(sum%1000000007)</line-8>
|
{"code": "<line-2> string = input().rstrip()</line-2>\n<line-7> sum+=start+(ord(string[i])-97)</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>__author__ = 'Prateek'</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>def test():</line-5>
<line-6> n,k=list(map(int,input().split()))</line-6>
<line-7> l = k</line-7>
<line-8> d =n-1</line-8>
<line-9> ans = l-1</line-9>
<line-10> ans = ans%MOD</line-10>
<line-11> a = k-n</line-11>
<line-12> term = (d+a)//d</line-12>
<line-13> ll = (a%MOD - (((term-1)%MOD)*(d%MOD))%MOD)%MOD</line-13>
<line-14> if ll < 0:</line-14>
<line-15> ll = (ll +MOD)%MOD</line-15>
<line-16> m = ((term%MOD)*((a%MOD+ll%MOD)%MOD))%MOD</line-16>
<line-17> m = (m*pow(2,MOD-2,MOD))%MOD</line-17>
<line-18> ans += m</line-18>
<line-19> ans = ans%MOD</line-19>
<line-20> print(ans)</line-20>
<line-21></line-21>
<line-22></line-22>
<line-23>if __author__ == 'Prateek':</line-23>
<line-24> t = int(input())</line-24>
<line-26> test()</line-26>
|
{"code": "<line-3>MOD = int(10**9+7)</line-3>\n<line-25> for _ in range(t):</line-25>", "lines": [3, 25]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>def solution():</line-4>
<line-5> T = int(input().strip())</line-5>
<line-6> for _ in range(T):</line-6>
<line-7> x, k = list(map(float, input().strip().split(' ')))</line-7>
<line-8> original_x = x</line-8>
<line-9> if k == 1:</line-9>
<line-10> a = [float(input().strip())]</line-10>
<line-11> b = [float(input().strip())]</line-11>
<line-12> else:</line-12>
<line-13> a = list(map(float, input().strip().split(' ')))</line-13>
<line-14> b = list(map(float, input().strip().split(' ')))</line-14>
<line-15> for i in range(int(k)):</line-15>
<line-16> x = x + (a[i]/b[i])*(x)</line-16>
<line-17> percentage = ((x - original_x) / x)*100</line-17>
<line-19></line-19>
<line-20>solution()</line-20>
|
{"code": "<line-2>import math</line-2>\n<line-18> print(\"%d\"%(int(percentage)))</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>from math import sqrt</line-1>
<line-2></line-2>
<line-4> if (n % 2 == 0 and n > 2) or n == 1: return 0</line-4>
<line-5> else:</line-5>
<line-6> s = int(sqrt(n)) + 1</line-6>
<line-7> for i in range(3, s, 2):</line-7>
<line-8> if n % i == 0:</line-8>
<line-9> return 0</line-9>
<line-10> return 1</line-10>
<line-11></line-11>
<line-12>def find(N, K): </line-12>
<line-13> if (N < 2 * K): </line-13>
<line-14> return 0</line-14>
<line-15> if (K == 1): </line-15>
<line-16> return isprime(N) </line-16>
<line-17> if (K == 2): </line-17>
<line-18> if (N % 2 == 0): </line-18>
<line-19> return 1</line-19>
<line-20> return isprime(N - 2); </line-20>
<line-21> return 1</line-21>
<line-22></line-22>
<line-23>for _ in range(int(input())):</line-23>
<line-25> print(find(n, k))</line-25>
<line-26></line-26>
<line-27></line-27>
|
{"code": "<line-3>def isprime(n):</line-3>\n<line-24> n, k = list(map(int, input().split()))</line-24>", "lines": [3, 24]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n=int(input(''))</line-3>
<line-4> x=bin(n)</line-4>
<line-5> x=len(x)-2</line-5>
<line-6> if n==(2**(x-1)):</line-6>
<line-7> print(n)</line-7>
<line-9> print(2**x)</line-9>
|
{"code": "<line-2>for _ in range(int(input(''))):</line-2>\n<line-8> else:</line-8>", "lines": [2, 8]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>l=[int(i) for i in input().split()]</line-3>
<line-4>xors=[]</line-4>
<line-5>for i in range(n):</line-5>
<line-6> for j in range(i+1,n):</line-6>
<line-7> xors.append([l[i]^l[j],(i,j)])</line-7>
<line-8>xors.sort()</line-8>
<line-9></line-9>
<line-10>#print(xors)</line-10>
<line-11>upto=[0]*n </line-11>
<line-12>for i in range(len(xors)):</line-12>
<line-13> #a=xors[i][0]</line-13>
<line-14> b,c=xors[i][1][0],xors[i][1][1]</line-14>
<line-15> upto[c]=max(upto[c],upto[b]+1)</line-15>
<line-16> </line-16>
<line-18> </line-18>
<line-19>print(max(upto)+1)</line-19>
|
{"code": "<line-2>n=int(input())</line-2>\n<line-17>#print(upto)</line-17>", "lines": [2, 17]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>t=int(input())</line-3>
<line-4>for _ in range(t):</line-4>
<line-5> n=int(input())</line-5>
<line-6> start=[]</line-6>
<line-7> end=[]</line-7>
<line-8> for i in range(n):</line-8>
<line-9> first, last = map (int, input().split())</line-9>
<line-10> start.append((first, i))</line-10>
<line-11> end.append((last, i))</line-11>
<line-12> score=[0]*n </line-12>
<line-13> start.sort(key=itemgetter(0))</line-13>
<line-14> end.sort(key=itemgetter(0), reverse=True)</line-14>
<line-15> for i in range(n-1):</line-15>
<line-16> score[start[i][1]]+=n-i-1</line-16>
<line-18> print(' '.join([str(i) for i in score]))</line-18>
|
{"code": "<line-2>from operator import itemgetter</line-2>\n<line-17> score[end[i][1]]+=n-i-1</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>def frequency(s,n):</line-1>
<line-3> count=0</line-3>
<line-4> for i in range(n):</line-4>
<line-5> if s[i]!="#":</line-5>
<line-6> f[count][ord(s[i])-97]+=1</line-6>
<line-7> else:</line-7>
<line-8> count+=1</line-8>
<line-9> for j in range(26):</line-9>
<line-10> f[count][j]=f[count-1][j]</line-10>
<line-11> return (f,count)</line-11>
<line-12> </line-12>
<line-13>def solve(s):</line-13>
<line-14> n=len(s)</line-14>
<line-15> f,count=frequency(s,n)</line-15>
<line-16> if count<3:</line-16>
<line-17> return 0</line-17>
<line-18> ans=0</line-18>
<line-19> index=[]</line-19>
<line-20> for i in range(n-1,-1,-1):</line-20>
<line-21> if s[i]=="#":</line-21>
<line-22> index.append(i)</line-22>
<line-23> </line-23>
<line-24> for c in range(1,count-2+1):</line-24>
<line-25> if index[-2]==index[-1]+1 or index[-3]==index[-2]+1:</line-25>
<line-26> index.pop()</line-26>
<line-27> continue</line-27>
<line-28> left=max(f[c-1])</line-28>
<line-29> mid1=0</line-29>
<line-30> mid2=0</line-30>
<line-31> right=0</line-31>
<line-32> for j in range(26):</line-32>
<line-33> mid1=max(mid1,f[c][j]-f[c-1][j])</line-33>
<line-34> mid2=max(mid2,f[c+1][j]-f[c][j])</line-34>
<line-35> right=max(right,f[count][j]-f[c+1][j])</line-35>
<line-36> if left and mid1 and mid2 and right:</line-36>
<line-37> ans=max(ans,left+mid1+mid2+right)</line-37>
<line-38> index.pop()</line-38>
<line-39> return ans</line-39>
<line-40> </line-40>
<line-41>for _ in range(int(input())):</line-41>
<line-42> s=input()</line-42>
<line-43> ans=solve(s)</line-43>
<line-44> if ans:</line-44>
<line-45> print(ans+3)</line-45>
<line-47> print(0)</line-47>
<line-48> </line-48>
<line-49> </line-49>
|
{"code": "<line-2> f=[[0 for i in range(26)]for j in range(n+1)]</line-2>\n<line-46> else:</line-46>", "lines": [2, 46]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>l=list(map(int,input().split()))</line-3>
<line-4>temp=[]</line-4>
<line-5>for item in l:</line-5>
<line-6> temp.append(item)</line-6>
<line-7>if(n<=3):</line-7>
<line-8> print(sum(temp))</line-8>
<line-9>else:</line-9>
<line-10> for i in range(3,n):</line-10>
<line-11> temp[i]=l[i]+min(temp[i-1],temp[i-2],temp[i-3])</line-11>
<line-13> print(res)</line-13>
|
{"code": "<line-2>n=int(input())</line-2>\n<line-12> res=sum(l)-min(temp[n-1],temp[n-2],temp[n-3])</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>ways=x=0</line-1>
<line-3>remi=((10**9)+7)</line-3>
<line-4>t=int(input())</line-4>
<line-5>for i in range(t):</line-5>
<line-6> n,k=list(map(int,input().split()))</line-6>
<line-7> if t<=100 and n>=1 and k<=val:</line-7>
<line-8> x=(k-1)**(n-1)</line-8>
<line-9> ways=k*x</line-9>
<line-10> ways=ways%remi</line-10>
<line-11> print(ways)</line-11>
<line-12> x=ways=0</line-12>
<line-14> break</line-14>
|
{"code": "<line-2>val=10**9</line-2>\n<line-13> else:</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>def identify(x, y):</line-4>
<line-5> rows[x][y] = '2'</line-5>
<line-6></line-6>
<line-7> r = 0</line-7>
<line-8> if x == 0:</line-8>
<line-9> r |= 1</line-9>
<line-10> elif rows[x-1][y] == '1':</line-10>
<line-11> r |= identify(x-1, y)</line-11>
<line-12> if x == 7:</line-12>
<line-13> r |= 4</line-13>
<line-14> elif rows[x+1][y] == '1':</line-14>
<line-15> r |= identify(x+1, y)</line-15>
<line-16> if y == 0:</line-16>
<line-17> r |= 2</line-17>
<line-18> elif rows[x][y-1] == '1':</line-18>
<line-19> r |= identify(x, y-1)</line-19>
<line-20> if y == 7:</line-20>
<line-21> r |= 8</line-21>
<line-22> elif rows[x][y+1] == '1':</line-22>
<line-23> r |= identify(x, y+1)</line-23>
<line-24> return r</line-24>
<line-25></line-25>
<line-26>P = 21945</line-26>
<line-27></line-27>
<line-28>while t:</line-28>
<line-29> t-=1</line-29>
<line-30> n = int(sys.stdin.readline())-3</line-30>
<line-31></line-31>
<line-32> rows = [list(sys.stdin.readline().strip()) for i in range(8)]</line-32>
<line-33> total = 0</line-33>
<line-34> for i in range(8):</line-34>
<line-35> for j in range(8):</line-35>
<line-36> if rows[i][j] == '1':</line-36>
<line-37> r = identify(i,j)</line-37>
<line-38> # print '\n'.join([''.join(ro) for ro in rows])</line-38>
<line-39> # print r</line-39>
<line-40> if n == 0:</line-40>
<line-41> total += 1</line-41>
<line-42> # print total</line-42>
<line-43> continue</line-43>
<line-44> if r == 0:</line-44>
<line-45> total += pow(2, 2*n, P)</line-45>
<line-46> elif r == 1 or r == 2 or r == 4 or r == 8:</line-46>
<line-47> total += pow(2, 2*n-1, P)</line-47>
<line-48> if r == 1 or r == 2:</line-48>
<line-49> total += pow(2, n, P)</line-49>
<line-50> elif r == 5 or r == 10:</line-50>
<line-51> total += pow(2, n, P)</line-51>
<line-52> elif r == 3 or r == 6 or r == 12 or r == 9:</line-52>
<line-53> total += pow(2, 2*n-2, P)</line-53>
<line-54> if r == 3:</line-54>
<line-55> total += 3 + 2*pow(2, n-1, P) - 2</line-55>
<line-56> elif r == 6 or r == 9:</line-56>
<line-57> total += pow(2, n-1, P)</line-57>
<line-58> elif r == 15:</line-58>
<line-59> total += 1</line-59>
<line-60> else:</line-60>
<line-61> total += pow(2, n-1, P)</line-61>
<line-62> if r == 11 or r == 7:</line-62>
<line-63> total += 1</line-63>
<line-65> print(total % P)</line-65>
|
{"code": "<line-2>t = int(sys.stdin.readline())</line-2>\n<line-64> # print total</line-64>", "lines": [2, 64]}
#### 0
|
<line-1># v = ["a","e","i","o","u"]</line-1>
<line-3># n = int(input())</line-3>
<line-4># a,b = [],[]</line-4>
<line-5># for i in range(n):</line-5>
<line-6># s = input()</line-6>
<line-7># isa = True</line-7>
<line-8># for j in range(1,len(s) - 1):</line-8>
<line-9># if(s[j] in v):</line-9>
<line-10># if(s[j - 1] not in v and s[j + 1] not in v):</line-10>
<line-11># isa = False</line-11>
<line-12># else:</line-12>
<line-13># if(s[j - 1] not in v or s[j + 1] not in v):</line-13>
<line-14># isa = False</line-14>
<line-15># if(not isa):</line-15>
<line-16># break</line-16>
<line-17># if(s[0] not in v and s[1] not in v):</line-17>
<line-18># isa = False</line-18>
<line-19># if(s[-1] not in v and s[-2] not in v):</line-19>
<line-20># isa = False</line-20>
<line-21># if(isa):</line-21>
<line-22># a.append(s)</line-22>
<line-23># else:</line-23>
<line-24># b.append(s)</line-24>
<line-25># dicta,dictb = {},{}</line-25>
<line-26># for i in a:</line-26>
<line-27># freq = {}</line-27>
<line-28># for j in i:</line-28>
<line-29># if(j in freq):</line-29>
<line-30># freq[j] += 1</line-30>
<line-31># else:</line-31>
<line-32># freq[j] = 1</line-32>
<line-33># for j in freq:</line-33>
<line-34># if(j not in dicta):</line-34>
<line-35># dicta[j] = (1,freq[j])</line-35>
<line-36># else:</line-36>
<line-37># dicta[j] = (dicta[j][0] + 1,dicta[j][1] + freq[j])</line-37>
<line-38># for i in b:</line-38>
<line-39># freq = {}</line-39>
<line-40># for j in i:</line-40>
<line-41># if(j in freq):</line-41>
<line-42># freq[j] += 1</line-42>
<line-43># else:</line-43>
<line-44># freq[j] = 1</line-44>
<line-45># for j in freq:</line-45>
<line-46># if(j not in dictb):</line-46>
<line-47># dictb[j] = (1,freq[j])</line-47>
<line-48># else:</line-48>
<line-49># dictb[j] = (dictb[j][0] + 1,dictb[j][1] + freq[j])</line-49>
<line-50># ans = 1</line-50>
<line-51># for i in dicta:</line-51>
<line-52># ans *= dicta[i][0]</line-52>
<line-53># for i in dictb:</line-53>
<line-54># ans /= dictb[i][0]</line-54>
<line-55># x,y = 1,1</line-55>
<line-56># for i in dictb:</line-56>
<line-57># x *= dictb[i][1]</line-57>
<line-58># for i in dicta:</line-58>
<line-59># y *= dicta[i][1]</line-59>
<line-60># alice,bob = len(a),len(b)</line-60>
<line-61># for i in range(bob):</line-61>
<line-62># while(alice > 0 and ans > 10**7):</line-62>
<line-63># ans /= y</line-63>
<line-64># alice -= 1</line-64>
<line-65># ans *= x</line-65>
<line-66># if(ans > 10**7 and alice == 0):</line-66>
<line-67># break</line-67>
<line-68># while(alice > 0):</line-68>
<line-69># ans /= y</line-69>
<line-70># if(ans < 1 and alice > 100):</line-70>
<line-71># ans = 0</line-71>
<line-72># break</line-72>
<line-73># alice -= 1</line-73>
<line-74># if(ans > 10**7):</line-74>
<line-75># print("Infinity")</line-75>
<line-76># else:</line-76>
<line-77># print(ans)</line-77>
<line-78># #partailly correct [75 pts]</line-78>
<line-79>#sys.stdin.readline() and sys.stdout.write() are faster I/O methods than input() and print()</line-79>
<line-80>from sys import stdin</line-80>
<line-81>z=['a','i','e','o','u']</line-81>
<line-82>t=int(stdin.readline())</line-82>
<line-83>while(t>0):</line-83>
<line-84> t-=1</line-84>
<line-85> n=int(stdin.readline())</line-85>
<line-86> alice=[]</line-86>
<line-87> bob=[]</line-87>
<line-88> for j in range(n):</line-88>
<line-89> s=str(stdin.readline().strip("\n"))</line-89>
<line-90> # print(s)</line-90>
<line-91> isalice=True</line-91>
<line-92> for i in range(1,len(s)-1):</line-92>
<line-93> if(s[i] in z):</line-93>
<line-94> if(s[i-1] not in z and s[i+1] not in z):</line-94>
<line-95> isalice=False</line-95>
<line-96> else:</line-96>
<line-97> if(s[i-1] not in z or s[i+1] not in z):</line-97>
<line-98> isalice=False</line-98>
<line-99> if(not isalice):</line-99>
<line-100> break</line-100>
<line-101> if(s[0] not in z and s[1] not in z):</line-101>
<line-102> isalice=False</line-102>
<line-103> if(s[-1] not in z and s[-2] not in z):</line-103>
<line-104> isalice=False</line-104>
<line-105> if(isalice):</line-105>
<line-106> alice.append(s)</line-106>
<line-107> else:</line-107>
<line-108> bob.append(s)</line-108>
<line-109> ali={}</line-109>
<line-110> bo={}</line-110>
<line-111> for i in alice:</line-111>
<line-112> d={}</line-112>
<line-113> for j in i:</line-113>
<line-114> if(j in d):</line-114>
<line-115> d[j]+=1</line-115>
<line-116> else:</line-116>
<line-117> d[j]=1</line-117>
<line-118> for j in d:</line-118>
<line-119> if j not in ali:</line-119>
<line-120> ali[j]=(1,d[j])</line-120>
<line-121> else:</line-121>
<line-122> ali[j]=(ali[j][0]+1,ali[j][1]+d[j])</line-122>
<line-123> for i in bob:</line-123>
<line-124> d={}</line-124>
<line-125> for j in i:</line-125>
<line-126> if(j in d):</line-126>
<line-127> d[j]+=1</line-127>
<line-128> else:</line-128>
<line-129> d[j]=1</line-129>
<line-130> for j in d:</line-130>
<line-131> if j not in bo:</line-131>
<line-132> bo[j]=(1,d[j])</line-132>
<line-133> else:</line-133>
<line-134></line-134>
<line-135> bo[j]=(bo[j][0]+1,bo[j][1]+d[j])</line-135>
<line-136> ans=1</line-136>
<line-137> for i in ali:</line-137>
<line-138> ans*=ali[i][0]</line-138>
<line-139> for i in bo:</line-139>
<line-140> ans=ans/bo[i][0]</line-140>
<line-141> x=1</line-141>
<line-142> y=1</line-142>
<line-143></line-143>
<line-144> for i in bo:</line-144>
<line-145> x=x*bo[i][1]</line-145>
<line-146> for i in ali:</line-146>
<line-147> y=y*ali[i][1]</line-147>
<line-148> # print(x,y)</line-148>
<line-149> alice=len(alice)</line-149>
<line-150> bob=len(bob)</line-150>
<line-151> for i in range(bob):</line-151>
<line-152> while(alice>0 and ans>10000000):</line-152>
<line-153> ans=ans/y</line-153>
<line-154> alice-=1</line-154>
<line-155> ans*=x</line-155>
<line-156> if(ans>10000000 and alice==0):</line-156>
<line-157> break</line-157>
<line-158> while(alice>0):</line-158>
<line-159> ans=ans/y</line-159>
<line-160> if(ans<1 and alice>100):</line-160>
<line-161> ans=0</line-161>
<line-162> break</line-162>
<line-163> alice-=1</line-163>
<line-164> if(ans>10000000):</line-164>
<line-165> print("Infinity")</line-165>
<line-166> else:</line-166>
<line-168>#AC</line-168>
|
{"code": "<line-2># for _ in range(int(input())):</line-2>\n<line-167> print(ans)</line-167>", "lines": [2, 167]}
#### 0
|
<line-1>for j in range(int(input())):</line-1>
<line-3> b=input()</line-3>
<line-4> c,d=0,0</line-4>
<line-5> a0=a.count("0")</line-5>
<line-6> a1=a.count("1")</line-6>
<line-7> if(a0==len(a) or a1==len(a)):</line-7>
<line-8> print("Unlucky Chef")</line-8>
<line-9> else:</line-9>
<line-10> print("Lucky Chef")</line-10>
<line-11> for i in range(len(a)):</line-11>
<line-12> if(a[i]!=b[i]):</line-12>
<line-13> if(a[i]=="0"):</line-13>
<line-14> c+=1</line-14>
<line-15> else:</line-15>
<line-17> print(max(c,d))</line-17>
|
{"code": "<line-2> a=input()</line-2>\n<line-16> d+=1</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n,k=[int(i) for i in input().split()]</line-3>
<line-4> l=input().split()</line-4>
<line-5> for i in range(k):</line-5>
<line-6> if l.pop()=='H':</line-6>
<line-7> for ind,j in enumerate(l):</line-7>
<line-8> if j=='H':</line-8>
<line-9> l[ind]='T'</line-9>
<line-10> else:</line-10>
<line-12> print(sum([1 for i in l if i=='H']))</line-12>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-11> l[ind]='H'</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>#cook your recipe</line-1>
<line-3>test_cases = int(input())</line-3>
<line-4>for _ in range(test_cases):</line-4>
<line-5> n = int(input())</line-5>
<line-6> sum1 = 0</line-6>
<line-7> final_sum = 0</line-7>
<line-8> num = list(map(int, input().split()))</line-8>
<line-9> rep_time = factorial(n - 1)</line-9>
<line-10> rep_count = dict()</line-10>
<line-11> for i in num:</line-11>
<line-12> if i in rep_count:</line-12>
<line-13> rep_count[i] +=1</line-13>
<line-14> else:</line-14>
<line-15> rep_count[i] =1</line-15>
<line-16> for j in rep_count:</line-16>
<line-17> if rep_count[j] ==1:</line-17>
<line-18> sum1 += j * factorial(n - rep_count[j])</line-18>
<line-19> else:</line-19>
<line-20> sum1 += j * factorial(n-1)/ factorial(n - rep_count[j])</line-20>
<line-21> </line-21>
<line-22> for k in range(n):</line-22>
<line-24></line-24>
<line-25> print(int(final_sum))</line-25>
|
{"code": "<line-2>from math import factorial</line-2>\n<line-23> final_sum += sum1 * (10**k)</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> for i in range(n):</line-4>
<line-5> for j in range(n):</line-5>
<line-6> if i>=j:</line-6>
<line-8> print()</line-8>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-7> print(int((i+1)*(i+2)/2)-j,end='')</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>m = int(input())</line-3>
<line-4>for i in range(m):</line-4>
<line-5> a,b = map(int,input().split())</line-5>
<line-6> a -= 1</line-6>
<line-7> t = b-1</line-7>
<line-8> t1 = x[a]-b</line-8>
<line-9> if a-1>=0:</line-9>
<line-10> x[a-1] += t</line-10>
<line-11> if a+1<n:</line-11>
<line-12> x[a+1] += t1</line-12>
<line-13> x[a] = 0</line-13>
<line-15> print(i)</line-15>
|
{"code": "<line-2>x = [int(i) for i in input().split()]</line-2>\n<line-14>for i in x:</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>for t in range(int(input())):</line-1>
<line-3> a = sorted(map(int,input().split()))</line-3>
<line-4> ans = 1</line-4>
<line-5> for i in range(n):</line-5>
<line-6> ans *= (a[i]-i)</line-6>
<line-7> ans %= (10**9+7)</line-7>
<line-8> if (ans == 0):</line-8>
<line-10> print(ans) </line-10>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-9> break</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>n,m,lk = list(map(int,input().split()))</line-1>
<line-3>dp = []</line-3>
<line-4>for i in range(n):</line-4>
<line-5> dp += [[0]*n]</line-5>
<line-6>for i in range(n):</line-6>
<line-7> for j in range(n):</line-7>
<line-8> if(i!=j):</line-8>
<line-9> dp[i][j]=10**18</line-9>
<line-10>for _ in range(m):</line-10>
<line-11> x,y,z = list(map(int,input().split()))</line-11>
<line-12> dp[x-1][y-1]=z</line-12>
<line-13> dp[y-1][x-1]=z</line-13>
<line-14>for k in range(n):</line-14>
<line-15> for i in range(n):</line-15>
<line-16> for j in range(n):</line-16>
<line-17> if(dp[i][j]>dp[i][k]+dp[k][j]):</line-17>
<line-18> dp[i][j]=dp[i][k]+dp[k][j]</line-18>
<line-19>dist = 10**18</line-19>
<line-20>for i in range(lk):</line-20>
<line-21> for j in range(i+1,lk):</line-21>
<line-23>print(dist)</line-23>
|
{"code": "<line-2>sp = [int(i)-1 for i in input().split()]</line-2>\n<line-22> dist = min(dist,dp[sp[i]][sp[j]])</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> a=int(input())</line-3>
<line-4> b=int(input())</line-4>
<line-5> l=int(input())</line-5>
<line-6> x=0</line-6>
<line-7> y=0</line-7>
<line-8> z=0</line-8>
<line-9> a1=0</line-9>
<line-10> b1=0</line-10>
<line-11> c1=0</line-11>
<line-12> while(a//10!=0 or a%10!=0):</line-12>
<line-13> a1+=(a%10+((a//10)%10)*7+((a//100)%10)*49+((a//1000)%10)*343+((a//10000)%10)*2401+((a//100000)%10)*16807+((a//1000000)%10)*117649+((a//10000000)%10)*823543+((a//100000000)%10)*5764801+((a//1000000000)%10)*40353607)*(282475249**x)</line-13>
<line-14> x+=1</line-14>
<line-15> a//=10000000000</line-15>
<line-16> </line-16>
<line-17> while (b//10!=0 or b%10!=0):</line-17>
<line-18> b1+=(b%10+((b//10)%10)*7+((b//100)%10)*49+((b//1000)%10)*343+((b//10000)%10)*2401+((b//100000)%10)*16807+((b//1000000)%10)*117649+((b//10000000)%10)*823543+((b//100000000)%10)*5764801+((b//1000000000)%10)*40353607)*(282475249**y)</line-18>
<line-19> y+=1</line-19>
<line-20> b//=10000000000</line-20>
<line-21> c=(a1//b1)%(7**l)</line-21>
<line-22> while z<l:</line-22>
<line-23> c1+=(c%7+((c//7)%7)*10+((c//49)%7)*100+((c//343)%7)*1000+((c//2401)%7)*10000+((c//16807)%7)*100000+((c//117649)%7)*1000000+((c//823543)%7)*10000000+((c//5764801)%7)*100000000+((c//40353607)%7)*1000000000)*(10000000000**(z//10))</line-23>
<line-24> c//=282475249</line-24>
<line-25> z+=10</line-25>
<line-27> t-=1</line-27>
|
{"code": "<line-2>while t>0 :</line-2>\n<line-26>\tprint(c1)</line-26>", "lines": [2, 26]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n = len(edges)</line-3>
<line-4> visited = set()</line-4>
<line-5> parents = [-1]*(n+1)</line-5>
<line-6> dp = [0]*(n+1)</line-6>
<line-7> stack = [1]</line-7>
<line-8> w = float('inf')</line-8>
<line-9> x = -1</line-9>
<line-10> while stack:</line-10>
<line-11> node = stack[-1]</line-11>
<line-12> if node not in visited:</line-12>
<line-13> count = 0</line-13>
<line-14> for kid in edges[node]:</line-14>
<line-15> if parents[kid] == -1:</line-15>
<line-16> if kid != 1:</line-16>
<line-17> parents[kid] = node</line-17>
<line-18> else:</line-18>
<line-19> if kid != parents[node]:</line-19>
<line-20> if kid in visited:</line-20>
<line-21> count += 1</line-21>
<line-22> else:</line-22>
<line-23> stack.append(kid)</line-23>
<line-24></line-24>
<line-25> if node == 1:</line-25>
<line-26> count -= 1</line-26>
<line-27> if count == len(edges[node])-1:</line-27>
<line-28> stack.pop()</line-28>
<line-29> visited.add(node)</line-29>
<line-30> max_val = 0</line-30>
<line-31> for kid in edges[node]:</line-31>
<line-32> dp[node] += dp[kid]</line-32>
<line-33> max_val = max(max_val,dp[kid])</line-33>
<line-34></line-34>
<line-35> dp[node] += 1</line-35>
<line-36></line-36>
<line-37> max_val = max(max_val,n-dp[node])</line-37>
<line-38> if max_val < w:</line-38>
<line-39> w = max_val</line-39>
<line-40> x = node</line-40>
<line-41> elif max_val == w:</line-41>
<line-42> x = min(x,node)</line-42>
<line-43></line-43>
<line-44> ans.append(str(x)+' '+str(w))</line-44>
<line-45> </line-45>
<line-46>def main():</line-46>
<line-47> t = int(input())</line-47>
<line-48> ans = []</line-48>
<line-49> for i in range(t):</line-49>
<line-50> n = int(input())</line-50>
<line-51> edges = {}</line-51>
<line-52> for j in range(1,n+1):</line-52>
<line-53> edges[j] = []</line-53>
<line-54></line-54>
<line-55> for j in range(n-1):</line-55>
<line-56> x,y = list(map(int,input().split()))</line-56>
<line-57> edges[x].append(y)</line-57>
<line-58> edges[y].append(x)</line-58>
<line-59></line-59>
<line-60> solve(edges,ans)</line-60>
<line-61></line-61>
<line-63></line-63>
<line-64>main()</line-64>
|
{"code": "<line-2>def solve(edges,ans):</line-2>\n<line-62> print('\\n'.join(ans))</line-62>", "lines": [2, 62]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(test_cases):</line-3>
<line-4> no_of_elements = int(input())</line-4>
<line-5> sequence = list(map(int, input().split()))</line-5>
<line-6> d1 = sequence[1] - sequence[0]</line-6>
<line-7> d2 = sequence[2] - sequence[1]</line-7>
<line-8> d3 = (sequence[3] - sequence[0])/3</line-8>
<line-9> d4 = (sequence[3] - sequence[1])/2</line-9>
<line-10> d5 = (sequence[2] - sequence[0])/2</line-10>
<line-11></line-11>
<line-12> if (d2 == d4):</line-12>
<line-13> d = d2</line-13>
<line-14></line-14>
<line-15> elif(d3 == d5):</line-15>
<line-16> d = d3</line-16>
<line-17></line-17>
<line-18> elif(d1 == d3):</line-18>
<line-19> d = d1</line-19>
<line-20></line-20>
<line-21> elif(d1 == d5):</line-21>
<line-22> d = d1</line-22>
<line-23></line-23>
<line-24> if (d == d1):</line-24>
<line-25> for i in range(no_of_elements):</line-25>
<line-26> sequence[i] = int(sequence[0] + i*d)</line-26>
<line-27> else:</line-27>
<line-28> for i in range(no_of_elements):</line-28>
<line-29> sequence[i] = int(sequence[-1] - ((no_of_elements - i - 1)*d))</line-29>
<line-30></line-30>
<line-31> for i in sequence:</line-31>
<line-33></line-33>
<line-34> print('\n')</line-34>
<line-35></line-35>
<line-36></line-36>
|
{"code": "<line-2>test_cases = int(input())</line-2>\n<line-32> print(i, end=\" \")</line-32>", "lines": [2, 32]}
#### 0
|
<line-1>import math</line-1>
<line-3> f=0</line-3>
<line-4> for y in ar:</line-4>
<line-5> if aa%y==0:</line-5>
<line-6> return 0</line-6>
<line-7> return 1</line-7>
<line-8>ar=[]</line-8>
<line-9>ar.append(2)</line-9>
<line-10>pc=3</line-10>
<line-11>te=int(input())</line-11>
<line-12>for _ in range(te):</line-12>
<line-13> a=int(input())</line-13>
<line-14> f=0</line-14>
<line-15> c=0</line-15>
<line-16> add=0</line-16>
<line-17> for x in ar:</line-17>
<line-18> try:</line-18>
<line-19> add=add+ar[x-1]</line-19>
<line-20> except:</line-20>
<line-21> while True:</line-21>
<line-22> if prime(pc)==1:</line-22>
<line-23> ar.append(pc)</line-23>
<line-24> if x<=len(ar):</line-24>
<line-25> break</line-25>
<line-26> pc+=1</line-26>
<line-27> pc+=1</line-27>
<line-28> add=add+ar[x-1]</line-28>
<line-29> c+=1</line-29>
<line-30> if c==a:</line-30>
<line-32> print(add)</line-32>
|
{"code": "<line-2>def prime(aa):</line-2>\n<line-31>\t\t\tbreak</line-31>", "lines": [2, 31]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> while y: </line-3>
<line-4> x, y = y, x % y </line-4>
<line-5> return x </line-5>
<line-6></line-6>
<line-7>def LCM(x, y):</line-7>
<line-8> lcm = (x*y)//GCD(x,y)</line-8>
<line-9> return lcm</line-9>
<line-10></line-10>
<line-11>t = int(input())</line-11>
<line-12>while t>0:</line-12>
<line-13> x,y = list(map(int,input().split()))</line-13>
<line-15> t -=1</line-15>
|
{"code": "<line-2>def GCD(x, y): </line-2>\n<line-14> print(GCD(x,y),LCM(x,y)) </line-14>", "lines": [2, 14]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3> count = 0</line-3>
<line-4> k = input()</line-4>
<line-5> x = list(k)</line-5>
<line-6> kk = input()</line-6>
<line-7> y = list(kk)</line-7>
<line-8> for j in y:</line-8>
<line-9> for jj in x:</line-9>
<line-10> if(j==jj):</line-10>
<line-11> count = count+1</line-11>
<line-13> print(count)</line-13>
|
{"code": "<line-2>for i in range(n):</line-2>\n<line-12> break</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> k = int(input())</line-3>
<line-4> if k%n==0:</line-4>
<line-5> print("YES")</line-5>
<line-7> print("NO")</line-7>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-6> else:</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>eps=1e-8</line-1>
<line-3>for ii in range(t):</line-3>
<line-4> n=int(input())</line-4>
<line-5> l=[int(i) for i in input().split() ]</line-5>
<line-6> b=[int(i) for i in input().split() ]</line-6>
<line-7> v=[int(i) for i in input().split() ]</line-7>
<line-8> c=[int(i) for i in input().split() ]</line-8>
<line-9> greatest_time=l[0]/v[0]</line-9>
<line-10> for i in range(1,n):</line-10>
<line-11> if v[i]>0:</line-11>
<line-12> greatest_time=min(greatest_time,(l[i]-b[i])/v[i])</line-12>
<line-13> elif v[i]<0:</line-13>
<line-14> greatest_time=min(greatest_time,-b[i]/v[i])</line-14>
<line-15> p = sum((b[i] - c[i]) ** 2 for i in range(n))</line-15>
<line-16> q = sum(2 * (b[i] - c[i]) * v[i] for i in range(n))</line-16>
<line-17> r = sum(vi ** 2 for vi in v)</line-17>
<line-18> func = lambda t: p/t/t + q/t + r</line-18>
<line-19> #ternary search</line-19>
<line-20> </line-20>
<line-21> def ternsearch():</line-21>
<line-22> </line-22>
<line-23> if b==c:</line-23>
<line-24> return(0)</line-24>
<line-25> </line-25>
<line-26> lo,hi=0,greatest_time</line-26>
<line-27> while hi-lo>eps:</line-27>
<line-28> d=(hi-lo)/3</line-28>
<line-29> m1=lo+d</line-29>
<line-30> m2=m1+d</line-30>
<line-31> if func(m1)<=func(m2):</line-31>
<line-32> hi=m2</line-32>
<line-33> else:</line-33>
<line-34> lo=m1</line-34>
<line-35> #print(hi,lo)</line-35>
<line-36> #print(func(lo)**(0.5))</line-36>
<line-37> return max(0,func(lo))**(0.5)</line-37>
<line-39> print('%.12f' % (ans,))</line-39>
<line-40> </line-40>
<line-41> </line-41>
<line-42></line-42>
<line-43> </line-43>
<line-44> </line-44>
<line-45></line-45>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-38> ans=ternsearch()</line-38>", "lines": [2, 38]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> </line-3>
<line-4> T = int(input())</line-4>
<line-5></line-5>
<line-6> for i in range(T):</line-6>
<line-7> n = int(input())</line-7>
<line-8> s = input()</line-8>
<line-9> arr = [int(i) for i in input().strip().split(" ")]</line-9>
<line-10> res = 1</line-10>
<line-11> result = 0</line-11>
<line-12></line-12>
<line-13> for j in range(n-7):</line-13>
<line-14> res = 1</line-14>
<line-15> res1= 0</line-15>
<line-16> s1 = s[j:j+8]</line-16>
<line-17> for i in range(8):</line-17>
<line-18> if s1[i] == 'D':</line-18>
<line-19> res = res*2</line-19>
<line-20> res1 += arr[i]</line-20>
<line-21></line-21>
<line-22> elif s1[i] == 'T':</line-22>
<line-23> res = res*3</line-23>
<line-24> res1 = res1 + arr[i]</line-24>
<line-25> elif s1[i] == 'd':</line-25>
<line-26> res1 = res1 + arr[i]*2</line-26>
<line-27> elif s1[i] == 't':</line-27>
<line-28> res1 += arr[i]*3</line-28>
<line-29> else:</line-29>
<line-30> res1 += arr[i]</line-30>
<line-31> res = res*res1</line-31>
<line-32> result = max(res,result)</line-32>
<line-33> print(result)</line-33>
<line-35> pass</line-35>
<line-36></line-36>
<line-37> </line-37>
<line-38> </line-38>
<line-39> </line-39>
<line-40> </line-40>
<line-41> </line-41>
<line-42> </line-42>
|
{"code": "<line-2>try:</line-2>\n<line-34>except EOFError:</line-34>", "lines": [2, 34]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(int(input())):</line-3>
<line-4> n,m=list(map(int,input().split()))</line-4>
<line-5> atomlist = ['']*n</line-5>
<line-6> for k in range(m):</line-6>
<line-7> s=[]</line-7>
<line-8> s.extend(input().split()[1:])</line-8>
<line-9> #print(s)</line-9>
<line-10> for w in range(n):</line-10>
<line-11> if str(w) in s:</line-11>
<line-12> atomlist[w]+="1"</line-12>
<line-13> else:</line-13>
<line-14> atomlist[w]+="0"</line-14>
<line-16> print(len(set(atomlist)))</line-16>
|
{"code": "<line-2># cook your dish here</line-2>\n<line-15> #print(atomlist)</line-15>", "lines": [2, 15]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n=int(input())</line-3>
<line-4> i=0</line-4>
<line-5> while i<n-1:</line-5>
<line-6> if i==0:</line-6>
<line-7> print("*",end="")</line-7>
<line-8> else:</line-8>
<line-9> print("*",end="")</line-9>
<line-10> for k in range(i-1):</line-10>
<line-11> print(" ",end="")</line-11>
<line-12> print("*",end="")</line-12>
<line-13> print() </line-13>
<line-14> i+=1 </line-14>
<line-15> for i in range(n):</line-15>
<line-16> print("*",end="")</line-16>
<line-17> print() </line-17>
<line-18></line-18>
<line-19>t=int(input())</line-19>
<line-20>i=0</line-20>
<line-21>while(i<t):</line-21>
<line-23> </line-23>
<line-24> i+=1</line-24>
|
{"code": "<line-2>def solve():</line-2>\n<line-22> solve()</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>for i in range(eval(input())):</line-1>
<line-3> n=int(n)</line-3>
<line-5> print(int( ((n-k)&(int((k-1)/2)))==0))</line-5>
|
{"code": "<line-2> n,k=input().strip().split()</line-2>\n<line-4> k=int(k)</line-4>", "lines": [2, 4]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> if (a==0) or (b==0) or (c==0):</line-3>
<line-4> return "NO"</line-4>
<line-5> else:</line-5>
<line-6> i=3</line-6>
<line-7> while(i>0):</line-7>
<line-8> if (a*a)==(b*b)+(c*c):</line-8>
<line-9> return "YES"</line-9>
<line-10> else:</line-10>
<line-11> t=a</line-11>
<line-12> a=b</line-12>
<line-13> b=c</line-13>
<line-14> c=t</line-14>
<line-15> i-=1</line-15>
<line-16> return "NO"</line-16>
<line-17>try:</line-17>
<line-18> for _ in range(int(input())):</line-18>
<line-19> a,b,c=map(int,input().split())</line-19>
<line-20> print(check(a,b,c))</line-20>
<line-21>except:</line-21>
<line-23> pass</line-23>
|
{"code": "<line-2>def check(a,b,c):</line-2>\n<line-22> print(e)</line-22>", "lines": [2, 22]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> d1,v1,d2,v2,p=map(int, input().split())</line-3>
<line-4> total=0</line-4>
<line-5> while p>0:</line-5>
<line-6> total+=1</line-6>
<line-7> if total>=d1:</line-7>
<line-8> p=p-v1</line-8>
<line-9> if total>=d2:</line-9>
<line-10> p=p-v2</line-10>
<line-11> print(total) </line-11>
<line-13> pass</line-13>
|
{"code": "<line-2>try:</line-2>\n<line-12>except:</line-12>", "lines": [2, 12]}
#### 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> arr=list(map(int,input().split()))</line-5>
<line-6> left=[-1 for i in range(n)]</line-6>
<line-7> right=[-1 for i in range(n)]</line-7>
<line-8> min1=float("inf")</line-8>
<line-9> for i in range(n):</line-9>
<line-10> min1=min(arr[i],min1+1)</line-10>
<line-11> left[i]=min1</line-11>
<line-12> min1=float("inf")</line-12>
<line-13> for i in range(n-1,-1,-1):</line-13>
<line-14> min1=min(arr[i],min1+1)</line-14>
<line-15> right[i]=min1</line-15>
<line-16> for i in range(n):</line-16>
<line-18> print("",end="\n")</line-18>
|
{"code": "<line-2>T=int(input())</line-2>\n<line-17> print(min(left[i],right[i]),end=\" \")</line-17>", "lines": [2, 17]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(int(input())):</line-3>
<line-4> k=int(input())</line-4>
<line-5> c=[]</line-5>
<line-6> d=[]</line-6>
<line-7> start=0</line-7>
<line-8></line-8>
<line-9> while True:</line-9>
<line-10> c=[]</line-10>
<line-11> for i in range(start):</line-11>
<line-12> c.append(" ")</line-12>
<line-13> for i in range(start,k+1):</line-13>
<line-14> c.append(str(i))</line-14>
<line-15> start+=1</line-15>
<line-16> d.append(c)</line-16>
<line-17></line-17>
<line-18> if start>k:</line-18>
<line-19> break</line-19>
<line-20></line-20>
<line-21> e=copy.copy(d[1:])</line-21>
<line-22> d.reverse()</line-22>
<line-23> d=d+e</line-23>
<line-24> ##print(d)</line-24>
<line-26> print(''.join(d[i]))</line-26>
<line-27></line-27>
<line-28></line-28>
|
{"code": "<line-2>import copy</line-2>\n<line-25> for i in range(len(d)):</line-25>", "lines": [2, 25]}
#### 0
|
<line-1># Python3 program to find XNOR</line-1>
<line-3>import math</line-3>
<line-4></line-4>
<line-5></line-5>
<line-6>def swap(a, b):</line-6>
<line-7> temp = a</line-7>
<line-8> a = b</line-8>
<line-9> b = temp</line-9>
<line-10></line-10>
<line-11></line-11>
<line-12># log(n) solution</line-12>
<line-13>def xnor(a, b):</line-13>
<line-14> # Make sure a is larger</line-14>
<line-15> if (a < b):</line-15>
<line-16> swap(a, b)</line-16>
<line-17></line-17>
<line-18> if (a == 0 and b == 0):</line-18>
<line-19> return 1;</line-19>
<line-20></line-20>
<line-21> # for last bit of a</line-21>
<line-22> a_rem = 0</line-22>
<line-23></line-23>
<line-24> # for last bit of b</line-24>
<line-25> b_rem = 0</line-25>
<line-26></line-26>
<line-27> # counter for count bit and</line-27>
<line-28> # set bit in xnor num</line-28>
<line-29> count = 0</line-29>
<line-30></line-30>
<line-31> # for make new xnor number</line-31>
<line-32> xnornum = 0</line-32>
<line-33></line-33>
<line-34> # for set bits in new xnor</line-34>
<line-35> # number</line-35>
<line-36> while (a != 0):</line-36>
<line-37></line-37>
<line-38> # get last bit of a</line-38>
<line-39> a_rem = a & 1</line-39>
<line-40></line-40>
<line-41> # get last bit of b</line-41>
<line-42> b_rem = b & 1</line-42>
<line-43></line-43>
<line-44> # Check if current two</line-44>
<line-45> # bits are same</line-45>
<line-46> if (a_rem == b_rem):</line-46>
<line-47> xnornum |= (1 << count)</line-47>
<line-48></line-48>
<line-49> # counter for count bit</line-49>
<line-50> count = count + 1</line-50>
<line-51></line-51>
<line-52> a = a >> 1</line-52>
<line-53> b = b >> 1</line-53>
<line-54></line-54>
<line-55> return xnornum;</line-55>
<line-56></line-56>
<line-57></line-57>
<line-58>t= int(input())</line-58>
<line-59>for o in range(t):</line-59>
<line-60> a,b,n=map(int,input().split())</line-60>
<line-61> c=a^b</line-61>
<line-62> x=bin(c)</line-62>
<line-63> x=x.split("b")</line-63>
<line-64> x=x[1]</line-64>
<line-65> x=len(x)</line-65>
<line-66> d=xnor(a,b)</line-66>
<line-67> p=[a,b,c];r=[a,b,d]</line-67>
<line-68> k=n%3-1</line-68>
<line-69> if p[k]>r[k]:</line-69>
<line-70> print(p[k])</line-70>
<line-72> print(r[k])</line-72>
|
{"code": "<line-2># of two numbers</line-2>\n<line-71> else :</line-71>", "lines": [2, 71]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>t=int(input())</line-3>
<line-4>while(t>0):</line-4>
<line-5> s=list(input().split(' '))</line-5>
<line-6> if("not" in s):</line-6>
<line-7> print("Real Fancy")</line-7>
<line-8> else:</line-8>
<line-10> t=t-1</line-10>
|
{"code": "<line-2>import re</line-2>\n<line-9> print(\"regularly fancy\")</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>for _ in range(n):</line-5>
<line-6> p1, p2, m = list(map(int, sys.stdin.readline().split()))</line-6>
<line-7></line-7>
<line-8> l = min(p1, p2)</line-8>
<line-9></line-9>
<line-10> #while(m > 0 and l > 0):</line-10>
<line-11> # k = min(l, m)</line-11>
<line-12> # l -= k</line-12>
<line-13> # m -= 1</line-13>
<line-14></line-14>
<line-15> q = min(p1, p2)</line-15>
<line-17></line-17>
<line-18> print(p1 - d + p2 - d)</line-18>
|
{"code": "<line-3>n = int(sys.stdin.readline())</line-3>\n<line-16> d = min((m * (m + 1)) / 2, q)</line-16>", "lines": [3, 16]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>n, m = map(int,stdin.readline().split())</line-3>
<line-4>forest=[]</line-4>
<line-5>matrix=[]</line-5>
<line-6>for _ in range(n):</line-6>
<line-7> forest.append(list(map(int,stdin.readline().split())))</line-7>
<line-8> matrix.append([0]*m)</line-8>
<line-9>matrix[0][0]=forest[0][0]</line-9>
<line-10>for j in range(1,m):</line-10>
<line-11> matrix[0][j]=matrix[0][j-1]+forest[0][j]</line-11>
<line-12>for i in range(1,n):</line-12>
<line-13> matrix[i][0]=matrix[i-1][0]+forest[i][0]</line-13>
<line-14>for i in range(1,n):</line-14>
<line-15> for j in range(1,m):</line-15>
<line-16> matrix[i][j]=matrix[i-1][j]+matrix[i][j-1]-matrix[i-1][j-1]+forest[i][j]</line-16>
<line-17>c=int(input())</line-17>
<line-18>for _ in range(c):</line-18>
<line-19> x1, y1, x2, y2 = map(int,stdin.readline().split())</line-19>
<line-20> x1-=1 </line-20>
<line-21> y1-=1 </line-21>
<line-22> x2-=1 </line-22>
<line-23> y2-=1 </line-23>
<line-24> appo=0</line-24>
<line-25> if x1>0:</line-25>
<line-26> appo+=matrix[x1-1][y2]</line-26>
<line-27> if y1>0:</line-27>
<line-28> appo+=matrix[x2][y1-1]</line-28>
<line-29> if x1>0 and y1>0:</line-29>
<line-31> print(matrix[x2][y2]-appo)</line-31>
|
{"code": "<line-2>from sys import stdin</line-2>\n<line-30> appo-=matrix[x1-1][y1-1]</line-30>", "lines": [2, 30]}
#### 0
|
<line-1>from math import *</line-1>
<line-3>for i in range(t):</line-3>
<line-4> m,b=input().split()</line-4>
<line-5> m=int(m)</line-5>
<line-7> print(2*gcd(m,b))</line-7>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-6> b=int(b)</line-6>", "lines": [2, 6]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> for t in range(int(input())):</line-3>
<line-4> n=int(input())</line-4>
<line-5> ans=n*n*n+((n-1)**2)</line-5>
<line-6> if ans<=10**9+7:</line-6>
<line-7> print(ans)</line-7>
<line-8> else:</line-8>
<line-9> print(ans)%(10**9+7)</line-9>
<line-11> pass</line-11>
|
{"code": "<line-2>try:</line-2>\n<line-10>except:</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> num = ""</line-3>
<line-4> val = 1</line-4>
<line-5> for i in range(n):</line-5>
<line-6> num += str(val)</line-6>
<line-7> if val == 1:</line-7>
<line-8> val = 0</line-8>
<line-9> else:</line-9>
<line-10> val = 1</line-10>
<line-12> print(num)</line-12>
<line-13> </line-13>
<line-14> </line-14>
|
{"code": "<line-2>\tn = int(input())</line-2>\n<line-11>\tfor i in range(n):</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> S = input()</line-3>
<line-4> R = input()</line-4>
<line-5> if S.count("1") == R.count("1"):</line-5>
<line-6> print("YES")</line-6>
<line-8> print("NO")</line-8>
|
{"code": "<line-2> length = int(input())</line-2>\n<line-7> else:</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>"""</line-1>
<line-3>"""</line-3>
<line-4></line-4>
<line-5></line-5>
<line-6>def find_destroyed_cells(cell_advance, n, m, k):</line-6>
<line-7> row = 1</line-7>
<line-8> col = 1</line-8>
<line-9> destroyed_cells = {(1, 1)}</line-9>
<line-10> while True:</line-10>
<line-11> row, col = cell_advance(row, col, n, m, k)</line-11>
<line-12> if row <= n and col <= m:</line-12>
<line-13> destroyed_cells.add((row, col))</line-13>
<line-14> else:</line-14>
<line-15> break</line-15>
<line-16> return destroyed_cells</line-16>
<line-17></line-17>
<line-18></line-18>
<line-19>def cell_advance_hero1(row, col, n, m, k):</line-19>
<line-20> return row + (col + k) // m, (col + k) % m + 1</line-20>
<line-21></line-21>
<line-22></line-22>
<line-23>def cell_advance_hero2(row, col, n, m, k):</line-23>
<line-24> return (row + k) % n + 1, col + (row + k)//n</line-24>
<line-25></line-25>
<line-26></line-26>
<line-27>def main():</line-27>
<line-28> t = int(input())</line-28>
<line-29> for _ in range(t):</line-29>
<line-30> n, m = [int(s) for s in input().split(' ')]</line-30>
<line-31> counts = []</line-31>
<line-32> for k in range(n*m):</line-32>
<line-33> cells_h1 = find_destroyed_cells(cell_advance_hero1, n, m, k)</line-33>
<line-34> cells_h2 = find_destroyed_cells(cell_advance_hero2, n, m, k)</line-34>
<line-35></line-35>
<line-36> destroyed = len(cells_h1) + len(cells_h2) - len(cells_h1 & cells_h2)</line-36>
<line-37> counts.append(destroyed)</line-37>
<line-39></line-39>
<line-40></line-40>
<line-41>main()</line-41>
|
{"code": "<line-2>Code chef problem DESTCELL, Destroy Cells</line-2>\n<line-38> print(' '.join([str(c) for c in counts]))</line-38>", "lines": [2, 38]}
#### 0
|
<line-1>r = 1000000007</line-1>
<line-3>for i in range(t):</line-3>
<line-5> print(pow(3,n,r) + pow(-1,n)*3)</line-5>
<line-6> </line-6>
|
{"code": "<line-2>t = int(input())</line-2>\n<line-4> n = int(input())</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>fact = []</line-1>
<line-3>for i in range(1,100001):</line-3>
<line-4> fact.append((i*fact[i-1])%1000000007)</line-4>
<line-5> </line-5>
<line-6>def power(a,b,p):</line-6>
<line-7> x=1</line-7>
<line-8> y=a</line-8>
<line-9> while(b>0):</line-9>
<line-10> if(b%2 == 1):</line-10>
<line-11> x=(x*y)</line-11>
<line-12> if(x>p):</line-12>
<line-13> x=x%p</line-13>
<line-14> y=(y*y)</line-14>
<line-15> if(y>p):</line-15>
<line-16> y=y%p</line-16>
<line-17> b=b/2</line-17>
<line-18> </line-18>
<line-19> return x</line-19>
<line-20> </line-20>
<line-21>def inverse(N,p):</line-21>
<line-22> return power(N,p-2,p)</line-22>
<line-23> </line-23>
<line-24>def combination(N,R,p):</line-24>
<line-25> return (fact[N]*((inverse(fact[R],p)*inverse(fact[N-R],p))%p))%p</line-25>
<line-26> </line-26>
<line-27>T = int(input())</line-27>
<line-28> </line-28>
<line-29>for i in range(T):</line-29>
<line-30> N,K = [int(y) for y in input().split()]</line-30>
<line-31> A = [int(arr) for arr in input().split()]</line-31>
<line-32> numZ = 0;</line-32>
<line-33> answer = 0;</line-33>
<line-34> p = 1000000007</line-34>
<line-35> for j in range(len(A)):</line-35>
<line-36> if(A[j] == 0):</line-36>
<line-37> numZ = numZ + 1</line-37>
<line-38> N = N - numZ</line-38>
<line-39> if(numZ > 0):</line-39>
<line-40> if(N > K):</line-40>
<line-41> temp = K;</line-41>
<line-42> while(temp >= 0):</line-42>
<line-43> answer = answer + combination(N,temp,p)</line-43>
<line-44> temp = temp - 1</line-44>
<line-45> else:</line-45>
<line-46> temp = N</line-46>
<line-47> while(temp >= 0):</line-47>
<line-48> answer = answer + combination(N,temp,p)</line-48>
<line-49> temp = temp - 1</line-49>
<line-50> else:</line-50>
<line-51> if(N > K):</line-51>
<line-52> temp = K;</line-52>
<line-53> while(temp >= 0):</line-53>
<line-54> answer = answer + combination(N,temp,p)</line-54>
<line-55> temp = temp - 2</line-55>
<line-56> else:</line-56>
<line-57> temp = N</line-57>
<line-58> while(temp >= 0):</line-58>
<line-59> answer = answer + combination(N,temp,p)</line-59>
<line-61> print(answer%1000000007)</line-61>
|
{"code": "<line-2>fact.append(1)</line-2>\n<line-60> temp = temp - 2</line-60>", "lines": [2, 60]}
#### 0
|
<line-1>x=int(input())</line-1>
<line-3> n=int(input())</line-3>
<line-4> L=[str(n)]</line-4>
<line-5> c=1</line-5>
<line-6> while(len(L)!=n):</line-6>
<line-7> L.append(str(n+c))</line-7>
<line-8> if len(L)==n:</line-8>
<line-9> break</line-9>
<line-10> L.append(str(n-c))</line-10>
<line-11></line-11>
<line-12> c+=1</line-12>
<line-13></line-13>
<line-15></line-15>
<line-16> print(a)</line-16>
|
{"code": "<line-2>for a in range(x):</line-2>\n<line-14> a=\" \".join(L)</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> k = bin(n)</line-4>
<line-5> k = k[2:]</line-5>
<line-6> z = len(k)</line-6>
<line-7> c = '1'*z</line-7>
<line-8> if c == k:</line-8>
<line-9> return False</line-9>
<line-10></line-10>
<line-11>def find(n):</line-11>
<line-12></line-12>
<line-13> x = bin(n)[2:]</line-13>
<line-14> str = ''</line-14>
<line-15> for i in x[::-1]:</line-15>
<line-16> if i == '0':</line-16>
<line-17> str+='1'</line-17>
<line-18> break</line-18>
<line-19> else:</line-19>
<line-20> str+='0'</line-20>
<line-21></line-21>
<line-22> return int(str[::-1],2)</line-22>
<line-23></line-23>
<line-25></line-25>
<line-26> n = int(input())</line-26>
|
{"code": "<line-3>def conv(n):</line-3>\n<line-24>for i in range(t):</line-24>", "lines": [3, 24]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3> a, b = list(map(str, input().split()))</line-3>
<line-4> a = int(a[::-1])</line-4>
<line-5> b = int(b[::-1])</line-5>
<line-6> a = str(a + b)</line-6>
<line-8> print(a)</line-8>
|
{"code": "<line-2>for index in range(0, n):</line-2>\n<line-7> a = int(a[::-1])</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>#import set</line-1>
<line-3>while(t):</line-3>
<line-4> s = input()</line-4>
<line-5> set1 = set()</line-5>
<line-6> j = 0</line-6>
<line-7> for i in s[:-1]:</line-7>
<line-8> a = s[j:j+2]</line-8>
<line-9> set1.add(a)</line-9>
<line-10> j = j + 1</line-10>
<line-12> t= t-1</line-12>
<line-13> </line-13>
|
{"code": "<line-2>t = eval(input()) </line-2>\n<line-11> print(str(len(set1)) + '\\n')</line-11>", "lines": [2, 11]}
#### 0
|
<line-1># Problem: http://www.codechef.com/JULY09/submit/CUBESUM/ </line-1>
<line-3></line-3>
<line-4>def computeA():</line-4>
<line-5> X, Y, Z = [int(x) for x in input().split()]</line-5>
<line-6> B = []</line-6>
<line-7> for x in range(X):</line-7>
<line-8> B.append([])</line-8>
<line-9> for y in range(Y):</line-9>
<line-10> B[-1].append([int(t) for t in input().split()])</line-10>
<line-11> for z in range(Z):</line-11>
<line-12> result = B[x][y][z]</line-12>
<line-13> if x:</line-13>
<line-14> result -= B[x - 1][y][z]</line-14>
<line-15> if y:</line-15>
<line-16> result += B[x - 1][y - 1][z]</line-16>
<line-17> if z:</line-17>
<line-18> result -= B[x - 1][y - 1][z - 1]</line-18>
<line-19> </line-19>
<line-20> if y:</line-20>
<line-21> result -= B[x][y - 1][z]</line-21>
<line-22> if z:</line-22>
<line-23> result += B[x][y - 1][z - 1]</line-23>
<line-24> if z:</line-24>
<line-25> result -= B[x][y][z - 1]</line-25>
<line-26> if x:</line-26>
<line-27> result += B[x - 1][y][z - 1]</line-27>
<line-28> print(result, end=' ')</line-28>
<line-29> print()</line-29>
<line-30></line-30>
<line-31>test_cases = int(input())</line-31>
<line-33> computeA()</line-33>
|
{"code": "<line-2># Author: Susam Pal</line-2>\n<line-32>for i in range(test_cases):</line-32>", "lines": [2, 32]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>mod = 10**9 + 7</line-4>
<line-5>ts = int(input())</line-5>
<line-6>while ts > 0:</line-6>
<line-7> n,q = list(map(int,input().split()))</line-7>
<line-8> ncc = n-1</line-8>
<line-9> par = [i for i in range(n)]</line-9>
<line-10> rank = [1]*n</line-10>
<line-11> xor = [0]*n</line-11>
<line-12> flag = 1</line-12>
<line-13></line-13>
<line-14> def find(a):</line-14>
<line-15> if par[a] == a:</line-15>
<line-16> return a</line-16>
<line-17> else:</line-17>
<line-18> temp = find(par[a])</line-18>
<line-19> xor[a]^=xor[par[a]]</line-19>
<line-20> par[a] = temp</line-20>
<line-21> return temp</line-21>
<line-22></line-22>
<line-23> def union(a,b): </line-23>
<line-24> a,b = find(a),find(b)</line-24>
<line-25> if a ==b:</line-25>
<line-26> return </line-26>
<line-27> if rank[a] > rank[b]:</line-27>
<line-28> par[b] = a</line-28>
<line-29></line-29>
<line-30> rank[a]+=rank[b]</line-30>
<line-31> elif rank[a] < rank[b]:</line-31>
<line-32> par[a] = b</line-32>
<line-33> rank[b]+=rank[a]</line-33>
<line-34> else:</line-34>
<line-35> par[b] = a</line-35>
<line-36> rank[a]+=rank[b]</line-36>
<line-37> par[b] =a</line-37>
<line-38></line-38>
<line-39> for _ in range(q):</line-39>
<line-40> </line-40>
<line-41> a,b,x = list(map(int,input().split()))</line-41>
<line-42> a-=1</line-42>
<line-43> b-=1</line-43>
<line-44> if flag == -1:</line-44>
<line-45> continue</line-45>
<line-46> para = find(a)</line-46>
<line-47> parb = find(b)</line-47>
<line-48></line-48>
<line-49> if para == parb and xor[a] ^ xor[b] != x:</line-49>
<line-50> flag = -1 </line-50>
<line-51> continue</line-51>
<line-52> # print("no")</line-52>
<line-53></line-53>
<line-54> if para != parb:</line-54>
<line-55> if rank[para] < rank[parb]:</line-55>
<line-56> xor[para] = xor[a] ^ xor[b] ^ x</line-56>
<line-57> par[para] = parb</line-57>
<line-58> rank[parb]+=rank[para]</line-58>
<line-59> else:</line-59>
<line-60> xor[parb] = xor[a] ^ xor[b] ^ x</line-60>
<line-61> par[parb] = para</line-61>
<line-62> rank[para]+=rank[parb]</line-62>
<line-63> ncc-=1</line-63>
<line-64> </line-64>
<line-65> if flag != -1:</line-65>
<line-66> print("yes")</line-66>
<line-67> else:</line-67>
<line-69> </line-69>
<line-70> ts-=1</line-70>
|
{"code": "<line-2>sys.setrecursionlimit(1000000)</line-2>\n<line-68> print(\"no\")</line-68>", "lines": [2, 68]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> s=input()</line-3>
<line-4> d={}</line-4>
<line-5> for j in s:</line-5>
<line-6> if j not in d:</line-6>
<line-7> d[j]=1</line-7>
<line-8> else:</line-8>
<line-9> d[j]+=1</line-9>
<line-10> f=0</line-10>
<line-11> for j in d:</line-11>
<line-12> if(d[j]%2==1):</line-12>
<line-13> f=f+1</line-13>
<line-14> if((n//2)%2==0 and f==0):</line-14>
<line-15> print("YES")</line-15>
<line-16> continue</line-16>
<line-17> if((n//2)%2==1 and f<=2 and f%2==0):</line-17>
<line-18> print("YES")</line-18>
<line-20> print("NO")</line-20>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-19> continue</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> size=int(input())</line-3>
<line-4> li=list(map(int,input().split()))</line-4>
<line-5> c = 0</line-5>
<line-6> for i in li:</line-6>
<line-7> if(i >=len(li)/2):</line-7>
<line-9> print(c)</line-9>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-8> c += 1</line-8>", "lines": [2, 8]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>import math</line-3>
<line-4>from collections import Counter</line-4>
<line-5>from collections import OrderedDict </line-5>
<line-6>def inputt():</line-6>
<line-7> return sys.stdin.readline().strip()</line-7>
<line-8>def printt(n):</line-8>
<line-9> sys.stdout.write(str(n)+'\n')</line-9>
<line-10>def listt():</line-10>
<line-11> return [int(i) for i in inputt().split()]</line-11>
<line-12>def gcd(a,b): </line-12>
<line-13> return math.gcd(a,b) </line-13>
<line-14> </line-14>
<line-15>def lcm(a,b): </line-15>
<line-16> return (a*b) / gcd(a,b) </line-16>
<line-17>from collections import defaultdict </line-17>
<line-18></line-18>
<line-19>def find_sub_string(str): </line-19>
<line-20> str_len = len(str) </line-20>
<line-21> </line-21>
<line-22> # Count all distinct characters. </line-22>
<line-23> dist_count_char = len(set([x for x in str])) </line-23>
<line-24> </line-24>
<line-25> ctr, start_pos, start_pos_index, min_len = 0, 0, -1, 9999999999</line-25>
<line-26> curr_count = defaultdict(lambda: 0) </line-26>
<line-27> for i in range(str_len): </line-27>
<line-28> curr_count[str[i]] += 1</line-28>
<line-29> </line-29>
<line-30> if curr_count[str[i]] == 1: </line-30>
<line-31> ctr += 1</line-31>
<line-32> </line-32>
<line-33> if ctr == dist_count_char: </line-33>
<line-34> while curr_count[str[start_pos]] > 1: </line-34>
<line-35> if curr_count[str[start_pos]] > 1: </line-35>
<line-36> curr_count[str[start_pos]] -= 1</line-36>
<line-37> start_pos += 1</line-37>
<line-38> </line-38>
<line-39> len_window = i - start_pos + 1</line-39>
<line-40> if min_len > len_window: </line-40>
<line-41> min_len = len_window </line-41>
<line-42> start_pos_index = start_pos </line-42>
<line-43> return str[start_pos_index: start_pos_index + min_len]</line-43>
<line-44>t= int(inputt())</line-44>
<line-45>for _ in range(t):</line-45>
<line-46> j=[]</line-46>
<line-47> str1 =inputt()</line-47>
<line-48> s=find_sub_string(str1) </line-48>
<line-49> for i in s:</line-49>
<line-50> j.append(abs(97-ord(i))+1)</line-50>
<line-52> print(''.join(st)) </line-52>
<line-53></line-53>
<line-54></line-54>
|
{"code": "<line-2>import sys</line-2>\n<line-51> st = [str(i) for i in j]</line-51>", "lines": [2, 51]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-2> </line-2>
<line-4></line-4>
<line-5>while t:</line-5>
<line-6> m = int(input())</line-6>
<line-8> </line-8>
<line-9> </line-9>
<line-10> t -= 1</line-10>
|
{"code": "<line-3>t = int(input())</line-3>\n<line-7> print(int(m * (m + 1) * (2 * m + 1) / 6))</line-7>", "lines": [3, 7]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>T = int(input())</line-3>
<line-4>for _ in range(T):</line-4>
<line-5> N, A, K = map(int, input().split(" "))</line-5>
<line-6> total = (N-2) * 180</line-6>
<line-7> diffT = total - N*A</line-7>
<line-8> diffN = sum(range(1,N))</line-8>
<line-9> r = (A*diffN+(K-1)*diffT)</line-9>
<line-10> </line-10>
<line-11> d = math.gcd(r, diffN)</line-11>
<line-12> while d > 1:</line-12>
<line-13> r//=d</line-13>
<line-14> diffN//=d</line-14>
<line-16> print(r, diffN)</line-16>
|
{"code": "<line-2>import math</line-2>\n<line-15> d = math.gcd(r, diffN)</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>import sys</line-1>
<line-3>input = sys.stdin.readline</line-3>
<line-4>sys.setrecursionlimit(1000000)</line-4>
<line-5></line-5>
<line-6>arr=[int(x) for x in input().split()]</line-6>
<line-7></line-7>
<line-8>if arr[0]==1:</line-8>
<line-9> print(0)</line-9>
<line-10> return</line-10>
<line-11></line-11>
<line-12>p=[None]</line-12>
<line-13>for i in range(1,arr[0]+1):</line-13>
<line-14> p.append(arr[i])</line-14>
<line-15> </line-15>
<line-16>a=[None]</line-16>
<line-17>for i in range(arr[0]+1,2*arr[0]+1):</line-17>
<line-18> a.append(arr[i])</line-18>
<line-19></line-19>
<line-20>graph=defaultdict(list)</line-20>
<line-21></line-21>
<line-22>n=len(a)-1</line-22>
<line-23>for i in range(1,n+1):</line-23>
<line-24> if a[i]==-1:</line-24>
<line-25> source=i</line-25>
<line-26> continue</line-26>
<line-27> graph[a[i]].append((i,(p[a[i]]-p[i])))</line-27>
<line-28></line-28>
<line-29>def func(node):</line-29>
<line-30> nonlocal res</line-30>
<line-31> </line-31>
<line-32> if len(graph[node])==0:</line-32>
<line-33> return -10**9</line-33>
<line-34> </line-34>
<line-35> curr=-10**9</line-35>
<line-36> for child in graph[node]:</line-36>
<line-37> x=max(child[1],(func(child[0])+child[1]))</line-37>
<line-38> curr=max(curr,x)</line-38>
<line-39> res=max(curr,res)</line-39>
<line-40> </line-40>
<line-41> return curr </line-41>
<line-42></line-42>
<line-43>res=-10**9</line-43>
<line-45>print(res) </line-45>
<line-46> </line-46>
<line-47> </line-47>
<line-48> </line-48>
|
{"code": "<line-2>from collections import defaultdict</line-2>\n<line-44>curr=func(source)</line-44>", "lines": [2, 44]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(a):</line-3>
<line-4> n = int(input())</line-4>
<line-5> if n%2==0:</line-5>
<line-6> print('NO')</line-6>
<line-7> else:</line-7>
<line-8> print('YES')</line-8>
<line-9> for i1 in range(n):</line-9>
<line-10> li = [0]*n</line-10>
<line-11> b = str()</line-11>
<line-12> for i2 in range((n-1)//2):</line-12>
<line-13> li[(i1+i2+1)%n]+=1</line-13>
<line-14> for i3 in range(len(li)):</line-14>
<line-16> print(b)</line-16>
|
{"code": "<line-2>a = int(input())</line-2>\n<line-15> b+=str(li[i3])</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>def f(n):</line-1>
<line-2></line-2>
<line-4> low = []</line-4>
<line-5> high = []</line-5>
<line-6></line-6>
<line-7> for i in range(n - 1):</line-7>
<line-8> low.append(min(s[i], s[i+1]))</line-8>
<line-9> high.append(max(s[i], s[i+1]))</line-9>
<line-10> low.sort()</line-10>
<line-11> high.sort()</line-11>
<line-12> curr = mx = 0</line-12>
<line-13> i = j = 0</line-13>
<line-14> n -= 1</line-14>
<line-15> while i < n and j < n:</line-15>
<line-16> if low[i] < high[j]:</line-16>
<line-17> i += 1</line-17>
<line-18> curr += 1</line-18>
<line-19> else:</line-19>
<line-20> j += 1</line-20>
<line-21> curr -= 1</line-21>
<line-22> mx = max(mx, curr)</line-22>
<line-23></line-23>
<line-24> return mx </line-24>
<line-25> </line-25>
<line-27>print(f(n))</line-27>
|
{"code": "<line-3> s = list(map(int, input().split()))</line-3>\n<line-26>n = int(input())</line-26>", "lines": [3, 26]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> n=int(input())</line-3>
<line-4> o=int(input())</line-4>
<line-5> ans=4*(m+n+o)-24</line-5>
<line-6> if(ans <= 0):</line-6>
<line-7> print('0')</line-7>
<line-9> print(ans)</line-9>
|
{"code": "<line-2> m=int(input())</line-2>\n<line-8> else:</line-8>", "lines": [2, 8]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n = int(input())</line-3>
<line-4> l = []</line-4>
<line-5> for i in range(1,n+1):</line-5>
<line-6> l.append(i)</line-6>
<line-7> </line-7>
<line-8> for j in range(n):</line-8>
<line-9> s = ""</line-9>
<line-10> for k in l:</line-10>
<line-11> s+=str(k)</line-11>
<line-12> print(s)</line-12>
<line-13> x = l[0]</line-13>
<line-15> l.append(x)</line-15>
|
{"code": "<line-2>for a0 in range(int(input())):</line-2>\n<line-14> l.pop(0)</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>class Dsu:</line-1>
<line-3> self.par = s</line-3>
<line-4> self.v = v</line-4>
<line-5> self.dr = [1] * v</line-5>
<line-6> self.zero = [False] * v</line-6>
<line-7> self.speed = []</line-7>
<line-8> for i in range(v):</line-8>
<line-9> self.speed.append([])</line-9>
<line-10> self.speed[i].append(i)</line-10>
<line-11></line-11>
<line-12> def find(self, i):</line-12>
<line-13> # if parent[i] == -1:</line-13>
<line-14> # return i</line-14>
<line-15> # else: return self.find_parent(parent, parent[i])</line-15>
<line-16> if i != self.par[i][0]:</line-16>
<line-17> org = self.par[i][0]</line-17>
<line-18> self.par[i][0] = self.find(self.par[i][0])</line-18>
<line-19> if self.zero[i] or self.zero[self.par[i][0]] or self.zero[org]:</line-19>
<line-20> self.zero[i] = self.zero[self.par[i][0]] = self.zero[org] = True</line-20>
<line-21> if org != self.par[i][0]:</line-21>
<line-22> self.speed[self.par[i][0]].append(i)</line-22>
<line-23> return self.par[i][0]</line-23>
<line-24></line-24>
<line-25> def union(self, x, y):</line-25>
<line-26> # def union(self, parent, x, y):</line-26>
<line-27> # x_set = self.find_parent(parent, x)</line-27>
<line-28> # y_set = self.find_parent(parent, y)</line-28>
<line-29> # parent[x_set] = y_set</line-29>
<line-30> self.rx = self.find(x)</line-30>
<line-31> self.ry = self.find(y)</line-31>
<line-32> self.sign = -self.dr[x] * self.dr[y]</line-32>
<line-33> if self.rx != self.ry:</line-33>
<line-34> if (self.par[self.rx][1]<self.par[self.ry][1]):</line-34>
<line-35> mx=self.ry</line-35>
<line-36> mn=self.rx</line-36>
<line-37> if (self.par[self.rx][1]>self.par[self.ry][1]):</line-37>
<line-38> mx=self.rx</line-38>
<line-39> mn=self.ry</line-39>
<line-40> if self.par[self.rx][1] != self.par[self.ry][1]:</line-40>
<line-41> self.par[mn][0] = mx</line-41>
<line-42> if self.zero[mn] or self.zero[mx] or self.zero[x] or self.zero[y]:</line-42>
<line-43> self.zero[mn] = self.zero[mx] = self.zero[x] = self.zero[y] = True</line-43>
<line-44> else:</line-44>
<line-45> for i in range(len(self.speed[mn])):</line-45>
<line-46> self.dr[self.speed[mn][i]] *= self.sign</line-46>
<line-47> org = self.par[self.speed[mn][i]][0]</line-47>
<line-48> if org != mx:</line-48>
<line-49> self.par[self.speed[mn][i]][0] = mx</line-49>
<line-50> self.speed[mx].append(self.speed[mn][i])</line-50>
<line-51> self.speed[mx].append(mn)</line-51>
<line-52></line-52>
<line-53> else:</line-53>
<line-54> self.par[self.ry][0] = self.rx</line-54>
<line-55> self.par[self.rx][1] += 1</line-55>
<line-56> if self.zero[self.rx] or self.zero[self.ry] or self.zero[x] or self.zero[y]:</line-56>
<line-57> self.zero[self.rx] = self.zero[self.ry] = self.zero[x] = self.zero[y] = True</line-57>
<line-58> else:</line-58>
<line-59> for i in range(len(self.speed[self.ry])):</line-59>
<line-60> self.dr[self.speed[self.ry][i]] *= self.sign</line-60>
<line-61> org = self.par[self.speed[self.ry][i]][0]</line-61>
<line-62> if org != self.rx:</line-62>
<line-63> self.par[self.speed[self.ry][i]][0] = self.rx</line-63>
<line-64> self.speed[self.rx].append(self.speed[self.ry][i])</line-64>
<line-65> self.speed[self.rx].append(self.ry)</line-65>
<line-66> else:</line-66>
<line-67> return</line-67>
<line-68></line-68>
<line-69></line-69>
<line-70>def optwo(x, y, D):</line-70>
<line-71> if (D.find(x) == D.find(y) and D.dr[x] == D.dr[y]):</line-71>
<line-72> D.zero[x] = D.zero[y] = True</line-72>
<line-73> D.union(x, y)</line-73>
<line-74></line-74>
<line-75></line-75>
<line-76>def gcd(a, b):</line-76>
<line-77> if a == 0:</line-77>
<line-78> return b</line-78>
<line-79> else:</line-79>
<line-80> return gcd(b % a, a)</line-80>
<line-81></line-81>
<line-82></line-82>
<line-83>def opthree(x, y, v, D):</line-83>
<line-84> if (D.find(x) != D.find(y)) or (D.zero[D.par[y][0]]):</line-84>
<line-85> print(0)</line-85>
<line-86> else:</line-86>
<line-87> g = gcd(v * speed[x], speed[y])</line-87>
<line-88> flag=(D.dr[x] * D.dr[y])//abs(D.dr[x] * D.dr[y])</line-88>
<line-89> print(str(flag * v * speed[x] // g) + "/" + str(speed[y] // g))</line-89>
<line-90></line-90>
<line-91></line-91>
<line-92>n, M = map(int, input().split())</line-92>
<line-93>speed = list(map(int, input().split()))</line-93>
<line-94>s = []</line-94>
<line-95>for i in range(n):</line-95>
<line-96> s.append([i, 0])</line-96>
<line-97>D = Dsu(n, s)</line-97>
<line-98>for i in range(M):</line-98>
<line-99> T = list(map(int, input().split()))</line-99>
<line-100> if (T[0] == 1):</line-100>
<line-101> speed[T[1] - 1] = T[2]</line-101>
<line-102> elif (T[0] == 2):</line-102>
<line-103> optwo(T[1] - 1, T[2] - 1, D)</line-103>
<line-105> opthree(T[1] - 1, T[2] - 1, T[3], D)</line-105>
|
{"code": "<line-2> def __init__(self, v, s):</line-2>\n<line-104> elif (T[0] == 3):</line-104>", "lines": [2, 104]}
#### 0
|
<line-1>for _ in range(eval(input())):</line-1>
<line-3> ans = 0</line-3>
<line-4> for i in s:</line-4>
<line-5> if i.isdigit():</line-5>
<line-7> print(ans) </line-7>
|
{"code": "<line-2> s = input()</line-2>\n<line-6> ans += int(i)</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> arr = list(map(int,input().split()))</line-3>
<line-4></line-4>
<line-5> if n<=62:</line-5>
<line-6> st = set()</line-6>
<line-7></line-7>
<line-8> for i in range(n):</line-8>
<line-9> curr = 0</line-9>
<line-10> for j in range(i,n):</line-10>
<line-11> curr = curr|arr[j]</line-11>
<line-12></line-12>
<line-13> st.add(curr)</line-13>
<line-14> </line-14>
<line-15> if len(st)==n*(n+1)//2:</line-15>
<line-16> print("YES")</line-16>
<line-17> else:</line-17>
<line-18> print("NO")</line-18>
<line-19> </line-19>
<line-21> print("NO")</line-21>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-20> else:</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>import sys</line-1>
<line-3>x=sys.stdin.readlines()</line-3>
<line-4>l=[]</line-4>
<line-5>for s in x:</line-5>
<line-6> s=s.replace(".","")</line-6>
<line-7> s=s.replace("'","")</line-7>
<line-8> s=s.replace(",","")</line-8>
<line-9> s=s.replace(":","")</line-9>
<line-10> s=s.replace(";","")</line-10>
<line-11> lst=[str(i) for i in s.split()]</line-11>
<line-12> for j in lst:</line-12>
<line-13> l.append(j)</line-13>
<line-14>m=[]</line-14>
<line-15>for y in l:</line-15>
<line-16> z=y.lower()</line-16>
<line-17> m.append(z)</line-17>
<line-18>n=[]</line-18>
<line-19>for k in m:</line-19>
<line-20> if(k in n):</line-20>
<line-21> continue</line-21>
<line-22> else:</line-22>
<line-23> n.append(k)</line-23>
<line-24>print(len(n))</line-24>
<line-25>h=sorted(n)</line-25>
<line-27> print(j)</line-27>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-26>for j in h:</line-26>", "lines": [2, 26]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>MOD=1000000007</line-3>
<line-4>def mod(n, m=MOD):</line-4>
<line-5> n%=m</line-5>
<line-6> while n<0: n+=m</line-6>
<line-7> return n</line-7>
<line-8></line-8>
<line-9>def power(n, p):</line-9>
<line-10> res=1</line-10>
<line-11> while p:</line-11>
<line-12> if p%2: res=mod(res*n)</line-12>
<line-13> p//=2</line-13>
<line-14> n=mod(n*n)</line-14>
<line-15> return res</line-15>
<line-16></line-16>
<line-17>while t:</line-17>
<line-18> ma=input().split()</line-18>
<line-19> x=int(ma[0])</line-19>
<line-20> y=int(ma[1])</line-20>
<line-21> s=int(ma[2])</line-21>
<line-22> ma=input().split()</line-22>
<line-23> u=int(ma[0])</line-23>
<line-24> v=int(ma[1])</line-24>
<line-25> if s%x==0 and ((s // x) & ((s // x) - 1) == 0):</line-25>
<line-26> inv=power(u, MOD-2)</line-26>
<line-27> print(mod(mod(mod(s//x)*v)*inv))</line-27>
<line-28> else:</line-28>
<line-29> inv=power(v-u, MOD-2)</line-29>
<line-31> t-=1</line-31>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-30> print(mod(mod(mod(s//y)*v)*inv))</line-30>", "lines": [2, 30]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>s = [i for i in input()]</line-3>
<line-4>count = 0</line-4>
<line-5>for i in range(1,n):</line-5>
<line-6> if s[i] == s[i-1]:</line-6>
<line-7> count += 1</line-7>
<line-8> else:</line-8>
<line-10>print(count)</line-10>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-9> continue</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4> r = [conv[i](x) for i, x in enumerate(input().strip().split(' '))]</line-4>
<line-5> return r[0] if len(r) == 1 else r</line-5>
<line-6></line-6>
<line-7>def _ra(conv) :</line-7>
<line-8> return list(map(conv, input().strip().split(' ')))</line-8>
<line-9></line-9>
<line-10>def _rl() :</line-10>
<line-11> return list(input().strip())</line-11>
<line-12></line-12>
<line-13>def _rs() :</line-13>
<line-14> return input().strip()</line-14>
<line-15></line-15>
<line-16>def _a(k, *v) :</line-16>
<line-17> return all(x == k for x in v)</line-17>
<line-18></line-18>
<line-19>def _i(conv) :</line-19>
<line-20> for line in sys.stdin :</line-20>
<line-21> yield conv(line)</line-21>
<line-22>##################################################################</line-22>
<line-23></line-23>
<line-24></line-24>
<line-25>for _ in range(_r(int)) :</line-25>
<line-26> n, sx, sy, ex, ey, bx, by = _ra(int)</line-26>
<line-27></line-27>
<line-28> if sx != ex and sy != ey : </line-28>
<line-29> print(abs(sx - ex) + abs(sy - ey))</line-29>
<line-30> else : </line-30>
<line-31> if sx == ex : </line-31>
<line-32> if sx == bx : </line-32>
<line-33> if (by > sy and by < ey) or (by < sy and by > ey) :</line-33>
<line-34> print(abs(sx - ex) + abs(sy - ey) + 2)</line-34>
<line-35> else :</line-35>
<line-36> print(abs(sx - ex) + abs(sy - ey))</line-36>
<line-37> else : </line-37>
<line-38> print(abs(sx - ex) + abs(sy - ey))</line-38>
<line-39> else :</line-39>
<line-40> if sy == by : </line-40>
<line-41> if (bx > sx and bx < ex) or (bx < sx and bx > ex) :</line-41>
<line-42> print(abs(sx - ex) + abs(sy - ey) + 2)</line-42>
<line-43> else : </line-43>
<line-44> print(abs(sx - ex) + abs(sy - ey))</line-44>
<line-46> print(abs(sx - ex) + abs(sy - ey))</line-46>
<line-47></line-47>
<line-48></line-48>
|
{"code": "<line-3>def _r(*conv) :</line-3>\n<line-45> else : </line-45>", "lines": [3, 45]}
#### 0
|
<line-1>r,c,n = map(int , input().split());coordinates = [];coordinates_1,coordinates_2 = {},{}</line-1>
<line-3> x,y = map(int , input().split())</line-3>
<line-4> coordinates.append([x,y])</line-4>
<line-5>for i in coordinates:</line-5>
<line-6> if(i[0] in coordinates_1): coordinates_1[i[0]] += 1</line-6>
<line-7> else: coordinates_1[i[0]] = 1</line-7>
<line-8> if(i[1] in coordinates_2): coordinates_2[i[1]] += 1</line-8>
<line-10>print(max(coordinates_1.values()) + max(coordinates_2.values()))</line-10>
|
{"code": "<line-2>for _ in range(n):</line-2>\n<line-9> else: coordinates_2[i[1]] = 1</line-9>", "lines": [2, 9]}
#### 0
|
<line-2>for _ in range(int(input())):</line-2>
<line-3> x, y= map(int, input().split())</line-3>
<line-4> print(max(x,y), x+y)</line-4>
|
{"code": "<line-1># cook your dish here</line-1>", "lines": [1]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.