question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1>n=int(input())</line-1>
<line-3>for i in range(0,n):</line-3>
<line-4> a,b,c=map(int,input().split())</line-4>
<line-5> n1=(2**0.5)*(a/b)</line-5>
<line-6> n2=2*(a/c)</line-6>
<line-7> if n1>n2:</line-7>
<line-8> l.append("Elevator")</line-8>
<line-9> else:</line-9>
<line-10> l.append("Stairs")</line-10>
<line-12> print(i)</line-12>
|
{"code": "<line-2>l=[]</line-2>\n<line-11>for i in l:</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-3></line-3>
<line-4>def count(n, arr):</line-4>
<line-5> loc = 0</line-5>
<line-6> glob = 0</line-6>
<line-7> for i in range(n-1):</line-7>
<line-8> if arr[i] > arr[i+1]:</line-8>
<line-9> loc += 1</line-9>
<line-10> for i in range(n-1):</line-10>
<line-11> for j in range(i+1, n):</line-11>
<line-12> if glob > loc:</line-12>
<line-13> return 0</line-13>
<line-14> if arr[i] > arr[j]:</line-14>
<line-15> glob += 1;</line-15>
<line-16> if glob == loc:</line-16>
<line-17> return 1</line-17>
<line-18> return 0</line-18>
<line-19></line-19>
<line-20>for _ in range(t):</line-20>
<line-21> n = int(stdin.readline())</line-21>
<line-22> arr = list(map(int, stdin.readline().split()))</line-22>
<line-23> result = count(n, arr)</line-23>
<line-24> if result:</line-24>
<line-25> print("YES")</line-25>
<line-27> print("NO")</line-27>
|
{"code": "<line-2>t = int(stdin.readline())</line-2>\n<line-26> else:</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3></line-3>
<line-4># for i in range(n):</line-4>
<line-5># s = input()</line-5>
<line-6># subString1, subString2 = s[:4], s[4:]</line-6>
<line-7># rev = subString2[::-1]</line-7>
<line-8># print( 'uniform' if(subString1 == rev) else 'non-uniform')</line-8>
<line-9> </line-9>
<line-10>for i in range(n):</line-10>
<line-11> count = 0</line-11>
<line-12> s = input()</line-12>
<line-13> for i in range(1, len(s)):</line-13>
<line-14> if(s[i-1] != s[i]):</line-14>
<line-15> count += 1 </line-15>
<line-16> </line-16>
<line-17> if(s[0] != s[-1]): </line-17>
<line-19> print("uniform" if(count <=2 ) else "non-uniform")</line-19>
|
{"code": "<line-2># this code only for 8 bits string and it isn't possible to more than 8 bits of string </line-2>\n<line-18> count += 1 </line-18>", "lines": [2, 18]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>i=0</line-3>
<line-4>a=0</line-4>
<line-5>d=dict()</line-5>
<line-6>while i<t:</line-6>
<line-7> l=input().split()</line-7>
<line-8> d[int(l[0])]=int(l[0])+int(l[1])</line-8>
<line-9> i+=1</line-9>
<line-10>for k in d:</line-10>
<line-11> if d[k] in d:</line-11>
<line-12> if d[d[k]]==k:</line-12>
<line-13> a=1</line-13>
<line-14> break</line-14>
<line-15>if a==1:</line-15>
<line-16> print("YES")</line-16>
<line-18> print("NO")</line-18>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-17>else:</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>n,k,m = map(int,input().split())</line-1>
<line-3>fsum = [ar[0]]</line-3>
<line-4>for i in range(1,n):</line-4>
<line-5> fsum.append(fsum[i-1]+ar[i])</line-5>
<line-6>i = k</line-6>
<line-7>#print(fsum)</line-7>
<line-8>c = 0</line-8>
<line-9>while i <= n:</line-9>
<line-10> if i == k:</line-10>
<line-11> s = fsum[i-1]</line-11>
<line-12> else:</line-12>
<line-13> s = fsum[i-1]-fsum[i-k-1]</line-13>
<line-14> if s == 0:</line-14>
<line-15> c = -1</line-15>
<line-16> break</line-16>
<line-17> if s < m:</line-17>
<line-18> c += 1</line-18>
<line-19> if i<n:</line-19>
<line-20> for j in range(i,i-k-1,-1):</line-20>
<line-21> if ar[j-1] >0:</line-21>
<line-22> j += k-1</line-22>
<line-23> i = j</line-23>
<line-24> break</line-24>
<line-25> if i<n:</line-25>
<line-26> for j in range(i,i-k-1,-1):</line-26>
<line-27> if ar[j-1] >0:</line-27>
<line-28> j += k-1</line-28>
<line-29> i = j</line-29>
<line-30> break</line-30>
<line-31> i += 1</line-31>
<line-32>i = k</line-32>
<line-33>while i <= n:</line-33>
<line-34> if i==k:</line-34>
<line-35> s = fsum[i-1]</line-35>
<line-36> else:</line-36>
<line-37> s = fsum[i-1] - fsum[i-k-1]</line-37>
<line-38> if s == 0 :</line-38>
<line-39> c = -1</line-39>
<line-40> break</line-40>
<line-42>print(c)</line-42>
|
{"code": "<line-2>ar = list(map(int,input().split()))</line-2>\n<line-41> i += 1</line-41>", "lines": [2, 41]}
#### 0
|
<line-1>T = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> arr = list(map(int, input().split()))</line-4>
<line-5> a = [0 for _ in range(max(arr)+1)]</line-5>
<line-6> star_val = []</line-6>
<line-7> for i in range(len(arr)):</line-7>
<line-8> j = 1</line-8>
<line-9> val = 0</line-9>
<line-10> while j*arr[i] <= len(a):</line-10>
<line-11> val += a[j*arr[i]-1]</line-11>
<line-12> j += 1</line-12>
<line-13> star_val.append(val)</line-13>
<line-15> print(max(star_val))</line-15>
|
{"code": "<line-2>for _ in range(T):</line-2>\n<line-14> a[arr[i]-1] += 1</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>VQ = "UAMmSs"</line-1>
<line-3>a = list(map(int, input().split()))</line-3>
<line-4>for _ in range(int(input())):</line-4>
<line-5> q, x, y = input().split()</line-5>
<line-6> if q not in VQ:</line-6>
<line-7> print("!!!")</line-7>
<line-8> continue</line-8>
<line-9> if q == "U":</line-9>
<line-10> a[int(x) - 1] = int(y)</line-10>
<line-11> continue</line-11>
<line-12> l = int(x) - 1</line-12>
<line-13> r = int(y)</line-13>
<line-14> if q == "A":</line-14>
<line-15> print(sum(a[l:r]))</line-15>
<line-16> continue</line-16>
<line-17> if q == "M":</line-17>
<line-18> print(max(a[l:r]))</line-18>
<line-19> continue</line-19>
<line-20> if q == "m":</line-20>
<line-21> print(min(a[l:r]))</line-21>
<line-22> continue</line-22>
<line-23> s = sorted(set(a[l:r]))</line-23>
<line-24> if len(s) < 2:</line-24>
<line-25> print("NA")</line-25>
<line-27> print(s[1] if q == "s" else s[-2])</line-27>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-26> else:</line-26>", "lines": [2, 26]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(x):</line-3>
<line-4> s=int(input())</line-4>
<line-5> fact=1</line-5>
<line-6> for i in range(1,s+1):</line-6>
<line-8> print(fact)</line-8>
|
{"code": "<line-2>x=int(input())</line-2>\n<line-7> fact=fact*i</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>import math</line-1>
<line-3> if num1>num2:</line-3>
<line-4> a=num1</line-4>
<line-5> b=num2</line-5>
<line-6> else:</line-6>
<line-7> a=num2</line-7>
<line-8> b=num1</line-8>
<line-9> rem=a%b</line-9>
<line-10> while(rem!=0):</line-10>
<line-11> a=b</line-11>
<line-12> b=rem</line-12>
<line-13> rem=a%b</line-13>
<line-14> gcd=b</line-14>
<line-15> return (int((num1*num2)/gcd))</line-15>
<line-16> </line-16>
<line-17>for _ in range (int(input())):</line-17>
<line-18> hours=int(input())*24</line-18>
<line-19> x,y,z=list(map(int,input().split()))</line-19>
<line-20> lcm=x</line-20>
<line-21> lcm=fun(x,y)</line-21>
<line-23> print(int(hours//lcm))</line-23>
<line-24> </line-24>
<line-25> </line-25>
<line-26> </line-26>
|
{"code": "<line-2>def fun(num1,num2):</line-2>\n<line-22> lcm=fun(lcm,z)</line-22>", "lines": [2, 22]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for j in range(tc):</line-3>
<line-4> ip=list(map(int,input().rstrip().split()))</line-4>
<line-5> x=ip[0]</line-5>
<line-6> y=ip[1]</line-6>
<line-7> n=ip[2]</line-7>
<line-8> cnt=0</line-8>
<line-9> if(x==y):</line-9>
<line-10> print('0')</line-10>
<line-11> continue</line-11>
<line-12> ln=bin(x).replace("0b", "") </line-12>
<line-13> rn=bin(y).replace("0b", "") </line-13>
<line-14> ll=len(ln)</line-14>
<line-15> rl=len(rn)</line-15>
<line-16> #print(ln)</line-16>
<line-17> #print(rn)</line-17>
<line-18> if(ll==len(rn)):</line-18>
<line-19> for i in range(ll):</line-19>
<line-20> </line-20>
<line-21> if(ln[i]!=rn[i]):</line-21>
<line-22> ln=ln[i:]</line-22>
<line-23> rn=rn[i:]</line-23>
<line-24> break</line-24>
<line-25> #print(ln)</line-25>
<line-26> if(ln[0]=='0'):</line-26>
<line-27> ln=ln[1:]</line-27>
<line-28> ll-=1</line-28>
<line-29> #print(rn)</line-29>
<line-30> if(rn[0]=='0'):</line-30>
<line-31> rn=rn[1:]</line-31>
<line-32> rl-=1</line-32>
<line-33> ll=len(ln)</line-33>
<line-34> rl=len(rn)</line-34>
<line-35> if(ll>rl):</line-35>
<line-36> lb=ll </line-36>
<line-37> else:</line-37>
<line-38> lb=rl </line-38>
<line-39> pl=2**lb </line-39>
<line-40> hpl=pl//2</line-40>
<line-41> amn=((n+1)//pl)*hpl </line-41>
<line-42> rm=(n+1)%pl </line-42>
<line-43> if((rm*2)<=pl):</line-43>
<line-44> amn+=rm</line-44>
<line-45> else:</line-45>
<line-46> amn+=hpl </line-46>
<line-47> #print("amn = ",amn)</line-47>
<line-48> aln=(n+1)-amn</line-48>
<line-49> #print("aln = ",aln)</line-49>
<line-50> if(x<y):</line-50>
<line-51> print(amn)</line-51>
<line-53> print(aln)</line-53>
|
{"code": "<line-2>tc=int(input())</line-2>\n<line-52> else:</line-52>", "lines": [2, 52]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n,m=list(map(int,input().split()))</line-3>
<line-4> l=list(map(int,input().split()))</line-4>
<line-5> k=[]</line-5>
<line-6> for i in range(m):</line-6>
<line-7> a,b=list(map(int,input().split()))</line-7>
<line-8> k.append([a,b])</line-8>
<line-9> k.sort()</line-9>
<line-10> c=[]</line-10>
<line-11> flag=1</line-11>
<line-12> x=k[0][0]</line-12>
<line-13> y=k[0][1]</line-13>
<line-14> </line-14>
<line-15> for i in k[1:]:</line-15>
<line-16> if i[0]<=y:</line-16>
<line-17> y=max(y,i[1])</line-17>
<line-18> else:</line-18>
<line-19> c.append([x-1,y-1])</line-19>
<line-20> x=i[0]</line-20>
<line-21> y=i[1]</line-21>
<line-22> c.append([x-1,y-1])</line-22>
<line-23> m=[]</line-23>
<line-24> j=0</line-24>
<line-25> </line-25>
<line-26> for i in c:</line-26>
<line-27> while j<i[0]:</line-27>
<line-28> m.append(l[j])</line-28>
<line-29> j+=1</line-29>
<line-30> x=l[i[0]:i[1]+1]</line-30>
<line-31> m+=sorted(x)</line-31>
<line-32> j=i[1]+1</line-32>
<line-33> </line-33>
<line-34> while j<n:</line-34>
<line-35> m.append(l[j])</line-35>
<line-36> j+=1</line-36>
<line-37> </line-37>
<line-38> if m==sorted(l):</line-38>
<line-39> print('Possible')</line-39>
<line-41> print('Impossible')</line-41>
<line-42> </line-42>
<line-43> </line-43>
<line-44> </line-44>
<line-45> </line-45>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-40> else:</line-40>", "lines": [2, 40]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> sumi = 0</line-3>
<line-4> for j in range(k):</line-4>
<line-5> sumi += arr[j]</line-5>
<line-6> maxi = sumi</line-6>
<line-7> for i in range(k,len(arr)):</line-7>
<line-8> sumi -= arr[i - k]</line-8>
<line-9> sumi += arr[i]</line-9>
<line-10> maxi = max(maxi,sumi)</line-10>
<line-11> return maxi</line-11>
<line-12>for _ in range(int(input())):</line-12>
<line-13> n, k = map(int,input().split())</line-13>
<line-15> print(func(arr,k))</line-15>
|
{"code": "<line-2>def func(arr, k):</line-2>\n<line-14> arr = [int(x) for x in input().split()]</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>import math</line-1>
<line-3> </line-3>
<line-4>def phi(n):</line-4>
<line-5> res = n</line-5>
<line-6> i = 2</line-6>
<line-7> while i*i<=n:</line-7>
<line-8> if n%i==0:</line-8>
<line-9> res/=i</line-9>
<line-10> res*=(i-1)</line-10>
<line-11> </line-11>
<line-12> while n%i==0:</line-12>
<line-13> n/=i</line-13>
<line-14> i+=1</line-14>
<line-15> </line-15>
<line-16> if n>1:</line-16>
<line-17> res/=n</line-17>
<line-18> res*=(n-1)</line-18>
<line-19> </line-19>
<line-20> return int(res)</line-20>
<line-21> </line-21>
<line-22>while t:</line-22>
<line-23> a,m = list(map(int,input().split()))</line-23>
<line-24> g = math.gcd(a,m)</line-24>
<line-26> t-=1</line-26>
|
{"code": "<line-2>t = int(input())</line-2>\n<line-25>\tprint(phi(m//g))</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>for T in range(int (eval(input()))):</line-1>
<line-3> A=list(map(int,input().split()))</line-3>
<line-5> print(min(P,D))</line-5>
|
{"code": "<line-2> N,K,D=list(map(int,input().split()))</line-2>\n<line-4> P=sum(A)//K </line-4>", "lines": [2, 4]}
#### 0
|
<line-1>for t in range(int(input())):</line-1>
<line-3> l = []</line-3>
<line-4> m = []</line-4>
<line-5> x = list(map(int,input().split()))</line-5>
<line-6> l.append(x)</line-6>
<line-7> m.append(list(x))</line-7>
<line-8> for i in range(1,n):</line-8>
<line-9> x = list(map(int,input().split()))</line-9>
<line-10> l.append(x)</line-10>
<line-11> temp = []</line-11>
<line-12> for i in range(4):</line-12>
<line-13> temp.append (x[i]+min(m[-1][:i]+m[-1][i+1:]))</line-13>
<line-15> print(min(m[-1]))</line-15>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-14> m.append(temp)</line-14>", "lines": [2, 14]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> for _ in range(int(input())):</line-3>
<line-4> N, k = [int(x) for x in input().split()]</line-4>
<line-5> Powers = [k ** int(x) for x in input().split()]</line-5>
<line-6> </line-6>
<line-7> s1, s2 = 0, sum(Powers)</line-7>
<line-8> </line-8>
<line-9> ans = (0, None)</line-9>
<line-10> </line-10>
<line-11> i = 0</line-11>
<line-12> while i < N - 1:</line-12>
<line-13> s1 += Powers[i]</line-13>
<line-14> s2 -= Powers[i]</line-14>
<line-15> </line-15>
<line-16> z = s1 * s2 </line-16>
<line-17> if z > ans[0]:</line-17>
<line-18> ans = (z, i)</line-18>
<line-19> # print(z)</line-19>
<line-20> </line-20>
<line-21> i += 1</line-21>
<line-22> </line-22>
<line-24></line-24>
<line-25>main()</line-25>
|
{"code": "<line-2>def main():</line-2>\n<line-23> print(ans[1] + 1)</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> x=(th-tc)</line-3>
<line-4> if x%3!=0:</line-4>
<line-5> print("Yes")</line-5>
<line-6> else:</line-6>
<line-7> if (x//3)<=m:</line-7>
<line-8> print("No")</line-8>
<line-10> print("Yes")</line-10>
|
{"code": "<line-2> m,tc,th=map(int,input().split())</line-2>\n<line-9> else:</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>pref = []</line-1>
<line-2></line-2>
<line-4> b = bin(i)[2:]</line-4>
<line-5> if not any(b[j] == b[j+1] == '1' for j in range(len(b) - 1)):</line-5>
<line-6> pref.append(i)</line-6>
<line-7> else:</line-7>
<line-8> pref.append(pref[-1])</line-8>
<line-9></line-9>
<line-11> print(pref[int(input())])</line-11>
|
{"code": "<line-3>for i in range(10 ** 5 + 10):</line-3>\n<line-10>for i in range(int(input())):</line-10>", "lines": [3, 10]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> a,n,m = map(int,input().split(' '))</line-3>
<line-4> s = len(str(a))</line-4>
<line-5> #print(s)</line-5>
<line-6> c = 10**s - 1</line-6>
<line-7> w = c*m</line-7>
<line-8> b = pow(10,n*s,w)-1</line-8>
<line-9> d = b//c</line-9>
<line-11> print(ans%m) </line-11>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-10> ans = (d%m)*(a%m)</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>ar = []</line-1>
<line-3>for i in range(1, 31):</line-3>
<line-4> ar.append(ar[i-1]*(4*i-2)/(i+1))</line-4>
<line-5>t = int(input())</line-5>
<line-6>while(t>0):</line-6>
<line-7> n = int(input())</line-7>
<line-8> if(n==0):</line-8>
<line-9> print(0)</line-9>
<line-10> else:</line-10>
<line-12> t=t-1</line-12>
|
{"code": "<line-2>ar.append(1)</line-2>\n<line-11> print(ar[n]*2)</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> x,y=0,0</line-3>
<line-4> n,m=list(map(int,input().split()))</line-4>
<line-5> l=list(map(int,input().split()))</line-5>
<line-6> if(max(l)>m):</line-6>
<line-7> print(-1)</line-7>
<line-8> else:</line-8>
<line-9> for i in range(len(l)):</line-9>
<line-10> y+=l[i]</line-10>
<line-11> if(y>m):</line-11>
<line-12> y=l[i]</line-12>
<line-13> x+=1</line-13>
<line-14> if(y>0):</line-14>
<line-16> print(x)</line-16>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-15> x+=1</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>for t in range(eval(input())):</line-1>
<line-2> </line-2>
<line-4> </line-4>
<line-5> a = [ [] for i in range(n+1) ]</line-5>
<line-6> </line-6>
<line-7> for i in range(n-1):</line-7>
<line-8> x,y = list(map( int, input().split() ))</line-8>
<line-9> a[x].append(y)</line-9>
<line-10> a[y].append(x)</line-10>
<line-11> </line-11>
<line-12> vis = [0] * (n+1)</line-12>
<line-13> vis[1] = 1</line-13>
<line-14></line-14>
<line-15> ans = [1]</line-15>
<line-16></line-16>
<line-17> t1 = [1]</line-17>
<line-18> t2 = []</line-18>
<line-19> </line-19>
<line-20> while len(t1) > 0 :</line-20>
<line-21> for u in t1:</line-21>
<line-22> for x in a[u]:</line-22>
<line-23> if vis[x] == 0 :</line-23>
<line-24> vis[x] = 1</line-24>
<line-25> t2.append(x)</line-25>
<line-26> if len(t2) > 1 :</line-26>
<line-27> ans.append(t2[0])</line-27>
<line-28> ans.append(t2[-1])</line-28>
<line-29> if len(t2) == 1 :</line-29>
<line-30> ans.append(t2[0])</line-30>
<line-31> </line-31>
<line-32> t1 = t2</line-32>
<line-33> t2 = []</line-33>
<line-34> </line-34>
<line-35> for x in sorted(ans):</line-35>
<line-37> </line-37>
<line-38> print('')</line-38>
|
{"code": "<line-3> n = eval(input())</line-3>\n<line-36> print(x, end=' ')</line-36>", "lines": [3, 36]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n,k = list(map(int,input().split()))</line-3>
<line-4> mod = 10**9+7</line-4>
<line-5> s=0</line-5>
<line-6> for i in range(1,n+1):</line-6>
<line-7> p = pow(k,(2*i)-1,mod)</line-7>
<line-8> # print(p)</line-8>
<line-9> s=(s+p)%mod</line-9>
<line-10> # print(k)</line-10>
<line-12> print(s)</line-12>
<line-13></line-13>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-11> k = (p*k)%mod</line-11>", "lines": [2, 11]}
#### 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> a = list(map(int, input().split()))</line-6>
<line-7> gcd = max(a[0], a[-1])</line-7>
<line-8> </line-8>
<line-10>except EOFError:pass</line-10>
|
{"code": "<line-2>try:</line-2>\n<line-9> print(gcd)</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>def maxval(arr):</line-1>
<line-3> sn = [float('-inf')]*len(arr)</line-3>
<line-4> tn = [float('-inf')]*(len(arr)-1)</line-4>
<line-5> fon = [float('-inf')]*(len(arr)-2)</line-5>
<line-6> for i in reversed(list(range(len(arr)))):</line-6>
<line-7> fn[i] = max(fn[i + 1], arr[i])</line-7>
<line-8> for i in reversed(list(range(len(arr) - 1))):</line-8>
<line-9> sn[i] = max(sn[i + 1], fn[i + 1] - arr[i])</line-9>
<line-10></line-10>
<line-11> for i in reversed(list(range(len(arr) - 2))):</line-11>
<line-12> tn[i] = max(tn[i + 1], sn[i + 1] + arr[i])</line-12>
<line-13></line-13>
<line-14> for i in reversed(list(range(len(arr) - 3))):</line-14>
<line-15> fon[i] = max(fon[i + 1], tn[i + 1] - arr[i])</line-15>
<line-16> return fon[0]</line-16>
<line-17>n = int(input())</line-17>
<line-19>print(maxval(arr))</line-19>
<line-20> </line-20>
|
{"code": "<line-2> fn = [float('-inf')]*(len(arr)+1)</line-2>\n<line-18>arr = list(map(int,input().split()))</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>def convertToParitys(s):</line-1>
<line-3> This converts the string s to an int, which is a bitMap of the parity of each letter</line-3>
<line-4> odd ? = first bit set</line-4>
<line-5> odd a = second bit set</line-5>
<line-6> odd b = third bit set </line-6>
<line-7> etc</line-7>
<line-8> """</line-8>
<line-9> keys = '?abcdefghijklmnopqrstuvwxyz'</line-9>
<line-10> paritys = {c:0 for c in keys}</line-10>
<line-11> for c in s:</line-11>
<line-12> paritys[c] += 1</line-12>
<line-13> for c, v in paritys.items():</line-13>
<line-14> paritys[c] = v%2</line-14>
<line-15> </line-15>
<line-16> out = 0</line-16>
<line-17> bitValue = 1</line-17>
<line-18> for c in keys:</line-18>
<line-19> if paritys[c]:</line-19>
<line-20> out += bitValue</line-20>
<line-21> bitValue *= 2</line-21>
<line-22> return out</line-22>
<line-23></line-23>
<line-24>def getSolutionBitMaps(s):</line-24>
<line-25> """</line-25>
<line-26> these are the 27 valid bitmaps that a substring can have</line-26>
<line-27> even ? and the parities the same</line-27>
<line-28> 26 cases of odd ? and one bit different in the parity compared to s</line-28>
<line-29> """</line-29>
<line-30> out = []</line-30>
<line-31> sP = convertToParitys(s)</line-31>
<line-32> if sP%2:</line-32>
<line-33> sP -= 1 # to remove the '?' parity</line-33>
<line-34> #even case - </line-34>
<line-35> out.append(sP)</line-35>
<line-36> #odd cases - need to xor sP with 1 + 2**n n = 1 to 26 inc to flip ? bit and each of the others</line-36>
<line-37> for n in range(1,27):</line-37>
<line-38> out.append(sP^(1+2**n))</line-38>
<line-39> return out</line-39>
<line-40></line-40>
<line-41>def getLeadingSubStringBitMapCounts(s):</line-41>
<line-42> """</line-42>
<line-43> This calculates the bit map of each of the len(s) substrings starting with the first character and stores as a dictionary.</line-43>
<line-44> Getting TLE calculating each individually, so calculating with a single pass</line-44>
<line-45> """</line-45>
<line-46> out = {}</line-46>
<line-47> bM = 0</line-47>
<line-48> keys = '?abcdefghijklmnopqrstuvwxyz'</line-48>
<line-49> paritys = {c:0 for c in keys}</line-49>
<line-50> values = {c:2**i for i,c in enumerate(keys)}</line-50>
<line-51> out[bM] = out.setdefault(bM, 0) + 1 #add the null substring</line-51>
<line-52> bMis = []</line-52>
<line-53> i = 0</line-53>
<line-54> bMis = [0]</line-54>
<line-55> for c in s:</line-55>
<line-56> i += 1</line-56>
<line-57> if paritys[c]:</line-57>
<line-58> paritys[c] = 0</line-58>
<line-59> bM -= values[c]</line-59>
<line-60> else:</line-60>
<line-61> paritys[c] = 1</line-61>
<line-62> bM += values[c]</line-62>
<line-63> out[bM] = out.setdefault(bM, 0) + 1</line-63>
<line-64> bMis.append(bM)</line-64>
<line-65> return out,bMis</line-65>
<line-66></line-66>
<line-67>def solve(s):</line-67>
<line-68> out = 0</line-68>
<line-69> bMjCounts,bMis = getLeadingSubStringBitMapCounts(s)</line-69>
<line-70> #print('bMjCounts')</line-70>
<line-71> #print(bMjCounts)</line-71>
<line-72> solutions = getSolutionBitMaps(s)</line-72>
<line-73> #print('solutions')</line-73>
<line-74> #print(solutions) </line-74>
<line-75> for bMi in bMis:</line-75>
<line-76> for bMs in solutions:</line-76>
<line-77> if bMs^bMi in bMjCounts:</line-77>
<line-78> out += bMjCounts[bMs^bMi]</line-78>
<line-79> #print(i,bMi,bMs,bMs^bMi,bMjCounts[bMs^bMi])</line-79>
<line-80> if 0 in solutions:</line-80>
<line-81> out -= len(s) #remove all null substrings</line-81>
<line-82> out //= 2 # since j may be less that i each substring is counted twice</line-82>
<line-83> return out</line-83>
<line-84> </line-84>
<line-85>T = int(input())</line-85>
<line-86>for tc in range(T):</line-86>
<line-88> print(solve(s))</line-88>
<line-89> </line-89>
|
{"code": "<line-2> \"\"\"</line-2>\n<line-87> s = input()</line-87>", "lines": [2, 87]}
#### 0
|
<line-1>def gcd(a,b):</line-1>
<line-3> return gcd(b,a%b)</line-3>
<line-4></line-4>
<line-5>for _ in range(int(input())):</line-5>
<line-6> n = int(input())</line-6>
<line-7> arr = list(map(int,input().split()))</line-7>
<line-8> value = arr[0]</line-8>
<line-9> if n!=1:</line-9>
<line-10> for i in arr[1:]:</line-10>
<line-11> value = value*i//gcd(value, i)</line-11>
<line-12> if value%2==0:</line-12>
<line-13> print("NO")</line-13>
<line-15> print("YES")</line-15>
|
{"code": "<line-2> if b==0: return a</line-2>\n<line-14> else:</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3>while i<t:</line-3>
<line-4> n=int(input())</line-4>
<line-5> A=[]</line-5>
<line-6> A=input().split()</line-6>
<line-7> m=int(input())</line-7>
<line-8> B=[]</line-8>
<line-9> B=input().split()</line-9>
<line-10> j=0</line-10>
<line-11> a=-1</line-11>
<line-12> while j<m:</line-12>
<line-13> c=1</line-13>
<line-14> if B[j] in A:</line-14>
<line-15> b=A.index(B[j])</line-15>
<line-16> A.remove(B[j])</line-16>
<line-17> if b>=a:</line-17>
<line-18> a=b</line-18>
<line-19> c=1</line-19>
<line-20> else:</line-20>
<line-21> c=0</line-21>
<line-22> break</line-22>
<line-23> else:</line-23>
<line-24> c=0</line-24>
<line-25> break</line-25>
<line-26> j+=1</line-26>
<line-27> if c==1:</line-27>
<line-28> print("Yes")</line-28>
<line-29> else:</line-29>
<line-31> i+=1</line-31>
|
{"code": "<line-2>i=0</line-2>\n<line-30> print(\"No\")</line-30>", "lines": [2, 30]}
#### 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> a=[int(i) for i in input().split()]</line-5>
<line-6> div=sum(a)/n</line-6>
<line-7> div=math.ceil(div)</line-7>
<line-8> count=div*n-sum(a)</line-8>
<line-9> for i in a:</line-9>
<line-10> if i>div:</line-10>
<line-12> print(count)</line-12>
|
{"code": "<line-2>import math</line-2>\n<line-11> count+=i-div</line-11>", "lines": [2, 11]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>start_w = 27</line-3>
<line-4>w_dict = {}</line-4>
<line-5>words = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]</line-5>
<line-6>for word in words:</line-6>
<line-7> w_dict[word] = start_w</line-7>
<line-8> start_w = start_w - 1</line-8>
<line-9></line-9>
<line-10>total_wt = 0</line-10>
<line-11>for c in s:</line-11>
<line-13></line-13>
<line-14>print(total_wt)</line-14>
|
{"code": "<line-2>s = input().strip()</line-2>\n<line-12> total_wt = total_wt + w_dict[c]</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>import math</line-1>
<line-3>a=[True]*n</line-3>
<line-4>l=[]</line-4>
<line-5>for i in range(2,33):</line-5>
<line-6> if(a[i]):</line-6>
<line-7> for j in range(i*i,n,i):</line-7>
<line-8> a[j]=False</line-8>
<line-9>for pr in range(2,1001):</line-9>
<line-10> if(a[pr]):</line-10>
<line-11> l.append(pr)</line-11>
<line-12>t=int(input())</line-12>
<line-13>for j in range(t):</line-13>
<line-14> n,m=list(map(int,input().strip().split()))</line-14>
<line-15> arr=[int(num) for num in input().strip().split()]</line-15>
<line-16> Matrix =[]</line-16>
<line-17> index=[0]*100000</line-17>
<line-18> factors=[0]*100000</line-18>
<line-19> ans=''</line-19>
<line-20> for r in range(len(arr)):</line-20>
<line-21> li=[]</line-21>
<line-22> for val in l:</line-22>
<line-23> while((arr[r]%val)==0):</line-23>
<line-24> arr[r]=arr[r]/val</line-24>
<line-25> li.append(val)</line-25>
<line-26> factors[r]+=1</line-26>
<line-27> if(arr[r]!=1):</line-27>
<line-28> li.append(arr[r])</line-28>
<line-29> arr[r]=1</line-29>
<line-30> factors[r]+=1</line-30>
<line-31> Matrix.append(li)</line-31>
<line-32> for k in range(m):</line-32>
<line-33> opr=[int(o) for o in input().strip().split()]</line-33>
<line-34> L=opr[1]</line-34>
<line-35> R=opr[2]</line-35>
<line-36> if(opr[0]==0):</line-36>
<line-37> for ran in range(L-1,R):</line-37>
<line-38> if(index[ran]<factors[ran]):</line-38>
<line-39> index[ran]+=1</line-39>
<line-40> else:</line-40>
<line-41> result=1</line-41>
<line-42> for ran in range(L-1,R):</line-42>
<line-43> if(index[ran]<factors[ran]):</line-43>
<line-44> result=max(result,Matrix[ran][index[ran]])</line-44>
<line-45> ans+=str(result)</line-45>
<line-47> print(ans[:-1])</line-47>
|
{"code": "<line-2>n=1001</line-2>\n<line-46> ans+=' '</line-46>", "lines": [2, 46]}
#### 0
|
<line-2> print(2*(sum(list(map(int, input().split())))-1))</line-2>
|
{"code": "<line-1>for i in range(int(input())):</line-1>", "lines": [1]}
#### 0
|
<line-1>import sys</line-1>
<line-3>inp = lambda: list(map(int,sys.stdin.readline().rstrip("\r\n").split()))</line-3>
<line-4>#_______________________________________________________________________________ _______________________</line-4>
<line-5># from math import *</line-5>
<line-6># from bisect import *</line-6>
<line-7># from heapq import *</line-7>
<line-8># from collections import defaultdict as dd</line-8>
<line-9># from collections import OrderedDict as odict</line-9>
<line-10># from collections import Counter as cc</line-10>
<line-11># from collections import deque</line-11>
<line-12># sys.setrecursionlimit(2*(10**5)+100) this is must for dfs</line-12>
<line-13># mod = 10**9+7; md = 998244353</line-13>
<line-14># ______________________________________________________________________________ ________________________</line-14>
<line-15># segment tree for range minimum query</line-15>
<line-16># sys.setrecursionlimit(10**5)</line-16>
<line-17># n = int(input())</line-17>
<line-18># a = list(map(int,input().split()))</line-18>
<line-19># st = [float('inf') for i in range(4*len(a))]</line-19>
<line-20># def build(a,ind,start,end):</line-20>
<line-21># if start == end:</line-21>
<line-22># st[ind] = a[start]</line-22>
<line-23># else:</line-23>
<line-24># mid = (start+end)//2</line-24>
<line-25># build(a,2*ind+1,start,mid)</line-25>
<line-26># build(a,2*ind+2,mid+1,end)</line-26>
<line-27># st[ind] = min(st[2*ind+1],st[2*ind+2])</line-27>
<line-28># build(a,0,0,n-1)</line-28>
<line-29># def query(ind,l,r,start,end):</line-29>
<line-30># if start>r or end<l:</line-30>
<line-31># return float('inf')</line-31>
<line-32># if l<=start<=end<=r:</line-32>
<line-33># return st[ind]</line-33>
<line-34># mid = (start+end)//2</line-34>
<line-35># return min(query(2*ind+1,l,r,start,mid),query(2*ind+2,l,r,mid+1,end))</line-35>
<line-36># ______________________________________________________________________________ ________________________</line-36>
<line-37># Checking prime in O(root(N))</line-37>
<line-38># def isprime(n):</line-38>
<line-39># if (n % 2 == 0 and n > 2) or n == 1: return 0</line-39>
<line-40># else:</line-40>
<line-41># s = int(n**(0.5)) + 1</line-41>
<line-42># for i in range(3, s, 2):</line-42>
<line-43># if n % i == 0:</line-43>
<line-44># return 0</line-44>
<line-45># return 1</line-45>
<line-46># def lcm(a,b):</line-46>
<line-47># return (a*b)//gcd(a,b)</line-47>
<line-48># ______________________________________________________________________________ ________________________</line-48>
<line-49># nCr under mod</line-49>
<line-50># def C(n,r,mod):</line-50>
<line-51># if r>n:</line-51>
<line-52># return 0</line-52>
<line-53># num = den = 1</line-53>
<line-54># for i in range(r):</line-54>
<line-55># num = (num*(n-i))%mod</line-55>
<line-56># den = (den*(i+1))%mod</line-56>
<line-57># return (num*pow(den,mod-2,mod))%mod</line-57>
<line-58># M = 10**5 +10</line-58>
<line-59># ______________________________________________________________________________ ________________________</line-59>
<line-60># For smallest prime factor of a number</line-60>
<line-61># M = 1000010</line-61>
<line-62># pfc = [i for i in range(M)]</line-62>
<line-63># def pfcs(M):</line-63>
<line-64># for i in range(2,M):</line-64>
<line-65># if pfc[i]==i:</line-65>
<line-66># for j in range(i+i,M,i):</line-66>
<line-67># if pfc[j]==j:</line-67>
<line-68># pfc[j] = i</line-68>
<line-69># return</line-69>
<line-70># pfcs(M)</line-70>
<line-71># ______________________________________________________________________________ ________________________</line-71>
<line-72>tc = 1</line-72>
<line-73>tc, = inp()</line-73>
<line-74>a = [0,1]</line-74>
<line-75>for i in range(100000):</line-75>
<line-76> a.append(a[-1]+a[-2])</line-76>
<line-77>for _ in range(tc):</line-77>
<line-78> n, = inp()</line-78>
<line-79> start = 0</line-79>
<line-80> for i in range(n):</line-80>
<line-81> print(*a[start:start+i+1])</line-81>
<line-83> start +=i+1</line-83>
|
{"code": "<line-2>input = lambda: sys.stdin.readline().rstrip(\"\\r\\n\")</line-2>\n<line-82> print()</line-82>", "lines": [2, 82]}
#### 0
|
<line-1>import re,sys</line-1>
<line-3> if juices == [] or distances == []:</line-3>
<line-4> return -1;</line-4>
<line-5> total_juice_consumed = 0</line-5>
<line-6> juice_consumed = 0</line-6>
<line-7> start=0</line-7>
<line-8> for i in range(0,len(juices)):</line-8>
<line-9> diff = juices[i] - distances[i]</line-9>
<line-10> if juice_consumed >= 0:</line-10>
<line-11> juice_consumed += diff</line-11>
<line-12> else:</line-12>
<line-13> juice_consumed = diff</line-13>
<line-14> start = i</line-14>
<line-15> total_juice_consumed += diff</line-15>
<line-16> return start</line-16>
<line-17></line-17>
<line-18>juices = []</line-18>
<line-19>distances = []</line-19>
<line-20>numLines = int(input())</line-20>
<line-21>for each in range(0,numLines):</line-21>
<line-22> line = input()</line-22>
<line-23> result = [int(x) for x in re.findall('\d+',line)]</line-23>
<line-24> if len(result) == 2:</line-24>
<line-25> juices.append(result[0])</line-25>
<line-26> distances.append(result[1])</line-26>
<line-27></line-27>
<line-29>return</line-29>
|
{"code": "<line-2>def isCirlePossible(juices,distances):</line-2>\n<line-28>print(isCirlePossible(juices,distances))</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> s = input()</line-3>
<line-4> pref = [0]*len(s)</line-4>
<line-5> if s[0]=="1":</line-5>
<line-6> pref[0]+=1</line-6>
<line-7> for i in range(1,len(s)):</line-7>
<line-8> if s[i]=="1":</line-8>
<line-9> pref[i]+=1</line-9>
<line-10> pref[i]=pref[i]+pref[i-1]</line-10>
<line-11> k=1</line-11>
<line-12> cnt=0</line-12>
<line-13> while (k+k*k)<=len(s):</line-13>
<line-14> r = k+k*k</line-14>
<line-15> i=r-1</line-15>
<line-16> while i<len(s):</line-16>
<line-17> if (i-r)>=0:</line-17>
<line-18> if pref[i]-pref[i-r]==k:</line-18>
<line-19> cnt+=1</line-19>
<line-20> i+=1</line-20>
<line-21> else:</line-21>
<line-22> i+=abs(k-(pref[i]-pref[i-r]))</line-22>
<line-23> </line-23>
<line-24> else:</line-24>
<line-25> if pref[i]==k:</line-25>
<line-26> cnt+=1</line-26>
<line-27> i+=1</line-27>
<line-28> else:</line-28>
<line-29> i+=abs(k-(pref[i]))</line-29>
<line-31> print(cnt)</line-31>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-30> k+=1</line-30>", "lines": [2, 30]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> r=26</line-3>
<line-4> if n==1:</line-4>
<line-5> return 26</line-5>
<line-6> elif n==2:</line-6>
<line-7> return 52</line-7>
<line-8> elif n==3:</line-8>
<line-9> return 728</line-9>
<line-10> else:</line-10>
<line-11> if n%2==0:</line-11>
<line-12> return ((2*(bin_expo(r,((n//2)+1),p)-r)*bin_expo(25,1000000005,p)))%p</line-12>
<line-13> else:</line-13>
<line-14> n=n+1</line-14>
<line-15> return ((2*((bin_expo(r,(n//2+1),p)-r)*bin_expo(r-1,1000000005,p)))- bin_expo(26,n//2,p))%p</line-15>
<line-16>def bin_expo(x,n,p):</line-16>
<line-17> if n==0:</line-17>
<line-18> return 1</line-18>
<line-19> elif n==1:</line-19>
<line-20> return x%p</line-20>
<line-21> else:</line-21>
<line-22> temp=bin_expo(x,n//2,p)</line-22>
<line-23> temp=(temp*temp)%p</line-23>
<line-24> if n%2==0:</line-24>
<line-25> return temp</line-25>
<line-26> else:</line-26>
<line-27> return ((x%p)*temp)%p</line-27>
<line-28></line-28>
<line-29>test=int(input())</line-29>
<line-30>for _ in range(test):</line-30>
<line-31> n=int(input())</line-31>
<line-33> print(int(permutation(n,p)))</line-33>
|
{"code": "<line-2>def permutation(n,p):</line-2>\n<line-32> p=1000000007</line-32>", "lines": [2, 32]}
#### 0
|
<line-1>'''input</line-1>
<line-3>7 3 5</line-3>
<line-4>5 2 5 2</line-4>
<line-5>2 4 2 6</line-5>
<line-6>6 2 6 4</line-6>
<line-7>5 6 5 7</line-7>
<line-8>7 1 7 4</line-8>
<line-9>7 3 7</line-9>
<line-10>1 1 6 1</line-10>
<line-11>1 2 3 2</line-11>
<line-12>5 2 5 2</line-12>
<line-13>2 6 2 6</line-13>
<line-14>6 2 6 4</line-14>
<line-15>5 6 5 7</line-15>
<line-16>7 1 7 4</line-16>
<line-17>'''</line-17>
<line-18></line-18>
<line-19>for _ in range(int(input())):</line-19>
<line-20> n, k, m = list(map(int, input().split()))</line-20>
<line-21> row_s = []</line-21>
<line-22> col_s = []</line-22>
<line-23> for _ in range(m):</line-23>
<line-24> h_x, h_y, t_x, t_y = list(map(int, input().split()))</line-24>
<line-25> if h_x == t_x:</line-25>
<line-26> if (h_x < (((n - k) // 2) + 1)) or (h_x > (((n - k) // 2) + k)):</line-26>
<line-27> col_s.append([min(h_y, t_y), max(h_y, t_y)])</line-27>
<line-28> else:</line-28>
<line-29> row_s.append([h_x, h_x])</line-29>
<line-30> if h_y == t_y:</line-30>
<line-31> if (h_y < (((n - k) // 2) + 1)) or (h_y > (((n - k) // 2) + k)):</line-31>
<line-32> row_s.append([min(h_x, t_x), max(h_x, t_x)])</line-32>
<line-33> else:</line-33>
<line-34> col_s.append([h_y, h_y])</line-34>
<line-35> row_s.sort()</line-35>
<line-36> col_s.sort()</line-36>
<line-37></line-37>
<line-38> poss = True</line-38>
<line-39></line-39>
<line-40> if len(col_s) == 0 or len(row_s) == 0:</line-40>
<line-41> print(-1)</line-41>
<line-42> continue</line-42>
<line-43></line-43>
<line-44> # print(row_s, col_s)</line-44>
<line-45></line-45>
<line-46> next_row = ((n - k) // 2) + 1</line-46>
<line-47> i = 0</line-47>
<line-48> count_row = 0</line-48>
<line-49> while i < len(row_s):</line-49>
<line-50> max_next = next_row</line-50>
<line-51> if next_row < row_s[i][0]:</line-51>
<line-52> poss = False</line-52>
<line-53> break</line-53>
<line-54> while i < len(row_s) and row_s[i][0] <= next_row:</line-54>
<line-55> # print(max_next, row_s[i], next_row)</line-55>
<line-56> max_next = max(max_next, row_s[i][1] + 1)</line-56>
<line-57> # print(max_next, row_s[i], next_row)</line-57>
<line-58> i += 1</line-58>
<line-59> next_row = max_next</line-59>
<line-60> count_row += 1</line-60>
<line-61> if next_row > (((n - k) // 2) + k):</line-61>
<line-62> break</line-62>
<line-63> if next_row < (((n - k) // 2) + k) and i >= len(row_s) :</line-63>
<line-64> poss = False</line-64>
<line-65> break</line-65>
<line-66></line-66>
<line-67> # print(count_row)</line-67>
<line-68></line-68>
<line-69> next_col = ((n - k) // 2) + 1</line-69>
<line-70> i = 0</line-70>
<line-71> count_col = 0</line-71>
<line-72> while i < len(col_s):</line-72>
<line-73> max_next = next_col</line-73>
<line-74> if next_col < col_s[i][0]:</line-74>
<line-75> poss = False</line-75>
<line-76> break</line-76>
<line-77> while i < len(col_s) and col_s[i][0] <= next_col:</line-77>
<line-78> # print(max_next, col_s[i], next_col)</line-78>
<line-79> max_next = max(max_next, col_s[i][1] + 1)</line-79>
<line-80> # print(max_next, col_s[i], next_col)</line-80>
<line-81> i += 1</line-81>
<line-82> next_col = max_next</line-82>
<line-83> count_col += 1</line-83>
<line-84> if next_col > (((n - k) // 2) + k):</line-84>
<line-85> break</line-85>
<line-86> if next_col < (((n - k) // 2) + k) and i >= len(col_s) :</line-86>
<line-87> poss = False</line-87>
<line-88> break</line-88>
<line-89></line-89>
<line-90> # print(count_col)</line-90>
<line-92></line-92>
<line-93> # print(row_s, col_s)</line-93>
|
{"code": "<line-2>2</line-2>\n<line-91> print(count_col + count_row if poss else -1)</line-91>", "lines": [2, 91]}
#### 0
|
<line-1>def ans(l):</line-1>
<line-3> i = 0</line-3>
<line-4> while (i < len(l)):</line-4>
<line-5> temp = l[i]</line-5>
<line-6> k = temp[1]</line-6>
<line-7> if (k != 0):</line-7>
<line-8> s += str(temp[0]) + "x^" + str(k)</line-8>
<line-9> else:</line-9>
<line-10> s += str(temp[0])</line-10>
<line-11> i += 1</line-11>
<line-12> if (i < len(l)):</line-12>
<line-13> s += " + "</line-13>
<line-14> if (len(s) > 0):</line-14>
<line-15> return s</line-15>
<line-16> else:</line-16>
<line-17> return "0"</line-17>
<line-18> </line-18>
<line-19>test = int(input())</line-19>
<line-20>while (test != 0):</line-20>
<line-21> test -= 1</line-21>
<line-22> N = int(input())</line-22>
<line-23> l = []</line-23>
<line-24> while (N != 0):</line-24>
<line-25> n,m = list(map(int,input().split()))</line-25>
<line-26> if (m > 0):</line-26>
<line-27> l += [[n*m,m-1]]</line-27>
<line-29> print(ans(l))</line-29>
|
{"code": "<line-2> s = \"\"</line-2>\n<line-28> N -= 1</line-28>", "lines": [2, 28]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n,k = [int(c) for c in input().split()]</line-3>
<line-4> a = [int(c) for c in input().split()]</line-4>
<line-5> ls = a</line-5>
<line-6> if n==1:</line-6>
<line-7> print("YES")</line-7>
<line-8> print(1)</line-8>
<line-9> continue</line-9>
<line-10> if k==1:</line-10>
<line-11> print("NO")</line-11>
<line-12> continue</line-12>
<line-13> </line-13>
<line-14> if k==2 and n>2:</line-14>
<line-15> if ls[0]!=ls[1]-1:</line-15>
<line-16> print("NO")</line-16>
<line-17> continue</line-17>
<line-18></line-18>
<line-19> ans = [0 for i in range(n+1)]</line-19>
<line-20> count = n</line-20>
<line-21> for i in range(1,a[1]):</line-21>
<line-22> if i != a[0]:</line-22>
<line-23> ans[i] =count</line-23>
<line-24> count-=1</line-24>
<line-25> for i in a[::-1]:</line-25>
<line-26> ans[i] = count</line-26>
<line-27> count-=1</line-27>
<line-28> for i in range(1,n+1):</line-28>
<line-29> if ans[i] == 0:</line-29>
<line-30> ans[i] = count</line-30>
<line-31> count-=1</line-31>
<line-33> print(*ans[1:])</line-33>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-32> print(\"YES\")</line-32>", "lines": [2, 32]}
#### 0
|
<line-1>def magic():</line-1>
<line-3> n=len(art)</line-3>
<line-4> for i in range(n-k+1):</line-4>
<line-5> maxi=0</line-5>
<line-6> maxi=max(art[i:i+k])</line-6>
<line-7></line-7>
<line-8> total=0</line-8>
<line-9> total=art[i:i+k].count(maxi)</line-9>
<line-10></line-10>
<line-11> if total>=m:</line-11>
<line-12> return False</line-12>
<line-13></line-13>
<line-14> return True</line-14>
<line-15> </line-15>
<line-16></line-16>
<line-17></line-17>
<line-18> for _ in range(eval(input())):</line-18>
<line-19> n,k,m=list(map(int,input().split()))</line-19>
<line-20> arr=list(map(int,input().split()))</line-20>
<line-21> dp=[]</line-21>
<line-22> ans=100</line-22>
<line-23></line-23>
<line-24> for mask in range(0,(1<<n)):</line-24>
<line-25> size=bin(mask).count('1')</line-25>
<line-26></line-26>
<line-27> if ans>size:</line-27>
<line-28> art=list(arr)</line-28>
<line-29> for i in range(n):</line-29>
<line-30> if mask & (1<<i):</line-30>
<line-31> art[i]+=1</line-31>
<line-32></line-32>
<line-33> if check(art,k,m):</line-33>
<line-34> ans=size</line-34>
<line-35></line-35>
<line-37>magic()</line-37>
|
{"code": "<line-2> def check(art,k,m):</line-2>\n<line-36> print(ans if ans!=100 else -1)</line-36>", "lines": [2, 36]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>while t>0:</line-3>
<line-4> n=int(input())</line-4>
<line-5> li=[]</line-5>
<line-6> c,o,d,e,h,f=0,0,0,0,0,0</line-6>
<line-7> for i in range(0,n):</line-7>
<line-8> s=input()</line-8>
<line-9> </line-9>
<line-10> for i in range(len(s)):</line-10>
<line-11> if s[i]=='c':</line-11>
<line-12> c=c+1</line-12>
<line-13> elif s[i]=='o':</line-13>
<line-14> o=o+1</line-14>
<line-15> elif s[i]=='d':</line-15>
<line-16> d=d+1</line-16>
<line-17> elif s[i]=='e':</line-17>
<line-18> e=e+1</line-18>
<line-19> elif s[i]=='h':</line-19>
<line-20> h=h+1</line-20>
<line-21> elif s[i]=='f':</line-21>
<line-22> f=f+1</line-22>
<line-23> e=e//2</line-23>
<line-24> c=c//2</line-24>
<line-26> t-=1</line-26>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-25> print(min(c,o,d,e,h,f)) </line-25>", "lines": [2, 25]}
#### 0
|
<line-1>D=[0]*31</line-1>
<line-3>D[2]=5</line-3>
<line-4></line-4>
<line-5>for i in range(3,31):</line-5>
<line-6> best=10**10</line-6>
<line-7> for p in range(1,i+1):</line-7>
<line-8> best=min(best,D[p-1]+D[i-p]+i+1)</line-8>
<line-9> D[i]=best</line-9>
<line-10></line-10>
<line-11>t=int(input())</line-11>
<line-12>for i in range(t):</line-12>
<line-13> n,m=list(map(int,input().split()))</line-13>
<line-14> maxi=(n+2)*(n+1)/2-1</line-14>
<line-15> mini=D[n]</line-15>
<line-16> if mini<=m<=maxi: print(0)</line-16>
<line-18> else: print(m-maxi)</line-18>
|
{"code": "<line-2>D[1]=2</line-2>\n<line-17> elif m<mini: print(-1)</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>def diagonal_difference(matrix):</line-1>
<line-3> r = sum(matrix[i][N-i-1] for i in range(N))</line-3>
<line-4> return abs(l - r)</line-4>
<line-5></line-5>
<line-6>matrix = []</line-6>
<line-7>N = eval(input())</line-7>
<line-8>for _ in range(N):</line-8>
<line-10></line-10>
<line-11>print(diagonal_difference(matrix))</line-11>
|
{"code": "<line-2> l = sum(matrix[i][i] for i in range(N))</line-2>\n<line-9> matrix.append(list(map(int, input().split())))</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n,m=map(int,input().split())</line-3>
<line-4> d={}</line-4>
<line-5> e={}</line-5>
<line-6> l=[]</line-6>
<line-7> for i in range(n):</line-7>
<line-8> d[i]=0</line-8>
<line-9> for i in range(m):</line-9>
<line-10> e[i]=0</line-10>
<line-11> for i in range(n):</line-11>
<line-12> l.append(input())</line-12>
<line-13> for i in range(n):</line-13>
<line-14> for j in range(m):</line-14>
<line-15> if l[i][j]=='1':</line-15>
<line-16> d[i]=1</line-16>
<line-17> e[j]=1</line-17>
<line-18> #ans=[]</line-18>
<line-19> if sum(d.values())+sum(e.values())==0:</line-19>
<line-20> k=[-1]*m</line-20>
<line-21> for i in range(n):</line-21>
<line-22> print(*k)</line-22>
<line-23> else:</line-23>
<line-24> ans=[]</line-24>
<line-25> for i in range(n):</line-25>
<line-26> ans.append([0]*m)</line-26>
<line-27> for i in range(n):</line-27>
<line-28> for j in range(m):</line-28>
<line-29> if l[i][j]=='1':</line-29>
<line-30> ans[i][j]=0</line-30>
<line-31> else:</line-31>
<line-32> if (d[i] or e[j]):</line-32>
<line-33> ans[i][j]=1</line-33>
<line-34> else:</line-34>
<line-35> ans[i][j]=2</line-35>
<line-36> for i in range(n):</line-36>
<line-37> for j in range(m):</line-37>
<line-39> print()</line-39>
<line-40> </line-40>
<line-41> </line-41>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-38> print(ans[i][j],end=\" \")</line-38>", "lines": [2, 38]}
#### 0
|
<line-1># cook your code here</line-1>
<line-3> n=eval(input())</line-3>
<line-4> ind=0</line-4>
<line-5> m=-1</line-5>
<line-6> </line-6>
<line-7> for i in range(n):</line-7>
<line-8> </line-8>
<line-9> l=[int(x) for x in input().split()]</line-9>
<line-10> sc=l[0]</line-10>
<line-11> for j in range(1,len(l)):</line-11>
<line-12> sc+=int(l[j]>=4)+int(l[j]>=5)+2*int(l[j]>=6)</line-12>
<line-13> if sc==m:</line-13>
<line-14> ind=-2</line-14>
<line-15> if sc>m :</line-15>
<line-16> m=sc</line-16>
<line-17> ind=i+1</line-17>
<line-18> </line-18>
<line-19> </line-19>
<line-20> if (ind==-2):</line-20>
<line-21> print("tie")</line-21>
<line-22> elif (ind==1) :</line-22>
<line-23> print("chef")</line-23>
<line-25> print(ind)</line-25>
|
{"code": "<line-2>for _ in range(eval(input())):</line-2>\n<line-24> else:</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>c,f=list(map(int,input().split()))</line-1>
<line-3>while f:</line-3>
<line-4> x,y,cost=list(map(int,input().split()))</line-4>
<line-5> l[x-1][y-1]=cost</line-5>
<line-6> l[y-1][x-1]=cost</line-6>
<line-7> f-=1 </line-7>
<line-8>for i in range(c):</line-8>
<line-9> l[i][i]=0</line-9>
<line-10>for k in range(c): </line-10>
<line-11> for x in range(c):</line-11>
<line-12> for y in range(c): </line-12>
<line-13> if x==k or y==k or x==y:</line-13>
<line-14> continue</line-14>
<line-15> elif x!=y:</line-15>
<line-16> l[x][y]=min(l[x][y],l[x][k]+l[k][y]) </line-16>
<line-17>m=-1 </line-17>
<line-18>for i in range(c):</line-18>
<line-19> for j in range(c):</line-19>
<line-20> if m<l[i][j]:</line-20>
<line-21> m=l[i][j]</line-21>
<line-23> # cook your dish here</line-23>
|
{"code": "<line-2>l=[[1000001 for i in range(c)] for j in range(c)] </line-2>\n<line-22>print(m)</line-22>", "lines": [2, 22]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> </line-3>
<line-4> n = int(input())</line-4>
<line-5> </line-5>
<line-6> li1 = list(map(int,input().split(' ')))</line-6>
<line-7> li2 = list(map(int,input().split(' ')))</line-7>
<line-8> walk = 0</line-8>
<line-9> sum1 = 0 </line-9>
<line-10> sum2 = 0</line-10>
<line-11> for i in range(n):</line-11>
<line-12> if li1[i] == li2[i] and sum1 == sum2:</line-12>
<line-13> walk += li1[i]</line-13>
<line-14> sum1 += li1[i]</line-14>
<line-16> print(walk)</line-16>
|
{"code": "<line-2>for tc in range(int(input())):</line-2>\n<line-15> sum2 += li2[i]</line-15>", "lines": [2, 15]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for t in range(T):</line-3>
<line-4> N = int(input())</line-4>
<line-6> print(s[0])</line-6>
|
{"code": "<line-2>T = int(input())</line-2>\n<line-5> s = sorted(list(str(input())))</line-5>", "lines": [2, 5]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3></line-3>
<line-4>for i in range(int(input())):</line-4>
<line-5> n=int(input())</line-5>
<line-6> arr=list(map(int,input().split()))</line-6>
<line-7> coun=Counter(arr)</line-7>
<line-8> check=True</line-8>
<line-9></line-9>
<line-10> for j in coun:</line-10>
<line-11> if coun[j]>n//2:</line-11>
<line-12> print("No")</line-12>
<line-13> check=False</line-13>
<line-14> break</line-14>
<line-15></line-15>
<line-16></line-16>
<line-17></line-17>
<line-18></line-18>
<line-19> if check==True:</line-19>
<line-20> print("Yes")</line-20>
<line-21> narr=sorted(arr)</line-21>
<line-22> dic=defaultdict()</line-22>
<line-23> j=0</line-23>
<line-24> for j in range(len(narr)):</line-24>
<line-25> if narr[j] not in dic:</line-25>
<line-26> dic[narr[j]]=j</line-26>
<line-27> ans=[0]*n</line-27>
<line-28> for j in range(len(arr)):</line-28>
<line-29> ans[j]=narr[(dic[arr[j]]+n//2)%n]</line-29>
<line-30> if coun[arr[j]]!=1:</line-30>
<line-32> print(*ans)</line-32>
|
{"code": "<line-2>from collections import Counter,defaultdict</line-2>\n<line-31> dic[arr[j]]+=1</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>for _ in range(eval(input())):</line-1>
<line-3> if n%2:</line-3>
<line-4> print('NO')</line-4>
<line-6> print('YES') </line-6>
|
{"code": "<line-2> n=eval(input())</line-2>\n<line-5> else:</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> s = input().rstrip()</line-3>
<line-4> sumv = 0</line-4>
<line-5> for j in range(len(s)):</line-5>
<line-6> sumv += ord(s[j])</line-6>
<line-7> minv = 10 ** 8;</line-7>
<line-8> for i in range(ord('a'), ord('z') + 1):</line-8>
<line-9> val = abs(sumv - i * len(s))</line-9>
<line-10> if minv > val:</line-10>
<line-12> print(minv)</line-12>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-11> minv = val</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>from math import sqrt</line-1>
<line-3> for i in range(2, int(sqrt(n))+1):</line-3>
<line-4> if(n%i==0): return True</line-4>
<line-5> return False</line-5>
<line-6>ans = []</line-6>
<line-7>for _ in range(int(input())):</line-7>
<line-8> x, y = map(int, input().split())</line-8>
<line-10>print('\n'.join(ans))</line-10>
|
{"code": "<line-2>def isPrime(n):</line-2>\n<line-9> ans.append('NO' if(isPrime(x**2-y**2)) else 'YES')</line-9>", "lines": [2, 9]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>#powerful numbers</line-3>
<line-4>n = int(input())</line-4>
<line-5>plist = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313]</line-5>
<line-6>power = 1</line-6>
<line-7>for i in range(2,n+1,1):</line-7>
<line-8> pdiv = []</line-8>
<line-9> count = 0</line-9>
<line-10> for p in plist:</line-10>
<line-11> if i>=p and i%p==0:</line-11>
<line-12> pdiv.append(p)</line-12>
<line-13> for pd in pdiv:</line-13>
<line-14> if i%(pd**2)==0:</line-14>
<line-15> count+=1</line-15>
<line-16> if count==len(pdiv) and count!=0:</line-16>
<line-18></line-18>
<line-19> </line-19>
<line-20> </line-20>
<line-21>print(power)</line-21>
|
{"code": "<line-2># cook your dish here</line-2>\n<line-17> power+=1</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>#!/usr/bin/env python</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>def process(S):</line-5>
<line-6> P = [0,0,'S']</line-6>
<line-7> for i in S:</line-7>
<line-8> if i == 'L':</line-8>
<line-9> if P[-1] == 'N': P[-1] = 'W'</line-9>
<line-10> elif P[-1] == 'S': P[-1] = 'E'</line-10>
<line-11> elif P[-1] == 'E': P[-1] = 'N'</line-11>
<line-12> elif P[-1] == 'W': P[-1] = 'S'</line-12>
<line-13> elif i == 'R':</line-13>
<line-14> if P[-1] == 'N': P[-1] = 'E'</line-14>
<line-15> elif P[-1] == 'S': P[-1] = 'W'</line-15>
<line-16> elif P[-1] == 'E': P[-1] = 'S'</line-16>
<line-17> elif P[-1] == 'W': P[-1] = 'N'</line-17>
<line-18> else:</line-18>
<line-19> i = int(i)</line-19>
<line-20> if P[-1] == 'N': P[1] -= i</line-20>
<line-21> elif P[-1] == 'S': P[1] += i</line-21>
<line-22> elif P[-1] == 'E': P[0] += i</line-22>
<line-23> elif P[-1] == 'W': P[0] -= i</line-23>
<line-24> #print i, P</line-24>
<line-25> DIST = sqrt(P[0]**2+P[1]**2)</line-25>
<line-26></line-26>
<line-27> if P[0] == 0 and P[1] == 0: DIR = ''</line-27>
<line-28> elif P[0] == 0 and P[1] < 0: DIR = 'S'</line-28>
<line-29> elif P[0] == 0 and P[1] > 0: DIR = 'N'</line-29>
<line-30> elif P[0] < 0 and P[1] == 0: DIR = 'E'</line-30>
<line-31> elif P[0] < 0 and P[1] < 0: DIR = 'SE'</line-31>
<line-32> elif P[0] < 0 and P[1] > 0: DIR = 'NE'</line-32>
<line-33> elif P[0] > 0 and P[1] == 0: DIR = 'W'</line-33>
<line-34> elif P[0] > 0 and P[1] < 0: DIR = 'SW'</line-34>
<line-35> elif P[0] > 0 and P[1] > 0: DIR = 'NW'</line-35>
<line-36></line-36>
<line-37> DIST = int(DIST*10.)/10. # TOLD NO APPROXIMATION</line-37>
<line-38></line-38>
<line-39> return '%.1f%s' % (DIST, DIR)</line-39>
<line-40></line-40>
<line-41>def main():</line-41>
<line-42> T = int(input())</line-42>
<line-43> for t in range(T):</line-43>
<line-44> S = input().split()</line-44>
<line-46></line-46>
<line-47>main()</line-47>
<line-48></line-48>
|
{"code": "<line-3>from math import sqrt</line-3>\n<line-45> print(process(S))</line-45>", "lines": [3, 45]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> t-=1</line-3>
<line-4> d={}</line-4>
<line-5> n,m,k=[int(x) for x in list(input().split())]</line-5>
<line-6> sum=0</line-6>
<line-7> while(k):</line-7>
<line-8> k-=1</line-8>
<line-9> x,y=[int(x) for x in list(input().split())]</line-9>
<line-10> a=[-1,1,0,0]</line-10>
<line-11> b=[0,0,-1,1]</line-11>
<line-12> for i in range(4):</line-12>
<line-13> if((x+a[i],y+b[i]) in d):</line-13>
<line-14> sum-=1</line-14>
<line-15> else:</line-15>
<line-16> sum+=1</line-16>
<line-18> print(sum)</line-18>
|
{"code": "<line-2>while(t):</line-2>\n<line-17> d[(x,y)]=1</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>import random</line-1>
<line-3>yash=(2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997)</line-3>
<line-4></line-4>
<line-5>def fix(m):</line-5>
<line-6> for ai in yash:</line-6>
<line-7> if m%ai==0:</line-7>
<line-8> return ai</line-8>
<line-9> return m</line-9>
<line-10></line-10>
<line-11>def rabin_miller(a,i,n):</line-11>
<line-12> if i==0:</line-12>
<line-13> return 1</line-13>
<line-14> x=rabin_miller(a,i/2,n)</line-14>
<line-15> if x==0:</line-15>
<line-16> return 0</line-16>
<line-17> y=(x*x)%n</line-17>
<line-18> if (y==1)and(x!=1)and(x!=n-1):</line-18>
<line-19> return 0</line-19>
<line-20> if i%2!=0:</line-20>
<line-21> y=(a*y)%n</line-21>
<line-22> return y</line-22>
<line-23></line-23>
<line-24>def gcd(x,y):</line-24>
<line-25> if y==0:</line-25>
<line-26> return x</line-26>
<line-27> return gcd(y,x%y)</line-27>
<line-28></line-28>
<line-29>def brent_rho(n):</line-29>
<line-30> if (n<=3)or(rabin_miller(random.randint(2,n-2),n-1,n)==1):</line-30>
<line-31> return n</line-31>
<line-32> y,r,q,m=1,1,1,203</line-32>
<line-33> while 1:</line-33>
<line-34> x=y</line-34>
<line-35> for i in range(1,r+1):</line-35>
<line-36> y=(y*y+1)%n</line-36>
<line-37> k=0</line-37>
<line-38> while 1:</line-38>
<line-39> ys=y</line-39>
<line-40> for i in range(1,min(m,r-k)+1):</line-40>
<line-41> y=(y*y+1)%n</line-41>
<line-42> q=(q*abs(x-y))%n</line-42>
<line-43> g=gcd(q,n)</line-43>
<line-44> k+=m</line-44>
<line-45> if (k>=r)or(g>1):</line-45>
<line-46> break</line-46>
<line-47> r*=2</line-47>
<line-48> if g>1:</line-48>
<line-49> break</line-49>
<line-50> if g==n:</line-50>
<line-51> while 1:</line-51>
<line-52> ys=(ys*ys+1)%n</line-52>
<line-53> g=gcd(abs(x-ys),n)</line-53>
<line-54> if g>1:</line-54>
<line-55> break</line-55>
<line-56> if g==n:</line-56>
<line-57> return n</line-57>
<line-58> return brent_rho(g)</line-58>
<line-59></line-59>
<line-60>def divsum2(n):</line-60>
<line-61> if n==1:</line-61>
<line-62> return 0</line-62>
<line-63> d=brent_rho(n)</line-63>
<line-64> d=fix(d)</line-64>
<line-65> assert (d<=3)or(rabin_miller(random.randint(2,d-2),d-1,d)==1)</line-65>
<line-66> f,m=0,n</line-66>
<line-67> while m%d==0:</line-67>
<line-68> m/=d</line-68>
<line-69> f = f + 1;</line-69>
<line-70> return (f*d)+(divsum2(m))</line-70>
<line-71></line-71>
<line-72>try:</line-72>
<line-73> while(1):</line-73>
<line-74> z=eval(input())</line-74>
<line-75> print(divsum2(z))</line-75>
<line-77> os.sys.exit(0);</line-77>
|
{"code": "<line-2>import os</line-2>\n<line-76>except:</line-76>", "lines": [2, 76]}
#### 0
|
<line-1>import random</line-1>
<line-2></line-2>
<line-4> if i>0:</line-4>
<line-5> return 1</line-5>
<line-6> elif i<=0:</line-6>
<line-7> return 0</line-7>
<line-8>bleh = []</line-8>
<line-9>for _ in range(int(input())):</line-9>
<line-10> p = list(map(int,input().rstrip().split()))</line-10>
<line-11> max_rows = len(p)</line-11>
<line-12> if all([x==0 for x in p]):</line-12>
<line-13> print(1)</line-13>
<line-14> continue</line-14>
<line-15> if max_rows <= 1:</line-15>
<line-16> bleh.append(max_rows)</line-16>
<line-17> continue</line-17>
<line-18> max_pow = max_rows-1</line-18>
<line-19> if len(p)%2 !=0 and len(p)>0:</line-19>
<line-20> p.append(0)</line-20>
<line-21> max_col = len(p)//2</line-21>
<line-22> </line-22>
<line-23> rows = [[0 for _ in range(max_col)] for _ in range(max_rows)]</line-23>
<line-24> rows[0] = p[::2]</line-24>
<line-25> rows[1] = p[1::2]</line-25>
<line-26> if sign(rows[0][0]) != sign(rows[1][0]):</line-26>
<line-27> print(0)</line-27>
<line-28> continue</line-28>
<line-29> </line-29>
<line-30> for r in range(2,max_rows):</line-30>
<line-31> for n in range(max_col-1):</line-31>
<line-32> rows[r][n] = rows[r-1][0]*rows[r-2][n+1]-rows[r-2][0]*rows[r-1][n+1]</line-32>
<line-33> </line-33>
<line-34> last = sign(rows[0][0])</line-34>
<line-35> flag = 1</line-35>
<line-36> for i in range(1,len(rows)):</line-36>
<line-37> curr = sign(rows[i][0])</line-37>
<line-38> if rows[r] == [0 for _ in range(max_col)]:</line-38>
<line-39> for n in range(max_col):</line-39>
<line-40> rows[r][n] = rows[r-1][n]*(max_pow+4-(r+1)-2*(n+1)) </line-40>
<line-41> </line-41>
<line-42> elif rows[i][0] == 0:</line-42>
<line-43> if any([x != 0 for x in rows[i]]):</line-43>
<line-44> flag = 0</line-44>
<line-45> break</line-45>
<line-46> else:</line-46>
<line-47> curr = last</line-47>
<line-48> if curr != last:</line-48>
<line-49> flag = 0</line-49>
<line-50> break</line-50>
<line-52> print(flag)</line-52>
|
{"code": "<line-3>def sign(i):</line-3>\n<line-51> last = curr </line-51>", "lines": [3, 51]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(t,0,-1):</line-3>
<line-4> x,y=map(int,input().split())</line-4>
<line-5> k=x//y</line-5>
<line-6> </line-6>
<line-7> if k%y==0:</line-7>
<line-8> print("NO")</line-8>
<line-10> print("YES")</line-10>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-9> else:</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n=int(input())</line-3>
<line-4> l1=[]</line-4>
<line-5> if n==1:</line-5>
<line-6> print('*')</line-6>
<line-7> elif n==3:</line-7>
<line-8> print('*')</line-8>
<line-9> print('**')</line-9>
<line-10> print('*')</line-10>
<line-11> else:</line-11>
<line-12> s1=""</line-12>
<line-13> n1=n//2</line-13>
<line-14> n1+=1 </line-14>
<line-15> for i in range(1,n1+1):</line-15>
<line-16> s1=""</line-16>
<line-17> if i==1:</line-17>
<line-18> s1+='*'</line-18>
<line-19> elif i==2:</line-19>
<line-20> s1+='**'</line-20>
<line-21> else:</line-21>
<line-22> s1+='*'</line-22>
<line-23> for j in range(2,i):</line-23>
<line-24> s1+=' '</line-24>
<line-25> s1+='*'</line-25>
<line-26> l1.append(s1)</line-26>
<line-27> for i in l1:</line-27>
<line-28> print(i)</line-28>
<line-29> l1.reverse()</line-29>
<line-31> print(l1[i])</line-31>
<line-32> </line-32>
<line-33> </line-33>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-30> for i in range(1,len(l1)):</line-30>", "lines": [2, 30]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-2></line-2>
<line-4>while t:</line-4>
<line-5> t -= 1</line-5>
<line-6> n = int(input())</line-6>
<line-7> arr = list(map(int, input().split()))</line-7>
<line-8> sumi = sum(arr)</line-8>
<line-9> prev = 1</line-9>
<line-10> for i in range(n):</line-10>
<line-11> arr[i] = min(arr[i], prev)</line-11>
<line-12> prev = arr[i] + 1</line-12>
<line-13> prev = 1</line-13>
<line-14> for i in range(n - 1, -1, -1):</line-14>
<line-15> arr[i] = min(arr[i], prev)</line-15>
<line-16> prev = arr[i] + 1</line-16>
<line-17> temp = 0</line-17>
<line-18> for i in range(n):</line-18>
<line-20> print(sumi -( temp*temp))</line-20>
<line-21></line-21>
<line-22></line-22>
|
{"code": "<line-3>t = int(input())</line-3>\n<line-19> temp = max(temp, arr[i])</line-19>", "lines": [3, 19]}
#### 0
|
<line-1>def treeProduct(num, h, root, ch):</line-1>
<line-3> return num[root]</line-3>
<line-4></line-4>
<line-5> left = (root * 2) + 1</line-5>
<line-6> right = (root * 2) + 2</line-6>
<line-7></line-7>
<line-8> ret1 = treeProduct(num, h, left, ch + 1)</line-8>
<line-9> ret2 = treeProduct(num, h, right, ch + 1)</line-9>
<line-10></line-10>
<line-11> return num[root] * max(ret1, ret2)</line-11>
<line-12></line-12>
<line-13>def main():</line-13>
<line-14> n = int(input())</line-14>
<line-15> while n!=0:</line-15>
<line-16> line = str(input())</line-16>
<line-17> s = line.split()</line-17>
<line-18> num = [int((e)) for e in s]</line-18>
<line-19> print(int(treeProduct(num,n,0,1)%1000000007))</line-19>
<line-20> n = int(input())</line-20>
<line-21> </line-21>
<line-22> </line-22>
<line-23>def __starting_point():</line-23>
<line-25></line-25>
<line-26>__starting_point()</line-26>
|
{"code": "<line-2> if ch >= h:</line-2>\n<line-24> main()</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3></line-3>
<line-4> arr= list(map(int,input().split()))</line-4>
<line-5> arr.sort()</line-5>
<line-6> d={}</line-6>
<line-7> for i in arr:</line-7>
<line-8> if i not in d:</line-8>
<line-9> d[i]=1</line-9>
<line-10> else:</line-10>
<line-11> d[i]+=1</line-11>
<line-12> </line-12>
<line-13> flag = True</line-13>
<line-14> for i in d:</line-14>
<line-15> if d[i]>2:</line-15>
<line-16> flag=False</line-16>
<line-17> break</line-17>
<line-18> </line-18>
<line-19> </line-19>
<line-20></line-20>
<line-21> if arr.count(max(arr))!=1:</line-21>
<line-22> flag=False</line-22>
<line-23> </line-23>
<line-24> </line-24>
<line-25> if flag==True:</line-25>
<line-26></line-26>
<line-27> arr1=[]</line-27>
<line-28> arr2=[]</line-28>
<line-29> for i in d:</line-29>
<line-30> if d[i]<=2:</line-30>
<line-31> if d[i]==2:</line-31>
<line-32> </line-32>
<line-33> arr2.append(i)</line-33>
<line-34> arr1.append(i)</line-34>
<line-35> arr2.reverse()</line-35>
<line-36> rearr= arr1+arr2</line-36>
<line-37></line-37>
<line-38> print("YES")</line-38>
<line-39> print(*rearr)</line-39>
<line-40></line-40>
<line-41> else:</line-41>
<line-43> </line-43>
<line-44># cook your dish here</line-44>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-42> print(\"NO\")</line-42>", "lines": [2, 42]}
#### 0
|
<line-1>from itertools import permutations</line-1>
<line-2></line-2>
<line-4> ans=[]</line-4>
<line-5> </line-5>
<line-6> for des in desire:</line-6>
<line-7> check=1</line-7>
<line-8> for i in range(n-1):</line-8>
<line-9> </line-9>
<line-10> if (a[i]==a[i+1]):</line-10>
<line-11> return [-1]</line-11>
<line-12> if a[i+1]==des[a[i]-1]:</line-12>
<line-13> check=0</line-13>
<line-14> break</line-14>
<line-15> if check:</line-15>
<line-16> ans=des</line-16>
<line-17> break</line-17>
<line-18> if ans:</line-18>
<line-19> return ans</line-19>
<line-20> return [-1]</line-20>
<line-21> </line-21>
<line-22></line-22>
<line-23>per=permutations([1,2,3,4,5,6])</line-23>
<line-24>desire=[]</line-24>
<line-25>for p in per:</line-25>
<line-26> check=1</line-26>
<line-27> for i in range(1,7):</line-27>
<line-28> if p[i-1]==i:</line-28>
<line-29> check=0</line-29>
<line-30> break</line-30>
<line-31> if check:</line-31>
<line-32> doublecheck=1</line-32>
<line-33> for i in range(6):</line-33>
<line-34> if p[p[i]-1]!=i+1:</line-34>
<line-35> doublecheck=0</line-35>
<line-36> break</line-36>
<line-37> if doublecheck:</line-37>
<line-38> desire.append(p)</line-38>
<line-39>#print(desire)</line-39>
<line-40>for _ in range(int(input())):</line-40>
<line-41> </line-41>
<line-42> n=int(input())</line-42>
<line-44> print(*solve(n,a))</line-44>
|
{"code": "<line-3>def solve(n,a):</line-3>\n<line-43> a=list(map(int,input().split( )))</line-43>", "lines": [3, 43]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>for i in range(n):</line-3>
<line-4> l.append([int(x) for x in input().split()])</line-4>
<line-5>d=[10**9]*(n)</line-5>
<line-6>q=set([int(x) for x in range(1,n)])</line-6>
<line-7>d[1]=0</line-7>
<line-8>#print(q)</line-8>
<line-9>def extract():</line-9>
<line-10> mini=10**9</line-10>
<line-11> o=0</line-11>
<line-12> for i in range(1,len(d)):</line-12>
<line-13> if d[i]<mini and i in q:</line-13>
<line-14> mini=d[i]</line-14>
<line-15> o=i</line-15>
<line-16> q.remove(o)</line-16>
<line-17> return o</line-17>
<line-18>while len(q)!=0:</line-18>
<line-19> x=extract()</line-19>
<line-20> for i in range(1,n):</line-20>
<line-21> if i in q and l[x][i]<d[i]:</line-21>
<line-23>print(sum(d[1:]))</line-23>
|
{"code": "<line-2>l=[]</line-2>\n<line-22>\t\t\td[i]=l[x][i]</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>def invper(ar):</line-1>
<line-3> for i in range(len(ar)):</line-3>
<line-4> ar1[ar[i]-1]=i+1</line-4>
<line-5> return ar1</line-5>
<line-6>t=int(input())</line-6>
<line-7></line-7>
<line-8>while(t!=0):</line-8>
<line-9> ar=list(map(int,input().split()))</line-9>
<line-10> ar1=invper(ar)</line-10>
<line-11> if(ar==ar1):</line-11>
<line-12> print("ambiguous")</line-12>
<line-13> else:</line-13>
<line-15> t = int(input())</line-15>
|
{"code": "<line-2> ar1=[0]*(len(ar))</line-2>\n<line-14> print(\"not ambiguous\")</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> s=list(input())</line-3>
<line-4> coord=list(map(int,input().split()))</line-4>
<line-5> p=0</line-5>
<line-6> i=0</line-6>
<line-7> h=[]</line-7>
<line-8> for i in range(0,n):</line-8>
<line-9> if s[i]=='1':</line-9>
<line-10> h.append(i)</line-10>
<line-11> if h[0]!=0:</line-11>
<line-12> p=p+coord[h[0]]-coord[0]</line-12>
<line-13> if h[len(h)-1]!=n-1:</line-13>
<line-14> p=p+coord[n-1]-coord[h[len(h)-1]]</line-14>
<line-15> for j in range(0,len(h)-1):</line-15>
<line-16> if h[j]+1==h[j+1]:</line-16>
<line-17> continue</line-17>
<line-18> if h[j+1]-h[j]-1==1:</line-18>
<line-19> p=p+min(coord[h[j]+1]-coord[h[j]],coord[h[j+1]]-coord[h[j]+1])</line-19>
<line-20> else:</line-20>
<line-21> y=min(coord[h[j+1]]-coord[h[j]+1],coord[h[j+1]-1]-coord[h[j]])</line-21>
<line-22> for k in range(h[j]+1,h[j+1]-1):</line-22>
<line-23> y=min(y,coord[k]-coord[h[j]]+coord[h[j+1]]-coord[k+1])</line-23>
<line-25> print(p)</line-25>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-24> p=p+y</line-24>", "lines": [2, 24]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>a={}</line-3>
<line-4>for i in range(n):</line-4>
<line-5> x,y=input().split()</line-5>
<line-6> a[x]=y</line-6>
<line-7>for i in range(m):</line-7>
<line-8> c=input().strip()</line-8>
<line-9> if '.' not in c:</line-9>
<line-10> print("unknown")</line-10>
<line-11> else:</line-11>
<line-12> h=c.split('.')[-1]</line-12>
<line-13> if h in a:</line-13>
<line-14> print(a[h])</line-14>
<line-16> print('unknown')</line-16>
<line-17> </line-17>
<line-18> </line-18>
|
{"code": "<line-2>n,m=list(map(int,input().split()))</line-2>\n<line-15> else:</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>for t in range(int(input())):</line-1>
<line-3> l2=list(map(int,input().split()))</line-3>
<line-4> l3=list(map(int,input().split()))</line-4>
<line-5> max=0</line-5>
<line-6> g=l1[0]+l2[0]+l3[0]</line-6>
<line-7> y=l1[1]+l2[1]+l3[1]</line-7>
<line-8> r=l1[2]+l2[2]+l3[2]</line-8>
<line-9> if g%2==0:</line-9>
<line-10> g-=1</line-10>
<line-11> if y%2==0:</line-11>
<line-12> y-=1</line-12>
<line-13> if r%2==0:</line-13>
<line-14> r-=1</line-14>
<line-15> if max<g:</line-15>
<line-16> max=g</line-16>
<line-17> if max<r:</line-17>
<line-18> max=r</line-18>
<line-19> if max<y:</line-19>
<line-20> max=y</line-20>
<line-21> m=l1[0]+l1[1]+l1[2]</line-21>
<line-22> o=l2[0]+l2[1]+l2[2]</line-22>
<line-23> p=l3[0]+l3[1]+l3[2]</line-23>
<line-24> if m%2==0:</line-24>
<line-25> m-=1</line-25>
<line-26> if o%2==0:</line-26>
<line-27> o-=1</line-27>
<line-28> if p%2==0:</line-28>
<line-29> p-=1</line-29>
<line-30> if max<m:</line-30>
<line-31> max=m</line-31>
<line-32> if max<o:</line-32>
<line-33> max=o</line-33>
<line-34> if max<p:</line-34>
<line-36></line-36>
<line-37> print(max)</line-37>
|
{"code": "<line-2>\tl1=list(map(int,input().split()))</line-2>\n<line-35>\t\tmax=p</line-35>", "lines": [2, 35]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n = int(input())</line-3>
<line-4> flag = 0</line-4>
<line-5> while(n>0):</line-5>
<line-6> if((n%10)%2 == 0):</line-6>
<line-7> flag = 1</line-7>
<line-8> break</line-8>
<line-9> n = n//10</line-9>
<line-10> if(flag == 0):</line-10>
<line-11> print(0)</line-11>
<line-13> print(1)</line-13>
|
{"code": "<line-2>for i in range(int(input())):</line-2>\n<line-12> else:</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>l = []</line-1>
<line-3> l.append(int(input()))</line-3>
<line-4>for i in range(2,max(l)):</line-4>
<line-5> r = [x%i for x in l]</line-5>
<line-7> print(i, end = ' ')</line-7>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-6> if len(set([x%i for x in l])) == 1:</line-6>", "lines": [2, 6]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>try:</line-3>
<line-4> def prime(n):</line-4>
<line-5> for i in range(2, int(math.sqrt(n)) + 1):</line-5>
<line-6> if n % i == 0:</line-6>
<line-7> return False</line-7>
<line-8> return True</line-8>
<line-9> </line-9>
<line-10> for t in range(int(input())):</line-10>
<line-11> x, y = list(map(int, input().split()))</line-11>
<line-12> s = x + y </line-12>
<line-13> i = s</line-13>
<line-14> while(1):</line-14>
<line-15> if prime(s + 1):</line-15>
<line-16> ans = s + 1</line-16>
<line-17> break</line-17>
<line-18> else:</line-18>
<line-19> s += 1</line-19>
<line-21></line-21>
<line-22>except: pass</line-22>
|
{"code": "<line-2>import math</line-2>\n<line-20> print(ans - i)</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>for t in range(int(input())):</line-1>
<line-3> s=input().strip()</line-3>
<line-4> c=0</line-4>
<line-5> flag=0</line-5>
<line-6> for i in range(n):</line-6>
<line-7> if (s[i]=="A" or s[i]=="E" or s[i]=="I" or s[i]=="O" or s[i]=="U") and (s[i-1]=="A" or s[i-1]=="E" or s[i-1]=="I" or s[i-1]=="O" or s[i-1]=="U") :</line-7>
<line-8> flag=1</line-8>
<line-9> if flag and n!=1:</line-9>
<line-10> print("Yes")</line-10>
<line-12> print("No")</line-12>
|
{"code": "<line-2>\tn=int(input())</line-2>\n<line-11>\telse:</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>import sys</line-1>
<line-3>input=sys.stdin.readline</line-3>
<line-4>def binary(l,r,co,b,c):</line-4>
<line-5> x=(l+r)/2</line-5>
<line-6> #print(x)</line-6>
<line-7> val1=(2*x+b)*math.sin(x)</line-7>
<line-8> val2=(x**2+b*x+c)*math.cos(x)</line-8>
<line-9> x=(l+r)/2</line-9>
<line-10> val=val1-val2</line-10>
<line-11> if(abs(val)<.0000001 or co==150):</line-11>
<line-12> return (l+r)/2</line-12>
<line-13> if(val<0):</line-13>
<line-14> return binary((l+r)/2,r,co+1,b,c)</line-14>
<line-15> else:</line-15>
<line-16> return binary(l,(l+r)/2,co+1,b,c)</line-16>
<line-17>t=int(input())</line-17>
<line-18>for _ in range(t):</line-18>
<line-19> b,c=list(map(float,input().split()))</line-19>
<line-20> x=binary(.0000000001,math.pi/2-.0000000001,0,b,c)</line-20>
<line-21> #print("t=",_)</line-21>
<line-23> print(val)</line-23>
<line-24> </line-24>
<line-25></line-25>
<line-26> </line-26>
<line-27></line-27>
<line-28></line-28>
<line-29> </line-29>
<line-30> </line-30>
<line-31> </line-31>
<line-32></line-32>
<line-33></line-33>
<line-34> </line-34>
|
{"code": "<line-2>import math</line-2>\n<line-22> val=(x*x+b*x+c)/math.sin(x)</line-22>", "lines": [2, 22]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>def sieve():</line-3>
<line-4> for i in range(2,10**5+1):</line-4>
<line-5> if(store[i]==0):</line-5>
<line-6> store[i]=1</line-6>
<line-7> for j in range(i,10**5+1,i):</line-7>
<line-8> store[j]=i</line-8>
<line-9>sieve()</line-9>
<line-10># print(store)</line-10>
<line-11>for _ in range(int(input())):</line-11>
<line-12> </line-12>
<line-13> n=int(input())</line-13>
<line-14> li=[int(x) for x in input().split()]</line-14>
<line-15></line-15>
<line-16> dp=[0]*(10**5+1)</line-16>
<line-17> for i in li:</line-17>
<line-18> dp[store[i]]+=1</line-18>
<line-19> max_re=0</line-19>
<line-20> res=0</line-20>
<line-21> for i in li:</line-21>
<line-22> if(dp[store[i]]==max_re):</line-22>
<line-23> if(store[i]>res):</line-23>
<line-24> res=store[i]</line-24>
<line-25> elif(dp[store[i]]>max_re):</line-25>
<line-26> max_re=dp[store[i]]</line-26>
<line-28> </line-28>
<line-29> print(res)</line-29>
<line-30></line-30>
<line-31></line-31>
<line-32></line-32>
|
{"code": "<line-2>store=[0]*(10**5+1)</line-2>\n<line-27>\t\t\tres=store[i]</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>import math</line-1>
<line-3> if a == 0:</line-3>
<line-4> return (b, 0, 1)</line-4>
<line-5> else:</line-5>
<line-6> g, y, x = egcd(b % a, a)</line-6>
<line-7> return (g, x - (b // a) * y, y)</line-7>
<line-8></line-8>
<line-9>def modin(a, m):</line-9>
<line-10> g, x, y = egcd(a, m)</line-10>
<line-11> return x % m</line-11>
<line-12># def gcdexten(a,b,x,y):</line-12>
<line-13># if a == 0:</line-13>
<line-14># x = 0</line-14>
<line-15># y = 1</line-15>
<line-16># return b</line-16>
<line-17># x1 = y1 = 0</line-17>
<line-18># gcd = gcdexten(b%a,a,x1,y1)</line-18>
<line-19></line-19>
<line-20># x = y1 - (b/a) * x1</line-20>
<line-21># y = x1</line-21>
<line-22># return gcd</line-22>
<line-23></line-23>
<line-24># def modin(a):</line-24>
<line-25># m = 10**9 + 7</line-25>
<line-26># x = y = 0</line-26>
<line-27># g = gcdexten(a,m,x,y)</line-27>
<line-28># res = (x%m + m)%m</line-28>
<line-29># return res</line-29>
<line-30></line-30>
<line-31># void modInverse(int a, int m)</line-31>
<line-32># {</line-32>
<line-33># int x, y;</line-33>
<line-34># int g = gcdExtended(a, m, &x, &y);</line-34>
<line-35># if (g != 1)</line-35>
<line-36># cout << "Inverse doesn't exist";</line-36>
<line-37># else</line-37>
<line-38># {</line-38>
<line-39># // m is added to handle negative x</line-39>
<line-40># int res = (x%m + m) % m;</line-40>
<line-41># cout << "Modular multiplicative inverse is " << res;</line-41>
<line-42># }</line-42>
<line-43># }</line-43>
<line-44># int gcdExtended(int a, int b, int *x, int *y)</line-44>
<line-45># {</line-45>
<line-46># // Base Case</line-46>
<line-47># if (a == 0)</line-47>
<line-48># {</line-48>
<line-49># *x = 0, *y = 1;</line-49>
<line-50># return b;</line-50>
<line-51># }</line-51>
<line-52> </line-52>
<line-53># int x1, y1; // To store results of recursive call</line-53>
<line-54># int gcd = gcdExtended(b%a, a, &x1, &y1);</line-54>
<line-55> </line-55>
<line-56># // Update x and y using results of recursive</line-56>
<line-57># // call</line-57>
<line-58># *x = y1 - (b/a) * x1;</line-58>
<line-59># *y = x1;</line-59>
<line-60> </line-60>
<line-61># return gcd;</line-61>
<line-62># }</line-62>
<line-63>def combi(a,b):</line-63>
<line-64> mod = 10**9 + 7</line-64>
<line-65> if a < b:</line-65>
<line-66> return 0</line-66>
<line-67> if a == 1:</line-67>
<line-68> return 1</line-68>
<line-69> if b < a/2:</line-69>
<line-70> b = a - b</line-70>
<line-71> temp = 1</line-71>
<line-72> for i in range(b + 1,a + 1):</line-72>
<line-73> temp = (temp * i%mod)%mod</line-73>
<line-74> denom = modin(math.factorial(a-b),mod)</line-74>
<line-75> # print denom</line-75>
<line-76> return (temp%mod * denom%mod)%mod</line-76>
<line-77>for _ in range(eval(input())):</line-77>
<line-78> mod = 10**9 + 7</line-78>
<line-79> string1 = input()</line-79>
<line-80> n = len(string1)</line-80>
<line-81> dict1 = {}</line-81>
<line-82> count = 0</line-82>
<line-83> alpha = set()</line-83>
<line-84> for ele in string1:</line-84>
<line-85> if ele in dict1:</line-85>
<line-86> dict1[ele] += 1</line-86>
<line-87> else:</line-87>
<line-88> dict1[ele] = 1</line-88>
<line-89> alpha.add(ele)</line-89>
<line-90> count += 1</line-90>
<line-91> </line-91>
<line-92> count_list = []</line-92>
<line-93> total = 1</line-93>
<line-94> rem = n</line-94>
<line-95> for ele in alpha:</line-95>
<line-96> total = (total % mod) * (combi(rem,dict1[ele]) % mod)%mod</line-96>
<line-97> rem -= dict1[ele]</line-97>
<line-98> count_list.append(dict1[ele])</line-98>
<line-99> </line-99>
<line-100> sum_list = [n - count_list[0]]</line-100>
<line-101> for i in range(1,count):</line-101>
<line-102> sum_list.append(sum_list[i - 1] - count_list[i])</line-102>
<line-103> </line-103>
<line-104> sub_2 = 0</line-104>
<line-105> sub = 0</line-105>
<line-106> for i in count_list:</line-106>
<line-107> sub_2 += (n - i) * i</line-107>
<line-108> sub_2 /= 2</line-108>
<line-109> # print sub_2</line-109>
<line-110> </line-110>
<line-111> sub_3 = 0</line-111>
<line-112> for i in range(count):</line-112>
<line-113> for j in range(i + 1,count):</line-113>
<line-114> sub_3 += count_list[i] * count_list[j] * sum_list[j]</line-114>
<line-115> </line-115>
<line-116> sub_3 = 2 * sub_3</line-116>
<line-117> </line-117>
<line-118> sub_4_4 = 0</line-118>
<line-119> for i in range(count):</line-119>
<line-120> for j in range(i + 1,count):</line-120>
<line-121> for k in range(j + 1,count):</line-121>
<line-122> sub_4_4 += count_list[i] * count_list[j] * count_list[k] * sum_list[k]</line-122>
<line-123> </line-123>
<line-124> sub_4_4 *= 3</line-124>
<line-125> sub_4_2 = 0</line-125>
<line-126> for i in range(count):</line-126>
<line-127> for j in range(i + 1,count):</line-127>
<line-128> sub_4_2 += (count_list[i] * (count_list[i] - 1) * count_list[j] * (count_list[j] - 1))/4</line-128>
<line-129> </line-129>
<line-130> sub_4_3 = 0</line-130>
<line-131> for i in range(count):</line-131>
<line-132> temp = 0</line-132>
<line-133> for j in range(count):</line-133>
<line-134> if j != i:</line-134>
<line-135> temp += count_list[j] * (n - count_list[i] - count_list[j])</line-135>
<line-136> temp /= 2</line-136>
<line-137> sub_4_3 += ((count_list[i] * (count_list[i] - 1)) * temp)/2</line-137>
<line-138> # print sub_4_3</line-138>
<line-139> sub_4_3 *= 2</line-139>
<line-140> # sub_4 = ((sub_4_2%mod + sub_4_3%mod) + sub_4_4%mod)%mod</line-140>
<line-141> # sub_tot = ((sub_2%mod + sub_3%mod)%mod + sub_4%mod)%mod</line-141>
<line-142> sub_4 = sub_4_3 + sub_4_4 + sub_4_2</line-142>
<line-143> sub_tot = sub_2 + sub_3 + sub_4</line-143>
<line-144></line-144>
<line-145> # print((total * (total - 1)) - (total * sub_tot%mod))%mod</line-145>
<line-147> print((total * (total - (sub_tot + 1)%mod)%mod)%mod)</line-147>
|
{"code": "<line-2>def egcd(a, b):</line-2>\n<line-146>\t# print ((total)* (total - 1 - (((sub_3 + sub_2)%mod + (sub_4_4 +sub_4_3)%mod)%mod + sub_4_2%mod)))% mod </line-146>", "lines": [2, 146]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-2></line-2>
<line-4> return int(a-b)</line-4>
<line-5></line-5>
<line-6>while t :</line-6>
<line-7> t=t-1</line-7>
<line-8> </line-8>
<line-9> lia=[]</line-9>
<line-10> lib=[]</line-10>
<line-11> lik=[]</line-11>
<line-12> lim=[]</line-12>
<line-13> liab=[]</line-13>
<line-14> likm=[]</line-14>
<line-15> n,k,m=list(map(int,input().split()))</line-15>
<line-16> </line-16>
<line-17> </line-17>
<line-18> lia=list(map(int,input().split()))</line-18>
<line-19> lib=list(map(int,input().split()))</line-19>
<line-20> lik=list(map(int,input().split()))</line-20>
<line-21> lim=list(map(int,input().split()))</line-21>
<line-22> liab=list(map(diffe,lia,lib)) </line-22>
<line-23> </line-23>
<line-24> likm=lik+lim</line-24>
<line-25> </line-25>
<line-26> </line-26>
<line-27> likm.sort()</line-27>
<line-28> </line-28>
<line-29> liab.sort()</line-29>
<line-30> liab.reverse()</line-30>
<line-31> </line-31>
<line-32> for i in range(0,len(liab)): </line-32>
<line-33> for j in range(len(likm)-1,0-1,-1):</line-33>
<line-34> a=likm.pop()</line-34>
<line-35> if (liab[i]-a)>=0:</line-35>
<line-36> liab[i]=liab[i]-a</line-36>
<line-37> </line-37>
<line-39> </line-39>
<line-40> </line-40>
<line-41> print(sum(liab)) </line-41>
<line-42></line-42>
|
{"code": "<line-3>def diffe(a,b):</line-3>\n<line-38> break</line-38>", "lines": [3, 38]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n=int(input())</line-3>
<line-4> cnt=1;</line-4>
<line-5> for i in range(n):</line-5>
<line-6> s=""</line-6>
<line-7> for j in range(n):</line-7>
<line-8> s=s+str(bin(cnt))[2:][: : -1]+" "</line-8>
<line-9> cnt=cnt+1</line-9>
<line-11> </line-11>
<line-12> t=t-1</line-12>
|
{"code": "<line-2>while(t):</line-2>\n<line-10> print(s)</line-10>", "lines": [2, 10]}
#### 0
|
<line-1></line-1>
<line-2>def solve(s, p):</line-2>
<line-4> for x, y in zip(s, p):</line-4>
<line-5> if x == y:</line-5>
<line-6> continue</line-6>
<line-7> if x == '0':</line-7>
<line-8> if diffs < 1:</line-8>
<line-9> return "No"</line-9>
<line-10> diffs -= 1</line-10>
<line-11> else:</line-11>
<line-12> diffs += 1</line-12>
<line-13> return "Yes" if diffs == 0 else "No"</line-13>
<line-14></line-14>
<line-15>for _ in range(int(input())):</line-15>
<line-16> l = int(input())</line-16>
<line-17> s = input().strip()</line-17>
<line-19> print(solve(s, p))</line-19>
|
{"code": "<line-3> diffs = 0</line-3>\n<line-18> p = input().strip()</line-18>", "lines": [3, 18]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>i=0</line-3>
<line-4>while i<t:</line-4>
<line-5> a=[]</line-5>
<line-6> a=input().split()</line-6>
<line-7> b=[]</line-7>
<line-8> b=input().split()</line-8>
<line-9> j=0</line-9>
<line-10> c=0</line-10>
<line-11> while j<4:</line-11>
<line-12> if a[j] in b:</line-12>
<line-13> c+=1</line-13>
<line-14> j+=1</line-14>
<line-15> if c>=2:</line-15>
<line-16> print("similar")</line-16>
<line-17> else:</line-17>
<line-19> i+=1</line-19>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-18> print(\"dissimilar\")</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>q=int(input())</line-3>
<line-4>while q>0:</line-4>
<line-5> i=1</line-5>
<line-6> tot=a[0]</line-6>
<line-7> b=list(map(int,input().split()))</line-7>
<line-8> if b[0]==1:</line-8>
<line-9> #p,f=map(int,raw_input().split())</line-9>
<line-10> a[b[1]-1]=b[2]</line-10>
<line-11> else:</line-11>
<line-12> #r=int(raw_input())</line-12>
<line-13> tot=a[0]</line-13>
<line-14> while 1+i*b[1]<=n:</line-14>
<line-15> tot=tot*a[i*b[1]]</line-15>
<line-16> i=i+1</line-16>
<line-17> m=(str)(tot)</line-17>
<line-18> tot=tot%1000000007</line-18>
<line-20> q=q-1</line-20>
|
{"code": "<line-2>a=list(map(int,input().split()))</line-2>\n<line-19> print((int)(m[0]),tot)</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>import sys</line-1>
<line-3>import bisect</line-3>
<line-4>from sys import stdin,stdout</line-4>
<line-5>from math import gcd,floor,sqrt,log</line-5>
<line-6>from collections import defaultdict as dd</line-6>
<line-7>from bisect import bisect_left as bl,bisect_right as br</line-7>
<line-8></line-8>
<line-9>sys.setrecursionlimit(100000000)</line-9>
<line-10></line-10>
<line-11>ii =lambda: int(input())</line-11>
<line-12>si =lambda: input()</line-12>
<line-13>jn =lambda x,l: x.join(map(str,l))</line-13>
<line-14>sl =lambda: list(map(str,input().strip()))</line-14>
<line-15>mi =lambda: map(int,input().split())</line-15>
<line-16>mif =lambda: map(float,input().split())</line-16>
<line-17>lii =lambda: list(map(int,input().split()))</line-17>
<line-18></line-18>
<line-19>ceil =lambda x: int(x) if(x==int(x)) else int(x)+1</line-19>
<line-20>ceildiv=lambda x,d: x//d if(x%d==0) else x//d+1</line-20>
<line-21></line-21>
<line-22>flush =lambda: stdout.flush()</line-22>
<line-23>stdstr =lambda: stdin.readline()</line-23>
<line-24>stdint =lambda: int(stdin.readline())</line-24>
<line-25>stdpr =lambda x: stdout.write(str(x))</line-25>
<line-26></line-26>
<line-27>mod=1000000007</line-27>
<line-28></line-28>
<line-29></line-29>
<line-30>#main code</line-30>
<line-31>for _ in range(ii()):</line-31>
<line-32> n=ii()</line-32>
<line-33> arr=lii()</line-33>
<line-34> arr.sort()</line-34>
<line-35> ma=arr[-1]*arr[-2]</line-35>
<line-37> print(ma,mi)</line-37>
|
{"code": "<line-2>import math</line-2>\n<line-36> mi=arr[0]*arr[1]</line-36>", "lines": [2, 36]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> try:</line-3>
<line-4> n=int(input())</line-4>
<line-5> lis=[]</line-5>
<line-6> for i in range(n):</line-6>
<line-7> k=list(map(int,input().split()))</line-7>
<line-8> k.append(k[1]+k[2])</line-8>
<line-9> lis.append(k)</line-9>
<line-10> </line-10>
<line-11> #print(lis)</line-11>
<line-12> p=sorted(lis,key=lambda x:x[3],reverse=True)</line-12>
<line-13> #print(p)</line-13>
<line-14> maxi=0</line-14>
<line-15> s=0</line-15>
<line-16> w=0</line-16>
<line-17> for i in range(n):</line-17>
<line-18> s+=p[i][0]</line-18>
<line-19> w=s+p[i][1]+p[i][2]</line-19>
<line-20> maxi=max(maxi,w)</line-20>
<line-21> </line-21>
<line-22> print(maxi)</line-22>
<line-23> </line-23>
<line-24> </line-24>
<line-26> break</line-26>
<line-27> </line-27>
|
{"code": "<line-2>while True:</line-2>\n<line-25> except:</line-25>", "lines": [2, 25]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>from math import log2;</line-3>
<line-4>import sys;</line-4>
<line-5></line-5>
<line-6>sys.setrecursionlimit(10 ** 7)</line-6>
<line-7>from collections import defaultdict</line-7>
<line-8></line-8>
<line-9>inf = float("inf")</line-9>
<line-10>def find_height(node):</line-10>
<line-11> nodes[node]=1</line-11>
<line-12> for i in graph[node]:</line-12>
<line-13> nodes[node]+=find_height(i)</line-13>
<line-14> return nodes[node]</line-14>
<line-15>def find_sum(node):</line-15>
<line-16> suma=nodes[node]</line-16>
<line-17> maxa=0</line-17>
<line-18> for i in graph[node]:</line-18>
<line-19> maxa=max(find_sum(i),maxa)</line-19>
<line-20> return maxa+suma</line-20>
<line-21>for i in range(int(input())):</line-21>
<line-22> n=int(input())</line-22>
<line-23> l=list(map(int,input().split()))</line-23>
<line-24> graph=defaultdict(set)</line-24>
<line-25> for i in range(len(l)):</line-25>
<line-26></line-26>
<line-27> graph[l[i]].add(i+2)</line-27>
<line-28> nodes=defaultdict(int)</line-28>
<line-29> find_height(1)</line-29>
<line-31> print(ans)</line-31>
<line-32></line-32>
<line-33></line-33>
<line-34></line-34>
|
{"code": "<line-2># cook your dish here</line-2>\n<line-30> ans=find_sum(1)</line-30>", "lines": [2, 30]}
#### 0
|
<line-2>for i in range(int(input())):</line-2>
<line-3> a,b = map(int,input().split())</line-3>
<line-4> print(math.gcd(a,b))</line-4>
|
{"code": "<line-1>import math</line-1>", "lines": [1]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>def main(arr,k):</line-4>
<line-5> </line-5>
<line-6> </line-6>
<line-7> x=[]</line-7>
<line-8> y=[]</line-8>
<line-9> </line-9>
<line-10> </line-10>
<line-11> </line-11>
<line-12> for e in arr:</line-12>
<line-13> if e%2==0:</line-13>
<line-14> x.append(e)</line-14>
<line-15> y.append(0)</line-15>
<line-16> else:</line-16>
<line-17> x.append(0)</line-17>
<line-18> y.append(e)</line-18>
<line-19> </line-19>
<line-20> a=[0]*n</line-20>
<line-21> b=[0]*n</line-21>
<line-22> a[0]=x[0]</line-22>
<line-23> b[0]=y[0]</line-23>
<line-24> for i in range(1,n):</line-24>
<line-25> </line-25>
<line-26> if i<k:</line-26>
<line-27> a[i]=max(x[i],a[i-1])</line-27>
<line-28> b[i]=max(y[i],b[i-1])</line-28>
<line-29> else:</line-29>
<line-30> a[i]=max(x[i]+a[i-k-1],a[i-1])</line-30>
<line-31> b[i]=max(y[i]+b[i-k-1],b[i-1])</line-31>
<line-32> </line-32>
<line-33> print(a[-1]+b[-1]) </line-33>
<line-34> return </line-34>
<line-35></line-35>
<line-36>for i in range(int(input())):</line-36>
<line-37> n,k=list(map(int,input().split()))</line-37>
<line-38> </line-38>
<line-40> </line-40>
<line-41> (main(arr,k))</line-41>
<line-42></line-42>
|
{"code": "<line-2>import math</line-2>\n<line-39> arr=list(map(int,input().split()))</line-39>", "lines": [2, 39]}
#### 0
|
<line-1>from operator import itemgetter</line-1>
<line-3>for i in range(t):</line-3>
<line-4> n=int(input())</line-4>
<line-5> m,f=list(map(int,input().split()))</line-5>
<line-6> x=list(map(int,input().split()))</line-6>
<line-7> my,fy=0,0</line-7>
<line-8> check=[0]*n</line-8>
<line-9> #print check</line-9>
<line-10> for j in range(n):</line-10>
<line-11> if x[j]>0 and x[j]%m==0 and check[j]==0:</line-11>
<line-12> check[j]=1</line-12>
<line-13> my+=1</line-13>
<line-14> #print check</line-14>
<line-15> for j in range(n):</line-15>
<line-16> if x[j]>0 and x[j]%f==0 and check[j]==0:</line-16>
<line-17> check[j]=1</line-17>
<line-18> fy+=1</line-18>
<line-19> if ((((my+fy)*1.0)/n)*100)>=70:</line-19>
<line-20> print("Yes")</line-20>
<line-21> if my>fy:</line-21>
<line-22> print("Multan")</line-22>
<line-23> elif fy>my:</line-23>
<line-24> print("Fultan")</line-24>
<line-25> else:</line-25>
<line-26> print("Both")</line-26>
<line-27> else:</line-27>
<line-29> #print check</line-29>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-28> print(\"No\") </line-28>", "lines": [2, 28]}
#### 0
|
<line-1></line-1>
<line-2></line-2>
<line-3></line-3>
<line-4>def powerset(s):</line-4>
<line-6> masks = [1 << j for j in range(n)]</line-6>
<line-7> for i in range(2**n):</line-7>
<line-8> yield [j + 1 for j in range(n) if (masks[j] & i)]</line-8>
<line-9></line-9>
<line-10></line-10>
<line-11>def is_power2(num):</line-11>
<line-12> return num != 0 and ((num & (num - 1)) == 0)</line-12>
<line-13></line-13>
<line-14></line-14>
<line-15>def special(l):</line-15>
<line-16> n = len(l)</line-16>
<line-17> for i in range(n):</line-17>
<line-18> lis = [i + 1]</line-18>
<line-19> yield lis</line-19>
<line-20> for j in range(i + 1, n):</line-20>
<line-21> p = l[j] / l[i]</line-21>
<line-22> if p <= 1 or int(p) != p:</line-22>
<line-23> continue</line-23>
<line-24> lis = [i + 1, j + 1]</line-24>
<line-25> yield lis</line-25>
<line-26> sk = (j + 1) * int(p)</line-26>
<line-27> while sk <= n:</line-27>
<line-28> lis.append(sk)</line-28>
<line-29> sk *= int(p)</line-29>
<line-30> yield lis</line-30>
<line-31></line-31>
<line-32></line-32>
<line-33>def expIndices(l):</line-33>
<line-34> a = list(zip(l, l[1:]))</line-34>
<line-35> if len(a) == 0:</line-35>
<line-36> return True</line-36>
<line-37> else:</line-37>
<line-38> p = a[0][1] / a[0][0]</line-38>
<line-39> if p <= 1 or int(p) != p:</line-39>
<line-40> return False</line-40>
<line-41> for i in range(1, len(a)):</line-41>
<line-42> if a[i][1] / a[i][0] != p:</line-42>
<line-43> return False</line-43>
<line-44> return True</line-44>
<line-45></line-45>
<line-46></line-46>
<line-47>def main():</line-47>
<line-48> for _ in range(eval(input())):</line-48>
<line-49> S = input()</line-49>
<line-50> count = 0</line-50>
<line-51></line-51>
<line-52> for i in special(range(1, len(S) + 1)):</line-52>
<line-53> s = [S[j - 1] for j in i]</line-53>
<line-54> if s == s[::-1]:</line-54>
<line-55> count += 1</line-55>
<line-56> print(count)</line-56>
<line-57></line-57>
<line-58>def __starting_point():</line-58>
<line-60></line-60>
<line-61>__starting_point()</line-61>
|
{"code": "<line-5> n = len(s)</line-5>\n<line-59> main()</line-59>", "lines": [5, 59]}
#### 0
|
<line-1>tests = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> permut='2'</line-4>
<line-5> permut_list=[]</line-5>
<line-6> if n%2==0:</line-6>
<line-7> for i in range(2, n+1):</line-7>
<line-8> if i%2==1:</line-8>
<line-9> permut=permut+' '+str(i+1)</line-9>
<line-10> else:</line-10>
<line-11> permut=permut+' '+str(i-1)</line-11>
<line-12> print(permut)</line-12>
<line-13> pass</line-13>
<line-14> elif n==1:</line-14>
<line-15> print(1)</line-15>
<line-16> pass</line-16>
<line-17> else:</line-17>
<line-18> for i in range(2, n):</line-18>
<line-19> if i%2==1:</line-19>
<line-20> permut_list.append(str(i+1))</line-20>
<line-21> else:</line-21>
<line-22> permut_list.append(str(i-1))</line-22>
<line-23> permut_list.pop(-1)</line-23>
<line-24> permut_list.append(str(n))</line-24>
<line-25> permut_list.append(str(n-2))</line-25>
<line-26> this_permut='2'</line-26>
<line-27> for el in permut_list:</line-27>
<line-29> print(this_permut)</line-29>
|
{"code": "<line-2>for t in range(tests):</line-2>\n<line-28> this_permut=this_permut+' '+el</line-28>", "lines": [2, 28]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>n_sep = list(map(int, input().split()))</line-3>
<line-4>count = 0</line-4>
<line-5>sep_sort = sorted(n_sep)</line-5>
<line-6>hashing = {sep_sort[0]: 0}</line-6>
<line-7></line-7>
<line-8>for j in range(1, n):</line-8>
<line-9> if (abs(sep_sort[j] - sep_sort[j - 1]) > k):</line-9>
<line-10> count += 1</line-10>
<line-11> hashing[sep_sort[j]] = count</line-11>
<line-12>#print(hashing)</line-12>
<line-13>for i in range(p):</line-13>
<line-14> pair = list(map(int, input().split()))</line-14>
<line-15> </line-15>
<line-16> if hashing[n_sep[pair[1] - 1]] == hashing[n_sep[pair[0] - 1]]:</line-16>
<line-17> print("Yes")</line-17>
<line-19> print("No")</line-19>
|
{"code": "<line-2>n, k, p = [int(i) for i in input().split()]</line-2>\n<line-18> else:</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>try:</line-1>
<line-3># Finally.... I properly understood what needs to be done.</line-3>
<line-4></line-4>
<line-5> def ctlt(arr, val):</line-5>
<line-6> # find number of values in sorted arr < val</line-6>
<line-7> if arr[0] >= val: return 0</line-7>
<line-8> lo = 0</line-8>
<line-9> hi = len(arr)</line-9>
<line-10> while hi-lo > 1:</line-10>
<line-11> md = (hi+lo)//2</line-11>
<line-12> if arr[md]<val:</line-12>
<line-13> lo = md</line-13>
<line-14> else:</line-14>
<line-15> hi = md</line-15>
<line-16></line-16>
<line-17> return hi</line-17>
<line-18></line-18>
<line-19> for _ in range(int(input())):</line-19>
<line-20> n,k,x,d = map(int, input().split())</line-20>
<line-21> z = input().strip().split()</line-21>
<line-22> if k > 0:</line-22>
<line-23> ps = list(map(int,z[:k]))</line-23>
<line-24> else:</line-24>
<line-25> ps = [x]</line-25>
<line-26></line-26>
<line-27> ps.sort()</line-27>
<line-28></line-28>
<line-29> if x<n or x<ps[-1] or n<k:</line-29>
<line-30> print(-1)</line-30>
<line-31> continue</line-31>
<line-32></line-32>
<line-33> valchecked = 0</line-33>
<line-34> fillval = 0</line-34>
<line-35> valsdone = False</line-35>
<line-36> isolbelow = True</line-36>
<line-37> lastp = ps[0]</line-37>
<line-38></line-38>
<line-39> while not valsdone and n>=k:</line-39>
<line-40> if n == k:</line-40>
<line-41> lo = x+d+1 # put out of range</line-41>
<line-42> else:</line-42>
<line-43> # find best maxfill (before val support)</line-43>
<line-44> lo = 1</line-44>
<line-45> hi = x+1</line-45>
<line-46> while hi-lo>1:</line-46>
<line-47> md = (hi+lo)//2</line-47>
<line-48> v = (x-md+1) + ctlt(ps,md)</line-48>
<line-49> if v<n:</line-49>
<line-50> hi = md</line-50>
<line-51> else:</line-51>
<line-52> lo = md</line-52>
<line-53> </line-53>
<line-54> valsdone = True</line-54>
<line-55> checkto = ctlt(ps,lo)-1</line-55>
<line-56> if checkto >= valchecked: </line-56>
<line-57> # support all vals</line-57>
<line-58> for p in ps[valchecked+1:checkto+1]:</line-58>
<line-59> if lastp+d >= p:</line-59>
<line-60> isolbelow = False</line-60>
<line-61> elif isolbelow:</line-61>
<line-62> valsdone = False</line-62>
<line-63> fillval += lastp+d</line-63>
<line-64> n -= 1</line-64>
<line-65> isolbelow = (p > lastp + 2*d )</line-65>
<line-66> else:</line-66>
<line-67> isolbelow = True</line-67>
<line-68> lastp = p</line-68>
<line-69> valchecked = checkto</line-69>
<line-70> if valsdone and isolbelow: </line-70>
<line-71> # check gap to maxfill</line-71>
<line-72> if lastp + d >= lo:</line-72>
<line-73> isolbelow = False</line-73>
<line-74> else:</line-74>
<line-75> valsdone = False</line-75>
<line-76> fillval += lastp</line-76>
<line-77> ps[checkto] += d</line-77>
<line-78> lastp += d</line-78>
<line-79> isolbelow = False</line-79>
<line-80> n -= 1</line-80>
<line-81></line-81>
<line-82> if k > n:</line-82>
<line-83> print(-1)</line-83>
<line-84> elif k == n:</line-84>
<line-85> print(sum(ps) + fillval)</line-85>
<line-86> elif k == n-1 and lo > ps[-1]:</line-86>
<line-87> print(sum(ps) + fillval + min(x,ps[-1]+d))</line-87>
<line-88> else:</line-88>
<line-89> tot = (x+lo)*(x-lo+1)//2 + sum(ps[:ctlt(ps,lo)])</line-89>
<line-90> print(tot + fillval)</line-90>
<line-92> pass</line-92>
|
{"code": "<line-2># https://www.codechef.com/LTIME63B/problems/GHMC</line-2>\n<line-91>except:</line-91>", "lines": [2, 91]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(t):</line-3>
<line-4> D=int(input())</line-4>
<line-5> P=10**5-2</line-5>
<line-6> ans=[]</line-6>
<line-7> if(D==0):</line-7>
<line-8> ans.append(1)</line-8>
<line-9> while(D>0):</line-9>
<line-10> P=min(P,D)</line-10>
<line-11> ans.append(P+2);</line-11>
<line-12> ans.append(P+1);</line-12>
<line-13> ans.append(1);</line-13>
<line-14> D=D-P;</line-14>
<line-16> print(*ans,sep=" ",end="\n")</line-16>
<line-17> </line-17>
<line-18> </line-18>
<line-19> </line-19>
<line-20> </line-20>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-15> print(len(ans))</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>import math</line-1>
<line-3>while t:</line-3>
<line-4> t=t-1</line-4>
<line-5> r1,h1,r2,h2=list(map(float,input().split()))</line-5>
<line-6> vol1=(math.pi*r1*r1*h1)/3 + (2*math.pi*r1*r1*r1)/3</line-6>
<line-8> print("%.8f %.8f" % (vol1,vol2))</line-8>
<line-9></line-9>
|
{"code": "<line-2>t=eval(input())</line-2>\n<line-7> vol2=math.pi*r2*r2*h2</line-7>", "lines": [2, 7]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(x):</line-3>
<line-5> print(int(s[::-1]))</line-5>
|
{"code": "<line-2>x=int(input())</line-2>\n<line-4> s=input()</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n=int(input())</line-3>
<line-4> N=list(map(int,input().split()))</line-4>
<line-5> N.sort()</line-5>
<line-6> </line-6>
<line-7> k=n-1</line-7>
<line-8> ave=N[k]</line-8>
<line-9> for j in range(n-1):</line-9>
<line-10> ave=(ave+N[k-1])/2</line-10>
<line-12> </line-12>
<line-13> print(ave)</line-13>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-11> k=k-1</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>T = int(user_input[0])</line-4>
<line-5></line-5>
<line-6>for j in range(T) :</line-6>
<line-7></line-7>
<line-8> var = sys.stdin.readline().split()</line-8>
<line-9> N = int(var[0])</line-9>
<line-10> M = int(var[1])</line-10>
<line-11></line-11>
<line-12> if (N%M)%2 :</line-12>
<line-13> print("ODD")</line-13>
<line-15> print("EVEN")</line-15>
|
{"code": "<line-2>user_input = sys.stdin.readline().split()</line-2>\n<line-14> else :</line-14>", "lines": [2, 14]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3></line-3>
<line-4>a0=0</line-4>
<line-5>a1=1</line-5>
<line-6>n,k=stdin.readline().strip().split(' ')</line-6>
<line-7>n,k=int(n),int(k)</line-7>
<line-8></line-8>
<line-9>arr=list(map(int,stdin.readline().strip().split(' ')))</line-9>
<line-10></line-10>
<line-11></line-11>
<line-12></line-12>
<line-13>def solve(n,k,arr):</line-13>
<line-14> sol=[]</line-14>
<line-15></line-15>
<line-16> l=0;u=k;</line-16>
<line-17></line-17>
<line-18></line-18>
<line-19> while l!=u:</line-19>
<line-20> sol.append(arr[l:min(len(arr),u)])</line-20>
<line-21> l=min(l+k,len(arr))</line-21>
<line-22> u=min(u+k,len(arr))</line-22>
<line-23> </line-23>
<line-24> tiwari=[]</line-24>
<line-25> for i in range(k):</line-25>
<line-26> titi=0</line-26>
<line-27> gao=0</line-27>
<line-28> for j in range(len(sol)):</line-28>
<line-29> if len(sol[j])>i:</line-29>
<line-30> if sol[j][i]==0:</line-30>
<line-31> titi+=1</line-31>
<line-32> else:</line-32>
<line-33> gao+=1</line-33>
<line-34> tiwari.append((titi,gao))</line-34>
<line-35></line-35>
<line-36> minflip=(-1,-1)</line-36>
<line-37> ans=0</line-37>
<line-38> ctr=0</line-38>
<line-39> for i in tiwari:</line-39>
<line-40> if i[0]<i[1]:</line-40>
<line-41> ans+=i[0]</line-41>
<line-42> ctr+=(1*a1+a0*a1)*a1</line-42>
<line-43> if i[1]<minflip[0] or minflip[0]==-1:</line-43>
<line-44> minflip=(i[1],i[0])</line-44>
<line-45> else:</line-45>
<line-46> ans+=i[1]</line-46>
<line-47> if i[0]<minflip[0] or minflip[0]==-1:</line-47>
<line-48> minflip=(i[0],i[1])</line-48>
<line-49> #print(ans,ctr)</line-49>
<line-50> #print(tiwari)</line-50>
<line-51> #print(minflip)</line-51>
<line-52> if ctr%2==0:</line-52>
<line-53> ans+=minflip[0]</line-53>
<line-54> ans-=minflip[1]</line-54>
<line-55></line-55>
<line-56></line-56>
<line-58></line-58>
<line-59>solve(n,k,arr)</line-59>
|
{"code": "<line-2>from sys import stdin,stdout</line-2>\n<line-57> stdout.write(str(ans)+\"\\n\")</line-57>", "lines": [2, 57]}
#### 0
|
<line-1>test = int(input())</line-1>
<line-3> flavor = int(input())</line-3>
<line-4> rate = input()</line-4>
<line-5> gaf = input()</line-5>
<line-6> gaf = gaf.split()</line-6>
<line-7> gaf = [int(x) for x in gaf]</line-7>
<line-8> rate = rate.split()</line-8>
<line-9> rate = [int(x) for x in rate]</line-9>
<line-10> rate.sort()</line-10>
<line-11> c = gaf[0] - gaf[1]</line-11>
<line-12> sum = rate[0]*c</line-12>
<line-13> t = True</line-13>
<line-14> if gaf[0] < gaf[1]:</line-14>
<line-15> t = False</line-15>
<line-16> j = 0</line-16>
<line-17> while(j<gaf[1] and t):</line-17>
<line-18> sum = sum + rate[j]</line-18>
<line-19> j = j + 1</line-19>
<line-20> if t :</line-20>
<line-21> print(sum)</line-21>
<line-23> print("Not Possible")</line-23>
|
{"code": "<line-2>for i in range(test):</line-2>\n<line-22> else:</line-22>", "lines": [2, 22]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>def vision(t):</line-3>
<line-4> a1=x0+(dx*t)-x1</line-4>
<line-5> a2=y0+(dy*t)-y1</line-5>
<line-6> a3=z0+(dz*t)-z1</line-6>
<line-7> b=4*((a1*d1)+(a2*d2)+(a3*d3))*((a1*d1)+(a2*d2)+(a3*d3))</line-7>
<line-8> a=4*((a1*a1)+(a2*a2)+(a3*a3))</line-8>
<line-9> value=(b-(a*c))</line-9>
<line-10> return value</line-10>
<line-11>xrange=range</line-11>
<line-12>for _ in range(int(input())):</line-12>
<line-13> x1,y1,z1,x0,y0,z0,dx,dy,dz,cx,cy,cz,r=list(map(int,input().split()))</line-13>
<line-14> d1=x1-cx</line-14>
<line-15> d2=y1-cy</line-15>
<line-16> d3=z1-cz</line-16>
<line-17> c=(d1*d1)+(d2*d2)+(d3*d3)-(r*r)</line-17>
<line-18> low=0</line-18>
<line-19> high=10**9+1</line-19>
<line-20> while low<(high-10**-6):</line-20>
<line-21> mid=low+(high-low)*1.0/2;</line-21>
<line-22> value=vision(mid);</line-22>
<line-23> if abs(value)<=epi:</line-23>
<line-24> break;</line-24>
<line-25> elif value>0:</line-25>
<line-26> low=mid;</line-26>
<line-27> else:</line-27>
<line-29> print(mid)</line-29>
<line-30> </line-30>
|
{"code": "<line-2>epi=10**-2</line-2>\n<line-28> high=mid;</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>import sys</line-1>
<line-3>import random</line-3>
<line-4>import math</line-4>
<line-5>#nonlocal defs</line-5>
<line-6>n, m, p = list(map(int, input().split()))</line-6>
<line-7>arr = [dict() for _ in range(n)]</line-7>
<line-8>for _ in range(p):</line-8>
<line-9> i,j = list(map(int,input().split()))</line-9>
<line-10> i -= 1</line-10>
<line-11> j -= 1</line-11>
<line-12> if j not in arr[i]:</line-12>
<line-13> arr[i][j] = j+1</line-13>
<line-14> else:</line-14>
<line-15> arr[i][j] += 1</line-15>
<line-16></line-16>
<line-17>def chefbm(arr,i):</line-17>
<line-18> for (e,f) in arr[i].items():</line-18>
<line-19> if e == m-1:</line-19>
<line-20> continue</line-20>
<line-21> if e+1 in arr[i]:</line-21>
<line-22> c = arr[i][e+1]</line-22>
<line-23> else:</line-23>
<line-24> c = e+1</line-24>
<line-25> if arr[i][e] > c:</line-25>
<line-26> return -1</line-26>
<line-27> y = arr[i][m-1] if m-1 in arr[i] else m-1</line-27>
<line-28> x = arr[i][0] if 0 in arr[i] else 0</line-28>
<line-29> return y-x</line-29>
<line-30></line-30>
<line-32> print(chefbm(arr,i))</line-32>
|
{"code": "<line-2>import os</line-2>\n<line-31>for i in range(n):</line-31>", "lines": [2, 31]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(a):</line-3>
<line-4> b = int(input())</line-4>
<line-5> li = []</line-5>
<line-6> if b == 2:</line-6>
<line-7> print(2,1)</line-7>
<line-8> elif b == 3:</line-8>
<line-9> print(3,2)</line-9>
<line-10> elif b == 4:</line-10>
<line-11> print(4,2)</line-11>
<line-12> else:</line-12>
<line-13> for t in range(b+1):</line-13>
<line-14> if ((b*t)+1-(2**t))<0:</line-14>
<line-15> li.append(t-1)</line-15>
<line-16> break</line-16>
<line-17> for o in range(b+1):</line-17>
<line-18> if b<=2**(o):</line-18>
<line-19> li.append(o)</line-19>
<line-21> print(*li)</line-21>
<line-22> </line-22>
|
{"code": "<line-2>a = int(input())</line-2>\n<line-20> break</line-20>", "lines": [2, 20]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.