question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1>for _ in range(int(input())):</line-1>
<line-3> a=list(map(int,input().split()))</line-3>
<line-4> x=int(input())</line-4>
<line-5> for _ in range(1,n,2):</line-5>
<line-6> a[_],a[_-1]=a[_-1],a[_]</line-6>
<line-7> for _ in range(n):</line-7>
<line-8> a[_]+=(a[_]%3)</line-8>
<line-9> # a=a[::-1]</line-9>
<line-10> # a.sort()</line-10>
<line-11> # if x>a[-1]:</line-11>
<line-12> # print(-1)</line-12>
<line-13> # continue</line-13>
<line-14> l,h=-1,9999999999</line-14>
<line-15> for _ in range(n):</line-15>
<line-16> # if a[_]>=x:</line-16>
<line-17> # if _==n-1:</line-17>
<line-18> # print(-1)</line-18>
<line-19> # break</line-19>
<line-20> # elif _==0:</line-20>
<line-21> # print(-1)</line-21>
<line-22> # break</line-22>
<line-23> # else:</line-23>
<line-24> # print(a[_-1],a[_])</line-24>
<line-25> # break</line-25>
<line-26> if a[_]>l and a[_]<x :</line-26>
<line-27> l=a[_]</line-27>
<line-28> if a[_]<h and a[_]>x :</line-28>
<line-29> h=a[_]</line-29>
<line-30> print(l,end=" ")</line-30>
<line-31> if h==9999999999:</line-31>
<line-32> print(-1)</line-32>
<line-34> print(h) </line-34>
<line-35> </line-35>
<line-36> </line-36>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-33> else: </line-33>", "lines": [2, 33]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(int(input())):</line-3>
<line-4> n=int(input())</line-4>
<line-5> a=list(map(int, input().split()))</line-5>
<line-6> b=list(map(int, input().split()))</line-6>
<line-7></line-7>
<line-8> if a[0]!=0 or b[-1]!=0 or a[-1]!=b[0]:</line-8>
<line-9> print('No')</line-9>
<line-10> </line-10>
<line-11> else:</line-11>
<line-12> ab=b[0]</line-12>
<line-13> flag=0</line-13>
<line-14> for i in range(1, n-1):</line-14>
<line-15> if a[i]==0 or b[i]==0:</line-15>
<line-16> print('No')</line-16>
<line-17> flag=1 </line-17>
<line-18> break</line-18>
<line-19> </line-19>
<line-20> elif a[i]+b[i]<ab:</line-20>
<line-21> print('No')</line-21>
<line-22> flag=1 </line-22>
<line-23> break</line-23>
<line-24> </line-24>
<line-25> elif a[i]>ab+b[i] or b[i]>ab+a[i]:</line-25>
<line-26> print('No')</line-26>
<line-27> flag=1 </line-27>
<line-28> break</line-28>
<line-29> </line-29>
<line-31> print('Yes')</line-31>
|
{"code": "<line-2># cook your dish here</line-2>\n<line-30> if flag==0:</line-30>", "lines": [2, 30]}
#### 0
|
<line-1>def search(arr, lenl, val):</line-1>
<line-3> l = lenl - 1</line-3>
<line-4></line-4>
<line-5> total = 0</line-5>
<line-6></line-6>
<line-7> while (s <= l):</line-7>
<line-8> m = int((s + l) / 2)</line-8>
<line-9></line-9>
<line-10> if (arr[m] <= val):</line-10>
<line-11> total = m + 1</line-11>
<line-12> s = m + 1</line-12>
<line-13></line-13>
<line-14> else:</line-14>
<line-15> l = m - 1</line-15>
<line-16></line-16>
<line-17> return total</line-17>
<line-18></line-18>
<line-19></line-19>
<line-20>def kmpsearch(string, lps):</line-20>
<line-21> lis = []</line-21>
<line-22> lens = len(string)</line-22>
<line-23> lensh = lens // 2</line-23>
<line-24></line-24>
<line-25> l = 0</line-25>
<line-26> i = 0</line-26>
<line-27> while i < lens:</line-27>
<line-28> if string[i] == pat[l]:</line-28>
<line-29> l += 1</line-29>
<line-30> i += 1</line-30>
<line-31> elif l > 0:</line-31>
<line-32> l = lps[l - 1]</line-32>
<line-33> else:</line-33>
<line-34> i += 1</line-34>
<line-35></line-35>
<line-36> if l == lenp:</line-36>
<line-37> if i - l < lensh:</line-37>
<line-38> lis.append(i - l)</line-38>
<line-39></line-39>
<line-40> l = lps[l - 1]</line-40>
<line-41></line-41>
<line-42> return lis</line-42>
<line-43></line-43>
<line-44></line-44>
<line-45>def kmp(pat, lenp):</line-45>
<line-46></line-46>
<line-47> lps = [0]*(lenp)</line-47>
<line-48> l = 0</line-48>
<line-49> i = 1</line-49>
<line-50></line-50>
<line-51> while i < lenp:</line-51>
<line-52> if pat[i] == pat[l]:</line-52>
<line-53> l += 1</line-53>
<line-54> lps[i] = l</line-54>
<line-55> i += 1</line-55>
<line-56> elif l > 0:</line-56>
<line-57> l = lps[l-1]</line-57>
<line-58> else:</line-58>
<line-59> lps[i] = 0</line-59>
<line-60> i += 1</line-60>
<line-61></line-61>
<line-62> return lps</line-62>
<line-63></line-63>
<line-64></line-64>
<line-65></line-65>
<line-66>keyword = input()</line-66>
<line-67>pat = input()</line-67>
<line-68>q = int(input())</line-68>
<line-69></line-69>
<line-70>lenk = len(keyword)</line-70>
<line-71>lenp = len(pat)</line-71>
<line-72></line-72>
<line-73>k = keyword * 2</line-73>
<line-74>lis = kmpsearch(k, kmp(pat, lenp))</line-74>
<line-75>lenl = len(lis)</line-75>
<line-76></line-76>
<line-77>for _ in range(q):</line-77>
<line-78> n = int(input())</line-78>
<line-79> count = 0</line-79>
<line-80></line-80>
<line-81> q = n // lenk</line-81>
<line-82> r = n % lenk</line-82>
<line-83></line-83>
<line-84> count += search(lis, lenl, r - lenp)</line-84>
<line-85></line-85>
<line-86> if q >= 1:</line-86>
<line-87> count += search(lis, lenl, lenk + r - lenp)</line-87>
<line-88></line-88>
<line-89> if q >= 2:</line-89>
<line-91></line-91>
<line-92> print(count)</line-92>
<line-93> </line-93>
|
{"code": "<line-2> s = 0</line-2>\n<line-90> count += (q - 1)*lenl</line-90>", "lines": [2, 90]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> if num%1==0:</line-3>
<line-4> return int(num//1)</line-4>
<line-5> else:</line-5>
<line-6> return int((num//1)+1)</line-6>
<line-7> </line-7>
<line-8>for _ in range(int(input())):</line-8>
<line-9> n=int(input())</line-9>
<line-10> s=input()</line-10>
<line-11> p=0</line-11>
<line-12> a=[]</line-12>
<line-13> for i in range(n):</line-13>
<line-14> if s[i]=="P":</line-14>
<line-15> p=p+1</line-15>
<line-16> req=ceil(0.75*n)</line-16>
<line-17> requirement=req-p</line-17>
<line-18> for i in range(2,n-2):</line-18>
<line-19> if s[i]=="A":</line-19>
<line-20> if (s[i-1]=="P" or s[i-2]=="P") and (s[i+1]=="P" or s[i+2]=="P"):</line-20>
<line-21> a.append(i)</line-21>
<line-22> if requirement>len(a):</line-22>
<line-23> print(-1)</line-23>
<line-25> print(max(requirement,0))</line-25>
|
{"code": "<line-2>def ceil(num):</line-2>\n<line-24> else:</line-24>", "lines": [2, 24]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>while t:</line-3>
<line-4> n=int(input())</line-4>
<line-5> r1=input()</line-5>
<line-6> r2=input()</line-6>
<line-7> r1count=0</line-7>
<line-8> r2count=0</line-8>
<line-9> count=0</line-9>
<line-10> for i in range(n):</line-10>
<line-11> if(r1[i]=="*"):</line-11>
<line-12> r1count+=1</line-12>
<line-13> if(r2[i]=="*"):</line-13>
<line-14> r2count+=1</line-14>
<line-15> if(r1count>0) and (r2count>0):</line-15>
<line-16> count=1</line-16>
<line-17> r1count=0</line-17>
<line-18> r2count=0</line-18>
<line-19> i=0</line-19>
<line-20> while(i<n):</line-20>
<line-21> if(r1[i]=="*"):</line-21>
<line-22> r1count+=1</line-22>
<line-23> if(r2[i]=="*"):</line-23>
<line-24> r2count+=1</line-24>
<line-25> if(r1count>1) or (r2count>1):</line-25>
<line-26> count+=1</line-26>
<line-27> r1count=0</line-27>
<line-28> r2count=0</line-28>
<line-29> i-=1</line-29>
<line-30> i+=1</line-30>
<line-31> elif(r1count==0 and r2count>0) or (r2count==0 and r1count>0):</line-31>
<line-32> count=max(r1count,r2count)-1</line-32>
<line-33> else:</line-33>
<line-34> count=0</line-34>
<line-36> t-=1</line-36>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-35> print(count)</line-35>", "lines": [2, 35]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>from math import gcd,sqrt,floor,factorial,ceil</line-3>
<line-4>from bisect import bisect_left,bisect_right</line-4>
<line-5>import bisect;</line-5>
<line-6>import sys;</line-6>
<line-7>from sys import stdin,stdout</line-7>
<line-8>import os</line-8>
<line-9>sys.setrecursionlimit(pow(10,7))</line-9>
<line-10>import collections</line-10>
<line-11>from collections import defaultdict,Counter</line-11>
<line-12>from statistics import median</line-12>
<line-13># input=stdin.readline</line-13>
<line-14># print=stdout.write</line-14>
<line-15>from queue import Queue</line-15>
<line-16>inf = float("inf")</line-16>
<line-17>from operator import neg;</line-17>
<line-18>n,m=map(int,input().split())</line-18>
<line-19>for i in range(m):</line-19>
<line-21> print(max(0,min(k-n-1,3*n+1-k)))</line-21>
|
{"code": "<line-2>import math;</line-2>\n<line-20> k=int(input())</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>from sys import setrecursionlimit</line-1>
<line-3></line-3>
<line-4>def solve(i):</line-4>
<line-5> if i + k >= n:</line-5>
<line-6> return 1</line-6>
<line-7></line-7>
<line-8> if i in dp:</line-8>
<line-9> return dp[i]</line-9>
<line-10></line-10>
<line-11> mini = float('inf')</line-11>
<line-12> for j in range(i+1, min(n, i+k+1)):</line-12>
<line-13> if i == -1 or a[i] == a[j]:</line-13>
<line-14> mini = min(mini, solve(j) + 1)</line-14>
<line-15></line-15>
<line-16> dp[i] = mini</line-16>
<line-17> return dp[i]</line-17>
<line-18></line-18>
<line-19></line-19>
<line-20>for _ in range(int(input())):</line-20>
<line-21> n, k = map(int, input().split())</line-21>
<line-22> a = list(map(lambda x: int(x) % 2, input().split()))</line-22>
<line-23></line-23>
<line-24> le = lo = -1</line-24>
<line-25> se = so = -1</line-25>
<line-26></line-26>
<line-27> for i in range(n-k, n):</line-27>
<line-28> if a[i] == 0:</line-28>
<line-29> le = i</line-29>
<line-30> break</line-30>
<line-31></line-31>
<line-32> for i in range(n-k, n):</line-32>
<line-33> if a[i] == 1:</line-33>
<line-34> lo = i</line-34>
<line-35> break</line-35>
<line-36></line-36>
<line-37> m1 = float('inf')</line-37>
<line-38> if le != -1:</line-38>
<line-39> m1 = 0</line-39>
<line-40> while True:</line-40>
<line-41> lle = -1</line-41>
<line-42></line-42>
<line-43> for i in range(se + 1, se + k + 1):</line-43>
<line-44> if i == le:</line-44>
<line-45> m1 += 2</line-45>
<line-46> break</line-46>
<line-47></line-47>
<line-48> if a[i] == 0:</line-48>
<line-49> lle = i</line-49>
<line-50></line-50>
<line-51> else:</line-51>
<line-52> if lle == -1:</line-52>
<line-53> m1 = float('inf')</line-53>
<line-54> break</line-54>
<line-55></line-55>
<line-56> se = lle</line-56>
<line-57> m1 += 1</line-57>
<line-58> continue</line-58>
<line-59></line-59>
<line-60> break</line-60>
<line-61></line-61>
<line-62> m2 = float('inf')</line-62>
<line-63> if lo != -1:</line-63>
<line-64> m2 = 0</line-64>
<line-65> while True:</line-65>
<line-66> llo = -1</line-66>
<line-67></line-67>
<line-68> for i in range(so + 1, so + k + 1):</line-68>
<line-69> if i == lo:</line-69>
<line-70> m2 += 2</line-70>
<line-71> break</line-71>
<line-72></line-72>
<line-73> if a[i] == 1:</line-73>
<line-74> llo = i</line-74>
<line-75></line-75>
<line-76> else:</line-76>
<line-77> if llo == -1:</line-77>
<line-78> m2 = float('inf')</line-78>
<line-79> break</line-79>
<line-80></line-80>
<line-81> so = llo</line-81>
<line-82> m2 += 1</line-82>
<line-83> continue</line-83>
<line-84></line-84>
<line-85> break</line-85>
<line-86></line-86>
<line-87> if min(m1, m2) != float('inf'):</line-87>
<line-88> print(min(m1, m2))</line-88>
<line-90> print(-1)</line-90>
|
{"code": "<line-2>setrecursionlimit(10 * 9)</line-2>\n<line-89> else:</line-89>", "lines": [2, 89]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>try:long</line-3>
<line-4>except NameError:long = int </line-4>
<line-5>def fac(n):</line-5>
<line-6> step,maxq,d = lambda x: 1 + (x<<2) - ((x>>1)<<1),long(floor(sqrt(n))),1</line-6>
<line-7> q = n % 2 == 0 and 2 or 3 </line-7>
<line-8> while q <= maxq and n % q != 0:</line-8>
<line-9> q = step(d)</line-9>
<line-10> d += 1</line-10>
<line-11> return q <= maxq and [q] + fac(n//q) or [n]</line-11>
<line-12>n,k,s = map(int,input().split())</line-12>
<line-13>a,di,l,m,ans,su =list(map(int,input().split())),{},[],0,0,0</line-13>
<line-14>for i in a:</line-14>
<line-15> bb,su = list(set(fac(i))),su+i</line-15>
<line-16> for j in bb:</line-16>
<line-17> try:di[j]+=1</line-17>
<line-18> except KeyError:m,di[j] = m+1,1</line-18>
<line-19> l.append(su*(k-m*s))</line-19>
<line-21>print(max(l))</line-21>
|
{"code": "<line-2>from math import floor, sqrt</line-2>\n<line-20> if su*(k-m*s) <0:m,di,su = 0,{},0</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>import random</line-1>
<line-3>for testCase in range(t):</line-3>
<line-4> n=int(input())</line-4>
<line-5> array1=[]</line-5>
<line-6> array2=[]</line-6>
<line-7> array=[]</line-7>
<line-8> for i in range(n) :</line-8>
<line-9> array1.append(list(map(int,input().split())))</line-9>
<line-10> for i in range(n) :</line-10>
<line-11> array2.append(list(map(int,input().split())))</line-11>
<line-12> for i in range(n) :</line-12>
<line-13> array.append(i)</line-13>
<line-14># print array2," ",array1</line-14>
<line-15> for i in range(n) :</line-15>
<line-16> print(array[i]+1, end=' ') </line-16>
<line-17> print() </line-17>
<line-18> k=0</line-18>
<line-19> max=0</line-19>
<line-20> answer=[]</line-20>
<line-21> temp=[]</line-21>
<line-22> while k < (1<<5) :</line-22>
<line-23> k+=1 </line-23>
<line-24> for i in range(n) :</line-24>
<line-25> rand=random.randint(0,len(array)-1)</line-25>
<line-26> temp.append(array[rand])</line-26>
<line-27> array.pop(rand)</line-27>
<line-28> array = temp</line-28>
<line-29> count=0</line-29>
<line-30> for i in range(n) :</line-30>
<line-31> for j in range(n) :</line-31>
<line-32> if(array1[i][j] and array2[array[i]][array[j]]) :</line-32>
<line-33> count+=1</line-33>
<line-34> if(count > max):</line-34>
<line-35> answer=array</line-35>
<line-36> max=count</line-36>
<line-37> #print max,count</line-37>
<line-38> for x in answer :</line-38>
<line-40> print()</line-40>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-39>\t\tprint(x+1, end=' ')</line-39>", "lines": [2, 39]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>dp=[0]*n </line-3>
<line-4>dp[0]=ar[0]</line-4>
<line-5>dp[1]=ar[1]</line-5>
<line-6>for i in range(2,n):</line-6>
<line-7> dp[i]=min(dp[i-2],dp[i-1])+ar[i]</line-7>
<line-8> </line-8>
<line-9>ar.reverse()</line-9>
<line-10>#print(ar)</line-10>
<line-11>dp1=[0]*n </line-11>
<line-12>dp1[0]=ar[0]</line-12>
<line-13>dp1[1]=ar[1]</line-13>
<line-14>for i in range(2,n):</line-14>
<line-16>print(min(dp[-1],dp1[-1]))</line-16>
|
{"code": "<line-2>ar=list(map(int,input().split()))</line-2>\n<line-15> dp1[i]=min(dp1[i-2],dp1[i-1])+ar[i]</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>for tc in range(int(input())):</line-1>
<line-3> a, b = list(map(int, input().split()))</line-3>
<line-4> pr = []</line-4>
<line-5></line-5>
<line-6> # 'L' is lexicographically lower than 'R'.</line-6>
<line-7> # so, we should first try to apply L+ or L-</line-7>
<line-8> # if we can't then only we'll try to apply R+ or R-</line-8>
<line-9></line-9>
<line-10> for i in range(N - 1):</line-10>
<line-11> l, r = list(map(int, input().split()))</line-11>
<line-12></line-12>
<line-13> #continue the following process until a == l and b == r</line-13>
<line-14> while a != l or b != r:</line-14>
<line-15> # trying to apply L-</line-15>
<line-16> if a > l:</line-16>
<line-17> a -= 1</line-17>
<line-18> pr.append('L-')</line-18>
<line-19></line-19>
<line-20> # now, trying to apply L+ (if a < b)</line-20>
<line-21> elif a + 1 < b and a < l:</line-21>
<line-22> a += 1</line-22>
<line-23> pr.append('L+')</line-23>
<line-24></line-24>
<line-25> # ok, so far, so good... now, let's try to apply R+</line-25>
<line-26> elif b < r:</line-26>
<line-27> b += 1</line-27>
<line-28> pr.append('R+')</line-28>
<line-29></line-29>
<line-30> # finally, lastly, trying to apply R- (if a < b)</line-30>
<line-31> elif b - 1 > a and b > r:</line-31>
<line-32> b -= 1</line-32>
<line-33> pr.append('R-')</line-33>
<line-34></line-34>
<line-36> print(''.join(pr))</line-36>
|
{"code": "<line-2> N = int(input())</line-2>\n<line-35> print(len(pr))</line-35>", "lines": [2, 35]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>MOD = 10 ** 9 + 7</line-3>
<line-4> </line-4>
<line-5>for t in range(int(input())):</line-5>
<line-6> N, M, K = map(int, input().split())</line-6>
<line-7> A = list(map(int, input().split()))</line-7>
<line-8> I, D = [0] * (N + 2), [0] * (N + 2)</line-8>
<line-9> for i in range(M):</line-9>
<line-10> x, L, R = input().split()</line-10>
<line-11> L, R = int(L), int(R)</line-11>
<line-12> if x == 'I':</line-12>
<line-13> I[L] += 1</line-13>
<line-14> I[R] -= 1</line-14>
<line-15> else:</line-15>
<line-16> D[L] += 1</line-16>
<line-17> D[R] -= 1</line-17>
<line-18> </line-18>
<line-19> impossibru = mx = mn = 0</line-19>
<line-20> ans = 1</line-20>
<line-21> for i in range(N):</line-21>
<line-22> I[i] += I[i - 1]</line-22>
<line-23> D[i] += D[i - 1]</line-23>
<line-24> if I[i] and D[i]:</line-24>
<line-25> impossibru = 1</line-25>
<line-26> break</line-26>
<line-27> if not I[i] and not D[i]:</line-27>
<line-28> ans = ans * (mx - mn + 1) % MOD</line-28>
<line-29> mn, mx = 1, K</line-29>
<line-30> elif I[i]:</line-30>
<line-31> mx = min(mx + 1, K)</line-31>
<line-32> mn += 1</line-32>
<line-33> elif D[i]:</line-33>
<line-34> mn = max(1, mn - 1)</line-34>
<line-35> mx -= 1</line-35>
<line-36> if mn > mx:</line-36>
<line-37> impossibru = 1</line-37>
<line-38> break</line-38>
<line-39> if A[i] != -1:</line-39>
<line-40> if not mn <= A[i] <= mx:</line-40>
<line-41> impossibru = 1</line-41>
<line-42> break</line-42>
<line-43> mn = mx = A[i]</line-43>
<line-45> </line-45>
<line-46> print(0 if impossibru else ans) </line-46>
|
{"code": "<line-2># cook your dish here</line-2>\n<line-44> ans = ans * (mx - mn + 1) % MOD</line-44>", "lines": [2, 44]}
#### 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> m,n = map(int,input().rstrip().split())</line-5>
<line-6> cnt = len(str(n))</line-6>
<line-7> x = pow(10,cnt)</line-7>
<line-8> if n == x-1:</line-8>
<line-9> print(m*cnt,m)</line-9>
<line-11> print(m*(cnt-1),m)</line-11>
|
{"code": "<line-2>from math import pow</line-2>\n<line-10> else:</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>from math import ceil</line-1>
<line-2></line-2>
<line-4> n = int(input())</line-4>
<line-5> arr = [int(x) for x in input().split()]</line-5>
<line-6> sarr = sum(arr)</line-6>
<line-7> mavg = sarr/n</line-7>
<line-8> while n>1:</line-8>
<line-9> sarr -= arr.pop()</line-9>
<line-10> n-=1</line-10>
<line-12> print(int(ceil(mavg)))</line-12>
|
{"code": "<line-3>for _ in range(int(input())):</line-3>\n<line-11> mavg = max(mavg, sarr/n)</line-11>", "lines": [3, 11]}
#### 0
|
<line-1>import math</line-1>
<line-3>for i in range(t):</line-3>
<line-4> k=int(input())</line-4>
<line-6> print(res)</line-6>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-5> res=((pow(2,k,1000000007))*5)%1000000007</line-5>", "lines": [2, 5]}
#### 0
|
<line-1># Md. Khairullah Gaurab</line-1>
<line-3># gaurab.cse.sust@gmail.com</line-3>
<line-4></line-4>
<line-5></line-5>
<line-6>test = int(input());</line-6>
<line-7></line-7>
<line-8>for i in range(test):</line-8>
<line-9> N, S, K = list(map(int,input().split()));</line-9>
<line-10> lis = list(map(int,input().split()));</line-10>
<line-11> ans = [i+1 for i in range(N)] ;</line-11>
<line-12> ans.sort(reverse=True);</line-12>
<line-13> for j in range(N):</line-13>
<line-15> print('')</line-15>
|
{"code": "<line-2># SUST, CSE, 20th Batch</line-2>\n<line-14> print(ans[j],end=' ');</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>for u in range(int(input())):</line-1>
<line-3> n=int(p[0])</line-3>
<line-4> s=p[1]</line-4>
<line-5> x,y=0,0</line-5>
<line-6> for i in range(n):</line-6>
<line-7> l=input()</line-7>
<line-8> if(l[0]=='1'):</line-8>
<line-9> y+=l.count('1')</line-9>
<line-10> else:</line-10>
<line-11> x+=l.count('0')</line-11>
<line-12> if(x<y):</line-12>
<line-13> print("Dum")</line-13>
<line-14> elif(y<x):</line-14>
<line-15> print("Dee")</line-15>
<line-16> else:</line-16>
<line-17> if(s=='Dee'):</line-17>
<line-18> print("Dum")</line-18>
<line-20> print("Dee")</line-20>
|
{"code": "<line-2> p=input().split()</line-2>\n<line-19> else:</line-19>", "lines": [2, 19]}
#### 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> p = [int(x) for x in input().split()]</line-5>
<line-6> q = [int(x) for x in input().split()]</line-6>
<line-7> </line-7>
<line-8> q[1] *= -1</line-8>
<line-9> m = (q[1]-p[1])/(q[0]-p[0])</line-9>
<line-10> c = p[1] - m*p[0]</line-10>
<line-11> </line-11>
<line-12> print("{:.2f}".format(-c/m))</line-12>
<line-14> pass</line-14>
|
{"code": "<line-2>try:</line-2>\n<line-13>except:</line-13>", "lines": [2, 13]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(int(input())):</line-3>
<line-4> </line-4>
<line-5> n,x=list(map(int,input().split()))</line-5>
<line-6> </line-6>
<line-7> l=list(map(int,input().split()))</line-7>
<line-8> battery=[]</line-8>
<line-9> </line-9>
<line-10> power=0</line-10>
<line-11> i=0</line-11>
<line-12> t=(n+1)//2</line-12>
<line-13> while power<x and i<t:</line-13>
<line-14> </line-14>
<line-15> if i==n-i-1:</line-15>
<line-16> temp=[-1,l[i]]</line-16>
<line-17> else:</line-17>
<line-18> temp=sorted([ l[i], l[n-i-1] ])</line-18>
<line-19> </line-19>
<line-20> power+=temp[1]</line-20>
<line-21> pos=bisect.bisect_right(battery, temp[1], lo=0, hi=len(battery))</line-21>
<line-22> battery.insert(pos,temp[1])</line-22>
<line-23> </line-23>
<line-24> if temp[0]>battery[0]:</line-24>
<line-25> </line-25>
<line-26> power-=battery.pop(0)</line-26>
<line-27> power+=temp[0]</line-27>
<line-28> pos=bisect.bisect_right(battery, temp[0], lo=0, hi=len(battery))</line-28>
<line-29> battery.insert(pos,temp[0])</line-29>
<line-30> </line-30>
<line-31> i+=1</line-31>
<line-32> </line-32>
<line-33> </line-33>
<line-34> if power>=x:</line-34>
<line-35> print('YES')</line-35>
<line-37> print('NO')</line-37>
|
{"code": "<line-2>import bisect</line-2>\n<line-36> else:</line-36>", "lines": [2, 36]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>for i in range(1,n+1):</line-3>
<line-4> arr.append(i)</line-4>
<line-5>c=0</line-5>
<line-6>i=0</line-6>
<line-7>f=0;</line-7>
<line-8>while(c<n-1):</line-8>
<line-9> if(arr[i%n]!=-1 and f):</line-9>
<line-10> arr[i%n]=-1</line-10>
<line-11> c=c+1</line-11>
<line-12> f=0</line-12>
<line-13> if(arr[i%n]!=-1):</line-13>
<line-14> f=1</line-14>
<line-15> i=i+1</line-15>
<line-16></line-16>
<line-17>for i in range(0,n):</line-17>
<line-18> if(arr[i]!=-1):</line-18>
<line-19> ans=arr[i]</line-19>
<line-21>print(ans) </line-21>
|
{"code": "<line-2>arr=[]</line-2>\n<line-20> break;</line-20>", "lines": [2, 20]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>import bisect</line-5>
<line-6>for _ in range(int(input())):</line-6>
<line-7> n = int(input())</line-7>
<line-8> x1 , x2, x3 = [], [], []</line-8>
<line-9> for i in range(n):</line-9>
<line-10> x, y = list(map(int, input().split()))</line-10>
<line-11></line-11>
<line-12> if x == 1: x1.append(y)</line-12>
<line-13> if x == 2: x2.append(y)</line-13>
<line-14> if x == 3: x3.append(y)</line-14>
<line-15></line-15>
<line-16> x1.sort()</line-16>
<line-17> x2.sort()</line-17>
<line-18> x3.sort()</line-18>
<line-19></line-19>
<line-20> y1, y2, y3 = len(x1), len(x2), len(x3)</line-20>
<line-21> area = 0</line-21>
<line-22> for i in range(y1):</line-22>
<line-23> for j in range(i+1, y1):</line-23>
<line-24> area += abs(x1[i] - x1[j])*(y2 + (2*y3))</line-24>
<line-25></line-25>
<line-26> for i in range(y3):</line-26>
<line-27> for j in range(i+1, y3):</line-27>
<line-28> area += abs(x3[i] - x3[j])*(y2 + (2*y1))</line-28>
<line-29></line-29>
<line-30> for i in range(y2):</line-30>
<line-31> for j in range(i+1, y2):</line-31>
<line-32> area += abs(x2[i] - x2[j])*(y1 + y3)</line-32>
<line-33></line-33>
<line-34> area /= 2</line-34>
<line-35></line-35>
<line-36> s1 = [0]</line-36>
<line-37> for i in range(y2): s1.append(s1[-1] + x2[i])</line-37>
<line-38> # print(s1)</line-38>
<line-39> s2 = [0]</line-39>
<line-40> for i in range(y2):s2.append(s2[-1] + x2[y2 - 1 - i])</line-40>
<line-41> # print(s2)</line-41>
<line-42></line-42>
<line-43> for i in x1:</line-43>
<line-44> for j in x3:</line-44>
<line-45> p1 = (i + j) / 2</line-45>
<line-46> p = bisect.bisect_left(x2, p1)</line-46>
<line-47> # print('p', p)</line-47>
<line-48> l = p</line-48>
<line-49> h = y2 - l</line-49>
<line-50> # print(l, h)</line-50>
<line-51></line-51>
<line-52> area += p1*(l) - s1[l]</line-52>
<line-53> # print('dfg', area)</line-53>
<line-54> area += s2[h] - p1*(h)</line-54>
<line-55></line-55>
<line-57> # print()</line-57>
|
{"code": "<line-2># Author: Dancing Monkey | Created: 09.DEC.2018</line-2>\n<line-56> print(format(area, 'f'))</line-56>", "lines": [2, 56]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(t):</line-3>
<line-4> n=int(input())</line-4>
<line-5> s=input().strip()</line-5>
<line-6> c=0</line-6>
<line-7> for i in range(len(s)):</line-7>
<line-8> if s[i]=='.':</line-8>
<line-9> continue</line-9>
<line-10> if s[i]=='H':</line-10>
<line-11> c+=1</line-11>
<line-12> if s[i]=='T':</line-12>
<line-13> c-=1</line-13>
<line-14> if c>1:</line-14>
<line-15> break</line-15>
<line-16> if c<0:</line-16>
<line-17> break</line-17>
<line-18> if c==0:</line-18>
<line-19> print('Valid')</line-19>
<line-21> print('Invalid')</line-21>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-20> else:</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>t = eval(input())</line-1>
<line-2></line-2>
<line-4> h = 1</line-4>
<line-5> triange = []</line-5>
<line-6> while m >= h:</line-6>
<line-7> triange.append(h)</line-7>
<line-8> m -= h </line-8>
<line-9> h += 1</line-9>
<line-10> return len(triange)</line-10>
<line-11></line-11>
<line-12>triangulo = []</line-12>
<line-13>for i in range(t):</line-13>
<line-14> n = eval(input())</line-14>
<line-15> triangulo.append(n)</line-15>
<line-16></line-16>
<line-18> print(moneda(i))</line-18>
|
{"code": "<line-3>def moneda(m):</line-3>\n<line-17>for i in triangulo:</line-17>", "lines": [3, 17]}
#### 0
|
<line-1>for u in range(int(input())):</line-1>
<line-3> l=list(map(int,input().split()))</line-3>
<line-4> d=list(map(int,input().split()))</line-4>
<line-5> ka=[]</line-5>
<line-6> k=[]</line-6>
<line-7> l.sort()</line-7>
<line-8> d.sort()</line-8>
<line-9> for i in range(n):</line-9>
<line-10> ka.append(d[i])</line-10>
<line-11> ka.append(l[i])</line-11>
<line-12> for i in range(n):</line-12>
<line-13> k.append(l[i])</line-13>
<line-14> k.append(d[i])</line-14>
<line-15> if(ka==sorted(ka)):</line-15>
<line-16> print("YES")</line-16>
<line-17> elif(k==sorted(k)):</line-17>
<line-18> print("YES")</line-18>
<line-20> print("NO")</line-20>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-19> else:</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>t =int(input())</line-1>
<line-3> C=[ord(x)-ord('R') for x in list(input())]</line-3>
<line-4> N=int(input())</line-4>
<line-5> L=sum(C)</line-5>
<line-6> r=1</line-6>
<line-7> c=0</line-7>
<line-8> while(r*L<N*12):</line-8>
<line-9> c+=N*12-r*L</line-9>
<line-11> print(c)</line-11>
<line-12></line-12>
<line-13></line-13>
<line-14></line-14>
<line-15></line-15>
<line-16></line-16>
<line-17></line-17>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-10> r+=1</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>def find_upper_bound(arr,key):</line-1>
<line-3> while low<=high:</line-3>
<line-4> mid = (low+high)//2 </line-4>
<line-5> if arr[mid]==key:return mid</line-5>
<line-6> elif arr[mid]>key and mid-1>=0 and arr[mid-1]<key:return mid </line-6>
<line-7> elif arr[mid]>key:high = mid - 1 </line-7>
<line-8> else:low = mid + 1 </line-8>
<line-9> return mid </line-9>
<line-10>def get_query(l):</line-10>
<line-11> nonlocal prefix_storer,bin_storer</line-11>
<line-12> ind = find_upper_bound(bin_storer,l)</line-12>
<line-13> surplus = (abs(bin_storer[ind]-l)*ind*ind)%limit </line-13>
<line-14> return (prefix_storer[ind]-surplus+limit)%limit</line-14>
<line-15>def fire_query(l,r):</line-15>
<line-16> return (get_query(r)-get_query(l-1)+limit)%limit</line-16>
<line-17>golomb,dp,prefix_storer,bin_storer = [],[0,1],[0,1],[0,1]</line-17>
<line-18>limit = 10**9+7</line-18>
<line-19>for i in range(2,10**6+100):</line-19>
<line-20> dp.append(1 + dp[i-dp[dp[i-1]]])</line-20>
<line-21> bin_storer.append(dp[-1]+bin_storer[-1])</line-21>
<line-22> prefix_storer.append(((prefix_storer[-1] + (dp[-1]*i*i)%limit))%limit)</line-22>
<line-23># print(dp[1:20])</line-23>
<line-24># print(bin_storer[1:20])</line-24>
<line-25># print(prefix_storer[1:20])</line-25>
<line-26># print(get_query(2),get_query(4))</line-26>
<line-27>for _ in range(int(input())):</line-27>
<line-29> print(fire_query(l,r))</line-29>
|
{"code": "<line-2> low,high = 0,len(arr)-1</line-2>\n<line-28> l,r = map(int,input().split())</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>#dt = {} for i in x: dt[i] = dt.get(i,0)+1</line-1>
<line-3>inp,ip = lambda :int(input()),lambda :[int(w) for w in input().split()]</line-3>
<line-4></line-4>
<line-5>def check(mid):</line-5>
<line-6> pos = x[0]</line-6>
<line-7> ct = 1</line-7>
<line-8> for i in range(1,n):</line-8>
<line-9> if x[i]-pos >= mid:</line-9>
<line-10> pos = x[i]</line-10>
<line-11> ct += 1</line-11>
<line-12> if ct == k:</line-12>
<line-13> return True</line-13>
<line-14> return False</line-14>
<line-15></line-15>
<line-16>for _ in range(inp()):</line-16>
<line-17> n,k = ip()</line-17>
<line-18> x = ip()</line-18>
<line-19> x.sort()</line-19>
<line-20> ans = -1</line-20>
<line-21> l,r = 1,x[-1]</line-21>
<line-22> while l < r:</line-22>
<line-23> mid = (l+r)//2</line-23>
<line-24> if check(mid):</line-24>
<line-25> ans = max(ans,mid)</line-25>
<line-26> l = mid +1</line-26>
<line-27> else:</line-27>
<line-29> print(ans)</line-29>
<line-30> </line-30>
<line-31> </line-31>
<line-32> </line-32>
<line-33> </line-33>
|
{"code": "<line-2>import sys;input = sys.stdin.readline</line-2>\n<line-28> r = mid</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>n,m,k=map(int, input().split())</line-1>
<line-3>check = [0]*m</line-3>
<line-4>while k!= 0:</line-4>
<line-5> x1,y1,x2,y2 =map(int,input().split())</line-5>
<line-6> a.append([x1,y1,x2,y2])</line-6>
<line-7> check[y1-1] += 1</line-7>
<line-8> check[y2-1] += 1</line-8>
<line-9> k-= 1</line-9>
<line-10>maxi = check.index(max(check))+1</line-10>
<line-11>sum = 0</line-11>
<line-12>k = 0</line-12>
<line-13>for i in range(len(a)):</line-13>
<line-14> x1,y1,x2,y2 = a[i]</line-14>
<line-15> if (y1 > maxi and y2 > maxi) or (y1<maxi and y2 < maxi):</line-15>
<line-16> sum+= abs(y2-y1)*2</line-16>
<line-17> sum += abs(x2-x1)*2</line-17>
<line-18> else:</line-18>
<line-19> if y1 != maxi:</line-19>
<line-20> k = abs(y1-maxi)</line-20>
<line-21> sum+= k*2</line-21>
<line-22> if x1 != x2:</line-22>
<line-23> k = abs(x2-x1)</line-23>
<line-24> sum += k</line-24>
<line-25> if y2 != maxi:</line-25>
<line-26> k = abs(y2-maxi)</line-26>
<line-28>print(sum)</line-28>
|
{"code": "<line-2>a = []</line-2>\n<line-27> sum+= k*2</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>try:</line-1>
<line-3> while(t > 0):</line-3>
<line-4> t -= 1</line-4>
<line-5> n,m = list(map(int,input().split()))</line-5>
<line-6> a = [list(map(int,input().split())) for _ in range(n)]</line-6>
<line-7> dp = [[0 for _ in range(m)] for _ in range(n)]</line-7>
<line-8> ans = [['0' for _ in range(m)] for _ in range(n)]</line-8>
<line-9> for i in range(n):</line-9>
<line-10> for j in range(m):</line-10>
<line-11> if i-1 < n:</line-11>
<line-12> if 0 <= j-1 and j+1 < m:</line-12>
<line-13> dp[i][j] = max(dp[i-1][j-1],dp[i-1][j],dp[i-1][j+1])</line-13>
<line-14> elif j == 0:</line-14>
<line-15> dp[i][j] = max(dp[i-1][j],dp[i-1][j+1])</line-15>
<line-16> elif j == m-1:</line-16>
<line-17> dp[i][j] = max(dp[i-1][j-1],dp[i-1][j])</line-17>
<line-18> </line-18>
<line-19> if dp[i][j] > a[i][j]:</line-19>
<line-20> ans[i][j] = '0'</line-20>
<line-21> else:</line-21>
<line-22> ans[i][j] = '1'</line-22>
<line-23> dp[i][j] = a[i][j]</line-23>
<line-24> </line-24>
<line-25> for i in ans:</line-25>
<line-26> print(''.join(i))</line-26>
<line-28> pass</line-28>
|
{"code": "<line-2> t = int(input())</line-2>\n<line-27>except:</line-27>", "lines": [2, 27]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3></line-3>
<line-4>for _ in range(0,test):</line-4>
<line-5> n = int(input())</line-5>
<line-7> print(len(lister))</line-7>
|
{"code": "<line-2>test = int(input())</line-2>\n<line-6> lister = set(map(int,input().split()))</line-6>", "lines": [2, 6]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>T=int(input())</line-3>
<line-4>for i in range(T):</line-4>
<line-5> a=list(map(int,input().split()))</line-5>
<line-6> n=a[0]</line-6>
<line-8> print(m*n//math.gcd(m,n))</line-8>
|
{"code": "<line-2>import math</line-2>\n<line-7> m=a[1]</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> l=list(map(int, input().split()))</line-3>
<line-4> l.sort()</line-4>
<line-5> </line-5>
<line-6> c=0</line-6>
<line-7> mn=abs(l[0]+l[1]-k)</line-7>
<line-8> for i in range(n-1):</line-8>
<line-9> for j in range(i+1, n):</line-9>
<line-10> temp=abs(l[i]+l[j]-k)</line-10>
<line-11> if temp==mn:</line-11>
<line-12> c+=1 </line-12>
<line-13> </line-13>
<line-14> elif temp<mn:</line-14>
<line-15> mn=temp</line-15>
<line-16> c=1 </line-16>
<line-17> </line-17>
<line-18> elif l[i]+l[j]-k>mn:</line-18>
<line-20> </line-20>
<line-21> print(mn, c)</line-21>
|
{"code": "<line-2> n,k=list(map(int, input().split()))</line-2>\n<line-19> break</line-19>", "lines": [2, 19]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>list1=[]</line-3>
<line-4>for i in range(int(input())):</line-4>
<line-5> x=int(input())</line-5>
<line-6> ans=(pow(2,x,mod)-1)%mod</line-6>
<line-7> list1.append((i+1,ans))</line-7>
<line-9> print(f'Case {i[0]}: {i[1]}')</line-9>
|
{"code": "<line-2>mod=8589934592</line-2>\n<line-8>for i in list1:</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>'''Author- Akshit Monga'''</line-1>
<line-3>input = stdin.readline</line-3>
<line-4>t=int(input())</line-4>
<line-5>for _ in range(t):</line-5>
<line-6> n=int(input())</line-6>
<line-7> a=[int(x) for x in input().split()]</line-7>
<line-8> ans=0</line-8>
<line-9> dp=[-1 for i in range(0,n+1)]</line-9>
<line-10> for i in a:</line-10>
<line-11> var1=dp[i]</line-11>
<line-12> var2=ans</line-12>
<line-13> ans=max(ans,var1+1)</line-13>
<line-15> print(n-ans)</line-15>
|
{"code": "<line-2>from sys import stdin, stdout</line-2>\n<line-14> dp[i]=max(dp[i],var2+1)</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>from collections import Counter </line-1>
<line-3> s = input()</line-3>
<line-4> c = Counter(list(s))</line-4>
<line-5> if len(c) == 1:</line-5>
<line-6> print(0)</line-6>
<line-7> else:</line-7>
<line-8> m = min(c['b'], c['g'])</line-8>
<line-9> ma = max(c['b'], c['g'])</line-9>
<line-10> l = (ma - m + 1) // 2</line-10>
<line-11> r = (ma - m + 1) // 2 + (ma - m + 1) % 2</line-11>
<line-12> res = (l * (l + 1)) // 2</line-12>
<line-13> re = res</line-13>
<line-14> for i in range(1, m):</line-14>
<line-15> res += 2 * l + 1</line-15>
<line-16> re += res</line-16>
<line-17> l += 1</line-17>
<line-18> res2 = (r * (r + 1)) // 2</line-18>
<line-19> re += res2</line-19>
<line-20> for i in range(1, m):</line-20>
<line-21> res2 += 2 * r + 1</line-21>
<line-22> re += res2</line-22>
<line-24> print(re)</line-24>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-23> r += 1</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>def f(a,n):</line-1>
<line-3> </line-3>
<line-4> for i in range(n):</line-4>
<line-5> count = 1</line-5>
<line-6> while(len(s1)>0 and a[i]<s1[-1][0]):</line-6>
<line-7> count += s1[-1][1]</line-7>
<line-8> s1.pop()</line-8>
<line-9> s1.append((a[i],count))</line-9>
<line-10> l[i] = count</line-10>
<line-11> </line-11>
<line-12> for i in range(n-1,-1,-1):</line-12>
<line-13> count = 1</line-13>
<line-14> while(len(s2)>0 and a[i]<=s2[-1][0]):</line-14>
<line-15> count += s2[-1][1]</line-15>
<line-16> s2.pop()</line-16>
<line-17> s2.append((a[i],count))</line-17>
<line-18> r[i] = count</line-18>
<line-19> </line-19>
<line-20> count = 0</line-20>
<line-21> for i in range(n):</line-21>
<line-22> count += a[i]*l[i]*r[i]</line-22>
<line-23> </line-23>
<line-25></line-25>
<line-26>t = int(input())</line-26>
|
{"code": "<line-2> l,r,s1,s2 = [0]*n, [0]*n, [], []</line-2>\n<line-24> return count</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> n, m = map(int, input().split())</line-3>
<line-4> arr1 = list(map(int, input().split()))</line-4>
<line-5> arr2 = list(map(int, input().split()))</line-5>
<line-6> hmap = {}</line-6>
<line-7> for i in range(n):</line-7>
<line-8> if arr1[i] in hmap:</line-8>
<line-9> hmap[arr1[i]] += 1</line-9>
<line-10> else:</line-10>
<line-11> hmap[arr1[i]] = 1</line-11>
<line-12> </line-12>
<line-13> for i in range(m):</line-13>
<line-14> if arr2[i] in hmap:</line-14>
<line-15> hmap[arr2[i]] += 1</line-15>
<line-16> else:</line-16>
<line-17> hmap[arr2[i]] = 1</line-17>
<line-18> ans = []</line-18>
<line-19> #print(hmap)</line-19>
<line-20> for key in hmap:</line-20>
<line-21> if hmap[key]==1:</line-21>
<line-22> ans.append(key)</line-22>
<line-23> ans.sort()</line-23>
<line-24> for x in ans:</line-24>
<line-26> print()</line-26>
<line-27> </line-27>
<line-28> </line-28>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-25> print(x,end=' ')</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> k=1</line-3>
<line-4> j=0</line-4>
<line-5> n=int(input())</line-5>
<line-6> while(n>0):</line-6>
<line-7> if(n<=k):</line-7>
<line-8> j+=1</line-8>
<line-9> n=0</line-9>
<line-10> elif n>2*k:</line-10>
<line-11> j+=2</line-11>
<line-12> n=n-2*k</line-12>
<line-13> k+=1</line-13>
<line-14> else:</line-14>
<line-15> j+=2</line-15>
<line-16> n=0</line-16>
<line-18> t-=1</line-18>
|
{"code": "<line-2>while(t):</line-2>\n<line-17> print(j)</line-17>", "lines": [2, 17]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3></line-3>
<line-4>import math</line-4>
<line-5>def distinctPrimeFactors(num) :</line-5>
<line-6> primes,sqrt = set(),int(math.sqrt(num))</line-6>
<line-7> if (num == 2) :primes.add(num)</line-7>
<line-8> for j in range(2, sqrt + 1) :</line-8>
<line-9> if (num % j == 0) :</line-9>
<line-10> primes.add(j)</line-10>
<line-11> while (num % j == 0) :num //= j</line-11>
<line-12> if (num > 2) :primes.add(num)</line-12>
<line-13> return (primes)</line-13>
<line-14>res,c,lst,primes,rangeData = [],0,{},{},{};k, q = map(int, input().split());primes[k] = distinctPrimeFactors(k)</line-14>
<line-15>for tc in range(q) :</line-15>
<line-16> query = input()</line-16>
<line-17> if (query[0] == '!') :</line-17>
<line-18> cmd, l, r, x = query.split();l,r,x = int(l),int(r),int(x);start,end,startflag = l,r,False</line-18>
<line-19> for i in sorted(rangeData) :</line-19>
<line-20> rangeVal = i</line-20>
<line-21> if (start > rangeVal[1]) :continue</line-21>
<line-22> if (end < rangeVal[0]) :break </line-22>
<line-23> startRange,endRange = start,end</line-23>
<line-24> if (start >= rangeVal[0] and start <= rangeVal[1]) :start = rangeVal[1] + 1;continue</line-24>
<line-25> if (end >= rangeVal[0]) :endRange = rangeVal[0] - 1</line-25>
<line-26> if (startRange <= endRange) :</line-26>
<line-27> rangeData[(startRange, endRange)] = x;start = max(endRange + 1, rangeVal[1] + 1)</line-27>
<line-28> if (start <= end) :rangeData[(start,end)] = x</line-28>
<line-29> elif (query[0] == '?') :</line-29>
<line-30> cmd, l, r = query.split();l,r,count = int(l),int(r),0</line-30>
<line-31> for primenum in primes[k] :</line-31>
<line-32> for currRange in rangeData :</line-32>
<line-33> if (not (r < currRange[0] or l > currRange[1])) :</line-33>
<line-34> if (rangeData[currRange] % primenum == 0) :count += 1;break</line-34>
<line-36>for i in range(c):print(res[i])</line-36>
|
{"code": "<line-2># cook your dish here</line-2>\n<line-35> c += 1;res.append(count) </line-35>", "lines": [2, 35]}
#### 0
|
<line-1>import math</line-1>
<line-3> f = math.factorial</line-3>
<line-4> return f(n) / f(r) / f(n-r)</line-4>
<line-5>t=int(input())</line-5>
<line-6>for i in range(1,t+1):</line-6>
<line-7> n=int(input())</line-7>
<line-8> arr = list(map(int, input().split()))</line-8>
<line-9> m=0</line-9>
<line-10> ans=0.0</line-10>
<line-11> for i in range(0,n):</line-11>
<line-12> if (arr[i]==-1):</line-12>
<line-13> m=m+1</line-13>
<line-14> for i in range(0,m):</line-14>
<line-15> ans=ans+((m-i)*comb(m-1,m-1-i))</line-15>
<line-17> print('{0:.7f}'.format(ans))</line-17>
|
{"code": "<line-2>def comb(n,r):</line-2>\n<line-16> ans=ans/pow(2,m-1)</line-16>", "lines": [2, 16]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n,r=list(map(int,input().split()))</line-3>
<line-4> l=list(map(int,input().split()))</line-4>
<line-5> m=0</line-5>
<line-6> for i in range(n-1):</line-6>
<line-7> d=[]</line-7>
<line-8> d.append(l[i])</line-8>
<line-9> c=1</line-9>
<line-10> while(i+c<n):</line-10>
<line-11> d.append(l[i+c])</line-11>
<line-12> d.sort(reverse=True)</line-12>
<line-13> if(d[0]+d[1]<=r):</line-13>
<line-14> c=c+1</line-14>
<line-15> else:</line-15>
<line-16> break</line-16>
<line-17> if(c>m):</line-17>
<line-19> print(m)</line-19>
<line-20></line-20>
<line-21></line-21>
|
{"code": "<line-2>for u in range(int(input())):</line-2>\n<line-18> m=c</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>n, m = map(int, input().split())</line-1>
<line-3>f = 1</line-3>
<line-4>s = ((n)*(n+1))//2 - l - f</line-4>
<line-5>for _ in range(m):</line-5>
<line-6> k = int(input())</line-6>
<line-7> if 2 <= k <= n-1 or k in [f, l]:</line-7>
<line-8> l, f = f, l</line-8>
<line-9> else:</line-9>
<line-11> print(s+l+f)</line-11>
|
{"code": "<line-2>l = n</line-2>\n<line-10> l = k</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>import math</line-1>
<line-3> return (math.floor(math.sqrt(b)) - math.ceil(math.sqrt(a)) + 1)</line-3>
<line-4>for _ in range(int(input())):</line-4>
<line-5> n=int(input())</line-5>
<line-6> val=CountSquares(1,n)</line-6>
<line-8> print(ans)</line-8>
|
{"code": "<line-2>def CountSquares(a, b):</line-2>\n<line-7> ans=val-val//3</line-7>", "lines": [2, 7]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>tests = int(input())</line-3>
<line-4>for _ in range(tests):</line-4>
<line-5> n = int(input())</line-5>
<line-6> weights = [int(j) for j in input().split()]</line-6>
<line-7> edges = [[0] for _ in range(n-1)]</line-7>
<line-8> for i in range(n-1):</line-8>
<line-9> edges[i] = [int(j)-1 for j in input().split()]</line-9>
<line-10> vertex_set = [[] for _ in range(n)]</line-10>
<line-11> for i in range(n-1):</line-11>
<line-12> vertex_set[edges[i][0]].append(edges[i][1])</line-12>
<line-13> vertex_set[edges[i][1]].append(edges[i][0])</line-13>
<line-14> counts = [0 for _ in range(3)]</line-14>
<line-15> for i in range(n):</line-15>
<line-16> counts[weights[i]] += 1</line-16>
<line-17> if counts[1] == 0:</line-17>
<line-18> print(2 * (counts[0] != 0 and counts[2] != 0))</line-18>
<line-19> elif counts[1] == n:</line-19>
<line-20> print(0)</line-20>
<line-21> else:</line-21>
<line-22> visited = [0]</line-22>
<line-23> for i in range(n):</line-23>
<line-24> vertex = visited[i]</line-24>
<line-25> for v in vertex_set[vertex]:</line-25>
<line-26> if v not in visited:</line-26>
<line-27> visited.append(v)</line-27>
<line-28> vertex_nums = [[0] for _ in range(n)]</line-28>
<line-29> for i in range(n-1,-1,-1):</line-29>
<line-30> vertex = visited[i]</line-30>
<line-31> for v in vertex_set[vertex]:</line-31>
<line-32> if v in visited[i:]:</line-32>
<line-33> vertex_nums[vertex].append(sum(vertex_nums[v])+1)</line-33>
<line-34> for i in range(n):</line-34>
<line-35> vertex_nums[i].append(n-1-sum(vertex_nums[i]))</line-35>
<line-36> sums = np.zeros(n,dtype=bool)</line-36>
<line-37> sums[0] = True</line-37>
<line-38> for i in range(n):</line-38>
<line-39> new_sums = np.zeros(n,dtype=bool)</line-39>
<line-40> new_sums[0] = True</line-40>
<line-41> for num in vertex_nums[i]:</line-41>
<line-42> new_sums[num:n] = np.logical_or(new_sums[num:n],new_sums[:n-num])</line-42>
<line-43> sums = np.logical_or(sums,new_sums)</line-43>
<line-44> solved = False</line-44>
<line-45> for i in range(n):</line-45>
<line-46> if sums[i] and counts[0] <= i and counts[2] <= n - 1 - i:</line-46>
<line-47> solved = True</line-47>
<line-48> break</line-48>
<line-49> if solved or counts[1] > 1:</line-49>
<line-50> print(1)</line-50>
<line-52> print(2)</line-52>
|
{"code": "<line-2>import numpy as np</line-2>\n<line-51> else:</line-51>", "lines": [2, 51]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> n=0</line-3>
<line-4> for i in range(1,t+1):</line-4>
<line-5> n=n+i</line-5>
<line-6> x=[n]</line-6>
<line-7> y=n</line-7>
<line-8> for j in range(i,t+i-1):</line-8>
<line-9> if j<t:</line-9>
<line-10> z=y+j</line-10>
<line-11> else:</line-11>
<line-12> z=y+(2*t-j-1)</line-12>
<line-13> x.append(z)</line-13>
<line-15> print(*x)</line-15>
|
{"code": "<line-2> t=int(input())</line-2>\n<line-14> y=z</line-14>", "lines": [2, 14]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n = int(input())</line-3>
<line-4> ar = list(map(int, input().split()))</line-4>
<line-5> </line-5>
<line-6> count = 0</line-6>
<line-7> for item in ar:</line-7>
<line-8> if bin(item)[-1] == '0':</line-8>
<line-10> </line-10>
<line-11> print(count)</line-11>
|
{"code": "<line-2>for test in range(int(input())):</line-2>\n<line-9> count += item</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>from sys import setrecursionlimit</line-1>
<line-3></line-3>
<line-4>def solve(i, j, c=0):</line-4>
<line-5> if i > j:</line-5>
<line-6> return 0</line-6>
<line-7></line-7>
<line-8> if (i, j) in dp:</line-8>
<line-9> return dp[i, j]</line-9>
<line-10></line-10>
<line-11> x0 = solve(i+1, j, c^1)</line-11>
<line-12> x1 = solve(i, j-1, c^1)</line-12>
<line-13></line-13>
<line-14> if c == 0:</line-14>
<line-15> y = 1 << (j - i)</line-15>
<line-16> x0 += a[i] * y</line-16>
<line-17> x1 += a[j] * y</line-17>
<line-18></line-18>
<line-19> dp[i, j] = x0 + x1</line-19>
<line-20> return dp[i, j]</line-20>
<line-21></line-21>
<line-22>for _ in range(int(input())):</line-22>
<line-23> n = int(input())</line-23>
<line-24> a = list(map(int, input().split()))</line-24>
<line-25> dp = {}</line-25>
<line-26></line-26>
<line-28> print(total / (1 << n))</line-28>
|
{"code": "<line-2>setrecursionlimit(10 ** 9)</line-2>\n<line-27> total = solve(0, n-1)</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>#!/usr/bin/env python2</line-1>
<line-2> </line-2>
<line-4> return 'a' <= c <= 'h'</line-4>
<line-5>def gd(c):</line-5>
<line-6> return '1' <= c <= '8'</line-6>
<line-7> </line-7>
<line-8>t = int(input())</line-8>
<line-9>for i in range(t):</line-9>
<line-10> line = input()</line-10>
<line-11> if len(line) != 5:</line-11>
<line-12> print("Error")</line-12>
<line-13> continue</line-13>
<line-14> if line[2] != '-':</line-14>
<line-15> print("Error")</line-15>
<line-16> continue</line-16>
<line-17> x1 = line[0]</line-17>
<line-18> y1 = line[1]</line-18>
<line-19> x2 = line[3]</line-19>
<line-20> y2 = line[4]</line-20>
<line-21> if gc(x1) and gd(y1) and gc(x2) and gd(y2):</line-21>
<line-22> d1 = abs(ord(x1) - ord(x2))</line-22>
<line-23> d2 = abs(ord(y1) - ord(y2))</line-23>
<line-24> if d1 > d2: d1,d2 = d2, d1</line-24>
<line-25> if (d1 == 1) and (d2 == 2):</line-25>
<line-26> print("Yes")</line-26>
<line-27> else:</line-27>
<line-28> print("No")</line-28>
<line-30> print("Error")</line-30>
|
{"code": "<line-3>def gc(c):</line-3>\n<line-29> else:</line-29>", "lines": [3, 29]}
#### 0
|
<line-1>T=int(input()) # cook your dish here</line-1>
<line-3> n=list(map(int,input().split()))</line-3>
<line-4> a=n[0]</line-4>
<line-5> b=n[1]</line-5>
<line-6> c=n[2]</line-6>
<line-7> l=[]</line-7>
<line-8> A=list(map(int,input().split()))</line-8>
<line-9> B=list(map(int,input().split()))</line-9>
<line-10> C=list(map(int,input().split()))</line-10>
<line-11> for i in range(b):</line-11>
<line-12> for j in range(a):</line-12>
<line-13> for k in range(c):</line-13>
<line-14> if(A[j]<=B[i] and B[i]>=C[k]):</line-14>
<line-15> sum=((A[j]+B[i])*(B[i]+C[k]))</line-15>
<line-16> l.append(int(sum))</line-16>
<line-17> </line-17>
<line-18> </line-18>
<line-19> </line-19>
<line-20> </line-20>
<line-21> sum=0</line-21>
<line-22> for i in range(len(l)):</line-22>
<line-24> print(sum%1000000007)</line-24>
|
{"code": "<line-2>for i in range(T): </line-2>\n<line-23> sum+=int(l[i])</line-23>", "lines": [2, 23]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(t):</line-3>
<line-4> x=int(input())</line-4>
<line-5> if x%10==0:</line-5>
<line-6> print(0)</line-6>
<line-7> elif x%5==0:</line-7>
<line-8> print(1)</line-8>
<line-10> print(-1)</line-10>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-9> else:</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> a=[]</line-3>
<line-4> l=0</line-4>
<line-5> for i in range(n):</line-5>
<line-6> a.append(list(map(int,input().split())))</line-6>
<line-7> for i in range(n-1,0,-1):</line-7>
<line-8> r=a[i][i-1]+1</line-8>
<line-9> if a[i][i]!=r:</line-9>
<line-10> l+=1</line-10>
<line-11> n=i+1</line-11>
<line-12> for j in range(n):</line-12>
<line-13> for k in range(j,n):</line-13>
<line-15> </line-15>
<line-16> print(l)</line-16>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-14> a[j][k],a[k][j]=a[k][j],a[j][k]</line-14>", "lines": [2, 14]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(t):</line-3>
<line-4> s=input()</line-4>
<line-5> k=len(s)</line-5>
<line-6> count=0</line-6>
<line-7> for i in range(k-1):</line-7>
<line-8> if(s[i]=="C"):</line-8>
<line-9> if(s[i+1]=='E'or s[i+1]=='S' or s[i+1]=="C"):</line-9>
<line-10> count+=1 </line-10>
<line-11> elif(s[i]=="E"):</line-11>
<line-12> if(s[i+1]=="S"or s[i+1]=='E'):</line-12>
<line-13> count+=1 </line-13>
<line-14> elif(s[i]=="S"):</line-14>
<line-15> if(s[i+1]=="S"):</line-15>
<line-16> count+=1 </line-16>
<line-17> if (count==k-1):</line-17>
<line-18> print("yes")</line-18>
<line-20> print("no")</line-20>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-19> else:</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n=int(input())</line-3>
<line-4> x=list(map(int,input().split()))</line-4>
<line-5> dic={}</line-5>
<line-6> dic2={}</line-6>
<line-7> for i in range(n):</line-7>
<line-8> dic2[x[i]]=1</line-8>
<line-9> #print dic2</line-9>
<line-10> if len(dic2)==n:</line-10>
<line-11> n+=2</line-11>
<line-12> print((n*(n-1)*(n-2)*(n-3))/24)</line-12>
<line-13> continue </line-13>
<line-14> counter=0</line-14>
<line-15> for i in range(n-1):</line-15>
<line-16> if x[i] in dic:</line-16>
<line-17> dic[x[i]]+=1</line-17>
<line-18> else:</line-18>
<line-19> dic[x[i]]=1</line-19>
<line-20> for j in range(i,n-1):</line-20>
<line-21> if x[j] in dic:</line-21>
<line-22> dic[x[j]]+=1</line-22>
<line-23> else:</line-23>
<line-24> dic[x[j]]=1</line-24>
<line-25> for p in range(j+1,n):</line-25>
<line-26> if x[p] in dic:</line-26>
<line-27> continue;</line-27>
<line-28> for q in range(p,n):</line-28>
<line-29> if x[q] in dic:</line-29>
<line-30> break</line-30>
<line-31> counter+=1</line-31>
<line-32> #print i,j,p,q</line-32>
<line-33> </line-33>
<line-35> print(counter)</line-35>
|
{"code": "<line-2>for q in range(t):</line-2>\n<line-34> dic.clear()</line-34>", "lines": [2, 34]}
#### 0
|
<line-1>lucky = {4, 774, 7, 744, 777, 74, 747, 44, 77, 47, 474, 444, 477, 447}</line-1>
<line-3>import sys </line-3>
<line-4>sys.setrecursionlimit(10 ** 6)</line-4>
<line-5>mod = 10 ** 9 + 7</line-5>
<line-6>fact = [1]</line-6>
<line-7>for i in range(1, 1001):</line-7>
<line-8> fact.append(fact[-1] * i % mod)</line-8>
<line-9>inv = [pow(i, mod-2, mod) for i in fact]</line-9>
<line-10>C = lambda k, n: fact[n] * inv[n-k] * inv[k] % mod</line-10>
<line-11>def f(n):</line-11>
<line-12> n = [int(x) for x in n]</line-12>
<line-13> @lru_cache(None)</line-13>
<line-14> def dp(pos, cnt, free):</line-14>
<line-15> if cnt > 777:</line-15>
<line-16> return 0</line-16>
<line-17> diff = len(n) - pos </line-17>
<line-18> ans = 0</line-18>
<line-19> if free:</line-19>
<line-20> for i in lucky:</line-20>
<line-21> i -= cnt</line-21>
<line-22> if 0 <= i <= diff:</line-22>
<line-23> ans += C(i, diff) * pow(2, i, mod) * pow(8, diff - i, mod)</line-23>
<line-24> ans %= mod </line-24>
<line-25> return ans</line-25>
<line-26> if pos == len(n):</line-26>
<line-27> return int(cnt in lucky)</line-27>
<line-28> for i in range(10 if free else n[pos]+1):</line-28>
<line-29> ans += dp(pos+1, cnt + int(i == 4 or i == 7), free or i < n[pos])</line-29>
<line-30> ans %= mod </line-30>
<line-31> return ans </line-31>
<line-32> return dp(0, 0, 0)</line-32>
<line-33> </line-33>
<line-34>t = int(input())</line-34>
<line-35>for _ in range(t):</line-35>
<line-36> l, r = input().split()</line-36>
<line-38> print((f(r) - f(l)) % mod)</line-38>
|
{"code": "<line-2>from functools import lru_cache</line-2>\n<line-37> l = str(int(l) -1) </line-37>", "lines": [2, 37]}
#### 0
|
<line-1>T=int(input())</line-1>
<line-3>for t in range(T):</line-3>
<line-4> R=int(input())</line-4>
<line-5> a=2*(R**2)</line-5>
<line-6> l.append(a)</line-6>
<line-8> print(s)</line-8>
|
{"code": "<line-2>l=[]</line-2>\n<line-7>for s in l:</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>try:</line-1>
<line-3> while t>0:</line-3>
<line-4> [a,b]=[int(x) for x in input().split()]</line-4>
<line-5> if a==1 and b==1:</line-5>
<line-6> print(1)</line-6>
<line-7> continue</line-7>
<line-8> if a%2==0:</line-8>
<line-9> o1=a//2</line-9>
<line-10> e1=a//2</line-10>
<line-11> else:</line-11>
<line-12> o1=a//2+1</line-12>
<line-13> e1=a//2</line-13>
<line-14> </line-14>
<line-15> if b%2==0:</line-15>
<line-16> o2=b//2</line-16>
<line-17> e2=b//2</line-17>
<line-18> else:</line-18>
<line-19> o2=b//2+1</line-19>
<line-20> e2=b//2</line-20>
<line-21> </line-21>
<line-22> print(e1*e2+o1*o2)</line-22>
<line-23> t-=1</line-23>
<line-25> pass</line-25>
|
{"code": "<line-2> t=int(input())</line-2>\n<line-24>except:</line-24>", "lines": [2, 24]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3># import bisect</line-3>
<line-4>def insort(l, v):</line-4>
<line-5> s = 0</line-5>
<line-6> e = len(l)</line-6>
<line-7> while True:</line-7>
<line-8> mid = (s+e)//2</line-8>
<line-9> if s == e or mid > len(l):</line-9>
<line-10> break</line-10>
<line-11> if l[mid][0] < v[0]:</line-11>
<line-12> s = mid+1</line-12>
<line-13> elif l[mid][0] > v[0]:</line-13>
<line-14> e = mid</line-14>
<line-15> else:</line-15>
<line-16> break</line-16>
<line-17> l.insert(mid, v)</line-17>
<line-18> </line-18>
<line-19>for _ in range(int(input())):</line-19>
<line-20> n,l = map(int, input().split())</line-20>
<line-21> a_l = list(map(int, input().split()))</line-21>
<line-22> </line-22>
<line-23> dic = {}</line-23>
<line-24> dif = 0</line-24>
<line-25> for i,v in enumerate(a_l, start=1):</line-25>
<line-26> if v not in dic:</line-26>
<line-27> dic[v] = [i, i]</line-27>
<line-28> else:</line-28>
<line-29> dic[v][0] = min(dic[v][0], i)</line-29>
<line-30> dic[v][1] = max(dic[v][1], i)</line-30>
<line-31> dif = max(dif, dic[v][1]-dic[v][0])</line-31>
<line-32> </line-32>
<line-33> ans = dif</line-33>
<line-34> if l <= len(set(a_l)):</line-34>
<line-35> i_l = [[v,i] for i,v in enumerate(a_l, start=1)]</line-35>
<line-36> i_l.sort(reverse=True)</line-36>
<line-37> </line-37>
<line-38> dp = [[-1 for _ in range(l)] for _ in range(n)]</line-38>
<line-39> pq_l = [[] for _ in range(l)]</line-39>
<line-40> for i in range(1,n):</line-40>
<line-41> il = 1</line-41>
<line-42> dif_l = []</line-42>
<line-43> for j in range(i):</line-43>
<line-44> dif = abs(i_l[i][1]-i_l[j][1])</line-44>
<line-45> dif_l.append(dif)</line-45>
<line-46> dp[i][il] = max(dp[i][il], dif)</line-46>
<line-47> </line-47>
<line-48> for il in range(2,min(l,i+1)):</line-48>
<line-49> for prev_max, ind in reversed(pq_l[il-1]):</line-49>
<line-50> if ind == i:</line-50>
<line-51> continue</line-51>
<line-52> if prev_max < dp[i][il]:</line-52>
<line-53> break</line-53>
<line-54> else:</line-54>
<line-55> dp[i][il] = max(dp[i][il], min(dif_l[ind], prev_max))</line-55>
<line-56> insort(pq_l[il], [dp[i][il], i])</line-56>
<line-57> # tmp = [v[0] for v in pq_l[il]]</line-57>
<line-58> # ind = bisect.bisect_right(tmp, dp[i][il])</line-58>
<line-59> # pq_l[il].insert(ind, [dp[i][il], i])</line-59>
<line-60> </line-60>
<line-61> il = 1</line-61>
<line-62> insort(pq_l[il], [dp[i][il], i])</line-62>
<line-63> # tmp = [v[0] for v in pq_l[il]]</line-63>
<line-64> # ind = bisect.bisect_right(tmp, dp[i][il])</line-64>
<line-65> # pq_l[il].insert(ind, [dp[i][il], i])</line-65>
<line-66> </line-66>
<line-67> # print(i, pq_l, dif_l)</line-67>
<line-68> </line-68>
<line-69> </line-69>
<line-70> # dp[i][1] = max(dp[i][1], dif)</line-70>
<line-71> # for il in range(2,l):</line-71>
<line-72> # if dp[j][il-1] == -1:</line-72>
<line-73> # break</line-73>
<line-74> # dp[i][il] = max(dp[i][il], min(dif, dp[j][il-1]))</line-74>
<line-75> ans = max(ans, dp[i][-1])</line-75>
<line-76> # print(dp)</line-76>
<line-78> print(ans)</line-78>
|
{"code": "<line-2># from queue import PriorityQueue</line-2>\n<line-77> # print(dic)</line-77>", "lines": [2, 77]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(t):</line-3>
<line-4> v,w=list(map(int,input().strip().split(" ")))</line-4>
<line-5> if v==w:</line-5>
<line-6> print(v+1)</line-6>
<line-7> elif v<w:</line-7>
<line-8> print(v+1)</line-8>
<line-9> else:</line-9>
<line-10> print(w+1)</line-10>
<line-11> #s="a"</line-11>
<line-12> #s=s*v</line-12>
<line-13> #l=list(s)</line-13>
<line-14> #print(l)</line-14>
<line-16> #for i in range(w):</line-16>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-15> ct=0</line-15>", "lines": [2, 15]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>from collections import defaultdict</line-3>
<line-4>for _ in range(int(stdin.readline())):</line-4>
<line-5> n=int(stdin.readline())</line-5>
<line-6> lst=list(map(int, stdin.readline().split()))</line-6>
<line-7> prefix_odd=[0]*n</line-7>
<line-8> prefix_even=[0]*n</line-8>
<line-9> odd_val=0</line-9>
<line-10> even_val=0</line-10>
<line-11> for i in range(n):</line-11>
<line-12> if lst[i]%2==0:</line-12>
<line-13> even_val+=1 </line-13>
<line-14> else:</line-14>
<line-15> odd_val+=1</line-15>
<line-16> prefix_even[i]=even_val</line-16>
<line-17> prefix_odd[i]=odd_val</line-17>
<line-18> #print(prefix_odd,prefix_even)</line-18>
<line-19> prefix_sum=[0]*n</line-19>
<line-20> s=0</line-20>
<line-21> for i in range(n):</line-21>
<line-22> s+=lst[i]</line-22>
<line-23> prefix_sum[i]=s</line-23>
<line-24> #print(prefix_sum)</line-24>
<line-25> dict={}</line-25>
<line-26> count={}</line-26>
<line-27> for i in range(n):</line-27>
<line-28> if lst[i] not in dict:</line-28>
<line-29> dict[lst[i]]=i</line-29>
<line-30> count[lst[i]]=1</line-30>
<line-31> else:</line-31>
<line-32> dict[lst[i]]=i</line-32>
<line-33> count[lst[i]]+=1</line-33>
<line-34> #print(dict)</line-34>
<line-35> graph=defaultdict(list)</line-35>
<line-36> for i in range(n):</line-36>
<line-37> graph[lst[i]].append(i)</line-37>
<line-38> max_sum=0</line-38>
<line-39> for i in graph:</line-39>
<line-40> if len(graph[i])>1:</line-40>
<line-41> prev=graph[i][0]</line-41>
<line-42> for j in range(1,len(graph[i])):</line-42>
<line-43> index2=graph[i][j]</line-43>
<line-44> index1=prev</line-44>
<line-45> prev=index2</line-45>
<line-46> #print(index1,index2)</line-46>
<line-47> if i%2==0:</line-47>
<line-48> val=prefix_even[index2]-prefix_even[index1]-1</line-48>
<line-49> #print(val)</line-49>
<line-50> if val%2==0:</line-50>
<line-51> temp_sum=prefix_sum[index2]-prefix_sum[index1]-i</line-51>
<line-52> #print(temp_sum)</line-52>
<line-53> if temp_sum>max_sum:</line-53>
<line-54> max_sum=temp_sum</line-54>
<line-55> else:</line-55>
<line-56> val=prefix_odd[index2]-prefix_odd[index1]-1</line-56>
<line-57> #print(val)</line-57>
<line-58> if val%2!=0:</line-58>
<line-59> temp_sum=prefix_sum[index2]-prefix_sum[index1]-i</line-59>
<line-60> #print(temp_sum)</line-60>
<line-61> if temp_sum>max_sum:</line-61>
<line-62> max_sum=temp_sum</line-62>
<line-63></line-63>
<line-64> '''max_sum=-1</line-64>
<line-65> for i in range(n):</line-65>
<line-66> if count[lst[i]]>1:</line-66>
<line-67> index2=dict[lst[i]]</line-67>
<line-68> index1=i</line-68>
<line-69> print(index1,index2)</line-69>
<line-70> if lst[i]%2==0:</line-70>
<line-71> val=prefix_even[index2]-prefix_even[index1]-1</line-71>
<line-72> print(val)</line-72>
<line-73> if val%2==0:</line-73>
<line-74> temp_sum=prefix_sum[index2]-prefix_sum[index1]-lst[i]</line-74>
<line-75> print(temp_sum)</line-75>
<line-76> if temp_sum>max_sum:</line-76>
<line-77> max_sum=temp_sum</line-77>
<line-78> else:</line-78>
<line-79> val=prefix_odd[index2]-prefix_odd[index1]-1</line-79>
<line-80> print(val)</line-80>
<line-81> if val%2!=0:</line-81>
<line-82> temp_sum=prefix_sum[index2]-prefix_sum[index1]-lst[i]</line-82>
<line-83> print(temp_sum)</line-83>
<line-84> if temp_sum>max_sum:</line-84>
<line-86> </line-86>
<line-87> stdout.write(str(max_sum)+'\n')</line-87>
|
{"code": "<line-2>from sys import stdin, stdout</line-2>\n<line-85> max_sum=temp_sum'''</line-85>", "lines": [2, 85]}
#### 0
|
<line-2> n=int(input())</line-2>
<line-3> print(n//2+1)</line-3>
|
{"code": "<line-1>for i in range(int(input())):</line-1>", "lines": [1]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>def main(arr):</line-4>
<line-5> </line-5>
<line-6> k=len(arr[0])</line-6>
<line-7> n=len(arr)</line-7>
<line-8> dp=[[0]*k for i in range(n+1)]</line-8>
<line-9> </line-9>
<line-10> summation_arr=[]</line-10>
<line-11> for i in range(len(arr)):</line-11>
<line-12> a=1 if i!=0 else 0</line-12>
<line-13> summation_arr.append(sum(arr[i])+a)</line-13>
<line-14> </line-14>
<line-15> for i in range(1,len(dp)):</line-15>
<line-16> for j in range(len(dp[0])):</line-16>
<line-17> dp[i][j]=(dp[i-1][j]+arr[i-1][j])/summation_arr[i-1]</line-17>
<line-18> ans=[]</line-18>
<line-19> </line-19>
<line-20> for i in range(k):</line-20>
<line-21> ans.append(dp[-1][i])</line-21>
<line-22> print(*ans)</line-22>
<line-23></line-23>
<line-24></line-24>
<line-25> </line-25>
<line-26>n,k=input().split()</line-26>
<line-27>n=int(n)</line-27>
<line-28>arr=[]</line-28>
<line-29>for i in range(n):</line-29>
<line-31>(main(arr))</line-31>
<line-32> </line-32>
<line-33> </line-33>
|
{"code": "<line-2>import math</line-2>\n<line-30> arr.append(list(map(int,input().split())))</line-30>", "lines": [2, 30]}
#### 0
|
<line-1>def codn1(s1,s2,p):</line-1>
<line-3> ind=0</line-3>
<line-4> for i in range(len(s1)):</line-4>
<line-5> if s1[i]!=s2[i]:</line-5>
<line-6> c+=1</line-6>
<line-7> ind=i</line-7>
<line-8> if c>1 or ind==len(s1)-1:</line-8>
<line-9> return 0</line-9>
<line-10> if s1[ind]>s2[ind] and s1[ind] in s2[ind+1:]:</line-10>
<line-11> p[0]=True</line-11>
<line-12> if s1[ind]<s2[ind] and s2[ind] in s1[ind+1:]:</line-12>
<line-13> p[1]=True</line-13>
<line-14> return 1</line-14>
<line-15> </line-15>
<line-16>def codn2(s1,s2):</line-16>
<line-17> if len(s1)<len(s2):</line-17>
<line-18> for i in range(len(s2)):</line-18>
<line-19> if s2[:i]+s2[i+1:]==s1:</line-19>
<line-20> return 1</line-20>
<line-21> else:</line-21>
<line-22> for i in range(len(s1)):</line-22>
<line-23> if s1[:i]+s1[i+1:]==s2:</line-23>
<line-24> return 2</line-24>
<line-25></line-25>
<line-26></line-26>
<line-27>def longest(k):</line-27>
<line-28> if cost[k]>0:</line-28>
<line-29> return cost[k]</line-29>
<line-30> for i in list(d[k]):</line-30>
<line-31> cost[k]=max(cost[k],longest(i)+1)</line-31>
<line-32> return cost[k]</line-32>
<line-33></line-33>
<line-34>n=int(input())</line-34>
<line-35>l=[]</line-35>
<line-36>#parent=[0]*n</line-36>
<line-37>d={}</line-37>
<line-38>cost={}</line-38>
<line-39>for i in range(n):</line-39>
<line-40> l.append(input())</line-40>
<line-41> d[i]=[]</line-41>
<line-42> cost[i]=0</line-42>
<line-43></line-43>
<line-44>for i in range(n):</line-44>
<line-45> for j in range(n):</line-45>
<line-46> if i!=j:</line-46>
<line-47> p=[False,False]</line-47>
<line-48> if len(l[i])==len(l[j]):</line-48>
<line-49> if codn1(l[i],l[j],p):</line-49>
<line-50> if p[0]==True:</line-50>
<line-51> d[j].append(i)</line-51>
<line-52> if p[1]==True:</line-52>
<line-53> d[i].append(j)</line-53>
<line-54> elif abs(len(l[i])-len(l[j]))==1:</line-54>
<line-55> y=codn2(l[i],l[j])</line-55>
<line-56> if y==1:</line-56>
<line-57> d[j].append(i)</line-57>
<line-58> if y==2:</line-58>
<line-59> d[i].append(j)</line-59>
<line-60>ans=0</line-60>
<line-61>#print(d)</line-61>
<line-62></line-62>
<line-63>for i in range(n):</line-63>
<line-65>print(ans+1)</line-65>
|
{"code": "<line-2>\tc=0</line-2>\n<line-64>\tans=max(ans,longest(i))</line-64>", "lines": [2, 64]}
#### 0
|
<line-1>from math import sqrt</line-1>
<line-2></line-2>
<line-4>pairs = 0</line-4>
<line-5></line-5>
<line-6>for i in range(1, a+1):</line-6>
<line-7> for j in range(1, b+1):</line-7>
<line-8> root = sqrt(i**2 + j)</line-8>
<line-9></line-9>
<line-10> if not root - int(root):</line-10>
<line-12></line-12>
<line-13>print(pairs)</line-13>
|
{"code": "<line-3>a, b = map(int, input().split())</line-3>\n<line-11> pairs += 1</line-11>", "lines": [3, 11]}
#### 0
|
<line-1>def check(l,n):</line-1>
<line-3> for i in range(n-1):</line-3>
<line-4> x = l[i]</line-4>
<line-5> c = 0</line-5>
<line-6> j = i</line-6>
<line-7> while (j+2<n and l[j+2]==x) or (j+1<n and l[j+1] == x):</line-7>
<line-8> if l[j+1] == x:</line-8>
<line-9> j = j+1</line-9>
<line-10> else:</line-10>
<line-11> j+=2</line-11>
<line-12> c+=1</line-12>
<line-13> if m<c:</line-13>
<line-14> m = c</line-14>
<line-15> return m</line-15>
<line-16></line-16>
<line-17>t = int(input())</line-17>
<line-18>for _ in range(t):</line-18>
<line-19> no = int(input())</line-19>
<line-21> print(check(a,no))</line-21>
|
{"code": "<line-2> m = 0</line-2>\n<line-20> a = list(map(int,input().split()))</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>N = int(input())</line-1>
<line-3>flag = 0</line-3>
<line-4>for i in range(N+1, 987654321):</line-4>
<line-5> a = str(i)</line-5>
<line-6> b = list(a)</line-6>
<line-7> c = set(a)</line-7>
<line-8> if '0' not in b:</line-8>
<line-9> if len(b) == len(c):</line-9>
<line-10> print(i)</line-10>
<line-11> flag += 1</line-11>
<line-12> break</line-12>
<line-13> </line-13>
<line-15> print(0)</line-15>
<line-16> </line-16>
<line-17> </line-17>
<line-18> </line-18>
|
{"code": "<line-2>i = N + 1</line-2>\n<line-14>if flag < 1:</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>import math</line-1>
<line-3>def diff(li1, li2): </line-3>
<line-4> li_dif = [i for i in li1 if i not in li2]</line-4>
<line-5> return li_dif </line-5>
<line-6>def segments(b):</line-6>
<line-7> """A sequence of (x,y) numeric coordinates pairs """</line-7>
<line-8> poly = [(i[0],i[1]) for i in b]</line-8>
<line-9> return zip(poly, poly[1:] + [poly[0]])</line-9>
<line-10>def perimeter(poly):</line-10>
<line-11> """A sequence of (x,y) numeric coordinates pairs """</line-11>
<line-12> return abs(sum(math.hypot(x0-x1,y0-y1) for ((x0, y0), (x1, y1)) in segments(poly)))</line-12>
<line-13>def av(b):</line-13>
<line-14> return sum([i[3] for i in b])</line-14>
<line-15>def val(b):</line-15>
<line-16> return sum([i[2] for i in b])</line-16>
<line-17>for _ in range(int(input())):</line-17>
<line-18> b = []</line-18>
<line-19> for _ in range(int(input())):</line-19>
<line-20> b.append(list(map(int,input().split())))</line-20>
<line-21> perm = []</line-21>
<line-22> for i in range(1,len(b)):</line-22>
<line-23> for e in p(b,i):</line-23>
<line-24> perm.append(e)</line-24>
<line-25> perm.sort(key=lambda x:val(x))</line-25>
<line-26> yes = []</line-26>
<line-27> for i in perm:</line-27>
<line-28> if av(i)>=perimeter(diff(b,i)):</line-28>
<line-29> good = val(i)</line-29>
<line-30> yes.append(i)</line-30>
<line-31> break</line-31>
<line-32> #yes.sort(key = lambda x: len(x))</line-32>
<line-33> print(" ".join([str(b.index(i)+1) for i in yes[0]]))</line-33>
<line-35> print(f'{x:.2f}')</line-35>
<line-36></line-36>
<line-37></line-37>
|
{"code": "<line-2>from itertools import permutations as p</line-2>\n<line-34> x = round(av(yes[0])-perimeter(diff(b,yes[0])),2)</line-34>", "lines": [2, 34]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(str1):</line-3>
<line-4> l1=[]</line-4>
<line-5> str2=input()</line-5>
<line-6> for i in str2:</line-6>
<line-7> l1.append(i)</line-7>
<line-8> </line-8>
<line-9> count=0</line-9>
<line-10> d=dict()</line-10>
<line-11> d={'a':1,'b':2,'c':3,'d':4,'e':5,'f':6,'g':7,'h':8,'i':9,'j':10,'k':11,'l':12,'m':13,'n':14}</line-11>
<line-12> d1={'o':15,'p':16,'q':17,'r':18,'s':19,'t':20,'u':21,'v':22,'w':23,'x':24,'y':25,'z':26}</line-12>
<line-13> d.update(d1)</line-13>
<line-14> for j in l1:</line-14>
<line-15> if j not in ['a','e','i','o','u']:</line-15>
<line-16> a=abs(d[j]-d['a'])</line-16>
<line-17> e=abs(d[j]-d['e'])</line-17>
<line-18> i=abs(d[j]-d['i'])</line-18>
<line-19> o=abs(d[j]-d['o'])</line-19>
<line-20> u=abs(d[j]-d['u'])</line-20>
<line-21> </line-21>
<line-23> print(count)</line-23>
<line-24></line-24>
|
{"code": "<line-2>str1=int(input())</line-2>\n<line-22> count+=min([a,e,i,o,u])</line-22>", "lines": [2, 22]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>def get_array(): return list(map(int , sys.stdin.readline().strip().split()))</line-3>
<line-4>def get_ints(): return list(map(int, sys.stdin.readline().strip().split()))</line-4>
<line-5>def input(): return sys.stdin.readline().strip()</line-5>
<line-6>import math</line-6>
<line-7>from collections import defaultdict</line-7>
<line-8>from itertools import combinations_with_replacement,permutations</line-8>
<line-9>import bisect</line-9>
<line-10>import math as mt </line-10>
<line-11>from functools import reduce</line-11>
<line-12>import time</line-12>
<line-13></line-13>
<line-14>def __starting_point():</line-14>
<line-15> for _ in range(int(input())):</line-15>
<line-16> n = int(input())</line-16>
<line-17> a=1</line-17>
<line-18> b=1</line-18>
<line-19> c=(-2*n)</line-19>
<line-20> dis = b * b - 4 * a * c </line-20>
<line-21> sqrt_val = math.sqrt(abs(dis))</line-21>
<line-22> r1=(-b + sqrt_val)/(2 * a)</line-22>
<line-23> # r2=(-b - sqrt_val)/(2 * a)</line-23>
<line-24></line-24>
<line-25> # print(r1)</line-25>
<line-26> r1 = math.floor(r1)+1</line-26>
<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>
<line-35></line-35>
<line-36></line-36>
<line-37></line-37>
<line-38></line-38>
<line-39>__starting_point()</line-39>
|
{"code": "<line-2>import sys</line-2>\n<line-27> print(n-r1+1)</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> t=t-1</line-3>
<line-4> n=int(input())</line-4>
<line-5> ans=0</line-5>
<line-6> for i in range(1,n+1,1):</line-6>
<line-7> sum=0;</line-7>
<line-8> for j in range(1,i+1,1):</line-8>
<line-9> sum=sum+j</line-9>
<line-10> s=sum-i</line-10>
<line-11> sum=sum+s</line-11>
<line-12> if(i!=n):</line-12>
<line-13> ans=ans+2*sum*i</line-13>
<line-14> else:</line-14>
<line-16> print(ans)</line-16>
|
{"code": "<line-2>while(t!=0):</line-2>\n<line-15> ans=ans+sum*i</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>isPrime=[1 for i in range(10001)]</line-1>
<line-3>isPrime[0]=0</line-3>
<line-4>isPrime[1]=0</line-4>
<line-5>prime=[]</line-5>
<line-6>for i in range(2,10001):</line-6>
<line-7> if isPrime[i]:</line-7>
<line-8> prime.append(i)</line-8>
<line-9> for j in range(i*i,10001,i):</line-9>
<line-10> isPrime[j]=0</line-10>
<line-11>#print(prime)</line-11>
<line-12>for i in prime:</line-12>
<line-13> for j in prime:</line-13>
<line-14> if (i + 2*j)>10000:</line-14>
<line-15> break</line-15>
<line-16> else:</line-16>
<line-17> cnt[i + 2*j]+=1</line-17>
<line-18>#print(le)</line-18>
<line-19>for _ in range(int(input())):</line-19>
<line-21> print(cnt[n])</line-21>
|
{"code": "<line-2>cnt=[0 for i in range(10001)]</line-2>\n<line-20> n=int(input())</line-20>", "lines": [2, 20]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>x=[]</line-3>
<line-4>y=[]</line-4>
<line-5>for _ in range(n):</line-5>
<line-6> s=input().split(' ')</line-6>
<line-7> x.append(int(s[0]))</line-7>
<line-8> y.append(int(s[1]))</line-8>
<line-9>q=x[0]</line-9>
<line-10>w=y[0]</line-10>
<line-11>for t in range(n-1):</line-11>
<line-12> x[t]=(x[t]+x[t+1])/2 </line-12>
<line-13> y[t]=(y[t]+y[t+1])/2 </line-13>
<line-14>x[n-1]=(x[n-1]+q)/2 </line-14>
<line-15>y[n-1]=(y[n-1]+w)/2 </line-15>
<line-16>i=0</line-16>
<line-17>a=0</line-17>
<line-18>while(i<n-1):</line-18>
<line-19> a+=(x[i]*y[i+1]-y[i]*x[i+1])/2</line-19>
<line-20> i+=1</line-20>
<line-21>a+=(x[i]*y[0]-y[i]*x[0])/2</line-21>
<line-22></line-22>
<line-24>#print(x,y)</line-24>
|
{"code": "<line-2>n=int(input())</line-2>\n<line-23>print(abs(a))</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3> t = int(input())</line-3>
<line-4> li = sorted(list(map(int , input().split())))</line-4>
<line-5> ans = 1</line-5>
<line-6> dp = [li[1]-li[0]] + [0] * (t-2) + [li[t-1] - li[t-2]]</line-6>
<line-7> for i in range(1 , t-1) :</line-7>
<line-9> print(max(dp))</line-9>
|
{"code": "<line-2>for i in range(n) :</line-2>\n<line-8> dp[i] = min(li[i] - li[i-1] , li[i+1] - li[i])</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>from sys import stdin, stdout</line-1>
<line-3>n = int(stdin.readline())</line-3>
<line-4>#l = list(map(int, stdin.readline().split()))</line-4>
<line-5>#l = [int(stdin.readline()) for _ in range(n)]</line-5>
<line-6>#a, b = map(int, stdin.readline().split())</line-6>
<line-7>for _ in range(n):</line-7>
<line-8> n1 = int(stdin.readline())</line-8>
<line-9> if n1==1:</line-9>
<line-10> print('*')</line-10>
<line-11> else:</line-11>
<line-12> a = n1+(n1-1)</line-12>
<line-13> s = 0</line-13>
<line-14> for x in range(1,n1):</line-14>
<line-15> if x==1:</line-15>
<line-16> print(' '*(n1-1)+'*'+' '*(n1-1))</line-16>
<line-17> s+=1</line-17>
<line-18> else:</line-18>
<line-19> print(' '*(n1-x)+'*'+' '*(s)+'*')</line-19>
<line-20> s+=2</line-20>
<line-22> print('*'*(a))</line-22>
<line-23> </line-23>
|
{"code": "<line-2>from collections import Counter</line-2>\n<line-21> #print()</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> m=list(map(int,input().split()))[:n]</line-3>
<line-4> m.sort()</line-4>
<line-5> t=0</line-5>
<line-6> for j in range(n//2):</line-6>
<line-8> print(t)</line-8>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-7> t+=abs(m[j]-m[n-j-1])</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> k = int(input())</line-4>
<line-5> count = 1</line-5>
<line-6> for _ in range(k):</line-6>
<line-7> output = []</line-7>
<line-8> for index in range(1,k+1):</line-8>
<line-9> output.append(bin(count).replace("0b", ""))</line-9>
<line-11> print(*output)</line-11>
|
{"code": "<line-3>for _ in range(t):</line-3>\n<line-10> count += 1</line-10>", "lines": [3, 10]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> # A temp_arr is created to store </line-3>
<line-4> # sorted array in merge function </line-4>
<line-5> temp_arr = [0]*n </line-5>
<line-6> return _mergeSort(arr, temp_arr, 0, n-1) </line-6>
<line-7> </line-7>
<line-8># This Function will use MergeSort to count inversions </line-8>
<line-9> </line-9>
<line-10>def _mergeSort(arr, temp_arr, left, right): </line-10>
<line-11> </line-11>
<line-12> # A variable inv_count is used to store </line-12>
<line-13> # inversion counts in each recursive call </line-13>
<line-14> </line-14>
<line-15> inv_count = 0</line-15>
<line-16> </line-16>
<line-17> # We will make a recursive call if and only if </line-17>
<line-18> # we have more than one elements </line-18>
<line-19> </line-19>
<line-20> if left < right: </line-20>
<line-21> </line-21>
<line-22> # mid is calculated to divide the array into two subarrays </line-22>
<line-23> # Floor division is must in case of python </line-23>
<line-24> </line-24>
<line-25> mid = (left + right)//2</line-25>
<line-26> </line-26>
<line-27> # It will calculate inversion </line-27>
<line-28> # counts in the left subarray </line-28>
<line-29> </line-29>
<line-30> inv_count += _mergeSort(arr, temp_arr, </line-30>
<line-31> left, mid) </line-31>
<line-32> </line-32>
<line-33> # It will calculate inversion </line-33>
<line-34> # counts in right subarray </line-34>
<line-35> </line-35>
<line-36> inv_count += _mergeSort(arr, temp_arr, </line-36>
<line-37> mid + 1, right) </line-37>
<line-38> </line-38>
<line-39> # It will merge two subarrays in </line-39>
<line-40> # a sorted subarray </line-40>
<line-41> </line-41>
<line-42> inv_count += merge(arr, temp_arr, left, mid, right) </line-42>
<line-43> return inv_count </line-43>
<line-44> </line-44>
<line-45># This function will merge two subarrays </line-45>
<line-46># in a single sorted subarray </line-46>
<line-47>def merge(arr, temp_arr, left, mid, right): </line-47>
<line-48> i = left # Starting index of left subarray </line-48>
<line-49> j = mid + 1 # Starting index of right subarray </line-49>
<line-50> k = left # Starting index of to be sorted subarray </line-50>
<line-51> inv_count = 0</line-51>
<line-52> </line-52>
<line-53> # Conditions are checked to make sure that </line-53>
<line-54> # i and j don't exceed their </line-54>
<line-55> # subarray limits. </line-55>
<line-56> </line-56>
<line-57> while i <= mid and j <= right: </line-57>
<line-58> </line-58>
<line-59> # There will be no inversion if arr[i] <= arr[j] </line-59>
<line-60> </line-60>
<line-61> if arr[i] <= arr[j]: </line-61>
<line-62> temp_arr[k] = arr[i] </line-62>
<line-63> k += 1</line-63>
<line-64> i += 1</line-64>
<line-65> else: </line-65>
<line-66> # Inversion will occur. </line-66>
<line-67> temp_arr[k] = arr[j] </line-67>
<line-68> inv_count += (mid-i + 1) </line-68>
<line-69> k += 1</line-69>
<line-70> j += 1</line-70>
<line-71> </line-71>
<line-72> # Copy the remaining elements of left </line-72>
<line-73> # subarray into temporary array </line-73>
<line-74> while i <= mid: </line-74>
<line-75> temp_arr[k] = arr[i] </line-75>
<line-76> k += 1</line-76>
<line-77> i += 1</line-77>
<line-78> </line-78>
<line-79> # Copy the remaining elements of right </line-79>
<line-80> # subarray into temporary array </line-80>
<line-81> while j <= right: </line-81>
<line-82> temp_arr[k] = arr[j] </line-82>
<line-83> k += 1</line-83>
<line-84> j += 1</line-84>
<line-85> </line-85>
<line-86> # Copy the sorted subarray into Original array </line-86>
<line-87> for loop_var in range(left, right + 1): </line-87>
<line-88> arr[loop_var] = temp_arr[loop_var] </line-88>
<line-89> </line-89>
<line-90> return inv_count </line-90>
<line-91> </line-91>
<line-92>for _ in range(int(input())):</line-92>
<line-93> n = int(input())</line-93>
<line-95> print(mergeSort(a, n) )</line-95>
|
{"code": "<line-2>def mergeSort(arr, n): </line-2>\n<line-94> a = list(map(int,input().split()))</line-94>", "lines": [2, 94]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> s = ''</line-3>
<line-4> for i in range(1, n + 1): s += str(i)</line-4>
<line-5> for i in range(n, 0, -1):</line-5>
<line-6> if i % 2 == 0:</line-6>
<line-7> for j in range(i, 0, -1): print(j, end = '')</line-7>
<line-8> else:</line-8>
<line-10> print()</line-10>
<line-11></line-11>
<line-12></line-12>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-9> for j in range(1, i + 1): print(j, end = '')</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>def solve(l):</line-1>
<line-3> if m == 0 or m == len(l) - 1:</line-3>
<line-4> return 1</line-4>
<line-5> return 1 + min(solve(l[0:m]), solve(l[m+1:]))</line-5>
<line-6></line-6>
<line-7>tc = int(input())</line-7>
<line-8>for test in range(tc):</line-8>
<line-9> n = int(input())</line-9>
<line-11> print(solve(l))</line-11>
|
{"code": "<line-2> m = l.index(max(l))</line-2>\n<line-10> l = list(map(int, input().split()))</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>import fractions</line-1>
<line-3> h,u,d = list(map(int,input().split()))</line-3>
<line-4> g = fractions.gcd(u,d)</line-4>
<line-5> if (h%g!=0):</line-5>
<line-6> print(-1)</line-6>
<line-7> else:</line-7>
<line-8> m = 0</line-8>
<line-9> n = 0</line-9>
<line-10> while (True):</line-10>
<line-11> n = (float(m)*u-h)/d</line-11>
<line-12> if (n>0 and int(n) == n):</line-12>
<line-13> break</line-13>
<line-15> print(int(m+n))</line-15>
|
{"code": "<line-2>for t in range(int(input())):</line-2>\n<line-14> m+=1</line-14>", "lines": [2, 14]}
#### 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, k = map(int, input().split())</line-5>
<line-6> if k == 0:</line-6>
<line-7> print(0, n)</line-7>
<line-8> else:</line-8>
<line-9> print(n//k, n%k)</line-9>
<line-11> pass</line-11>
|
{"code": "<line-2>try:</line-2>\n<line-10>except:</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> H=list(map(int,input().split()))</line-3>
<line-4> jumps=0</line-4>
<line-5> paracount=0</line-5>
<line-6> for i in range(len(H)-1):</line-6>
<line-7> if H[i+1]-H[i]<=U and H[i+1]>=H[i]:</line-7>
<line-8> jumps+=1</line-8>
<line-9> elif H[i]>=H[i+1] and H[i]-H[i+1]<=D:</line-9>
<line-10> jumps+=1</line-10>
<line-11> elif H[i]-H[i+1]>D and paracount==0:</line-11>
<line-12> jumps+=1</line-12>
<line-13> paracount=1</line-13>
<line-15> print(jumps+1)</line-15>
|
{"code": "<line-2> N,U,D=list(map(int,input().split()))</line-2>\n<line-14> else: break</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>try:</line-1>
<line-3> k=[[0 for i in range(S+1)] for i in range(n+1)]</line-3>
<line-4> for i in range(n+1):</line-4>
<line-5> for j in range(S+1):</line-5>
<line-6> if(j==0):</line-6>
<line-7> k[i][j]=1</line-7>
<line-8> elif(i==0):</line-8>
<line-9> k[i][j]=0</line-9>
<line-10> elif(arr[i-1]<=j):</line-10>
<line-11> k[i][j]=k[i-1][j-arr[i-1]]+k[i-1][j]</line-11>
<line-12> else:</line-12>
<line-13> k[i][j]=k[i-1][j]</line-13>
<line-14> return k[n][S]</line-14>
<line-15> for _ in range(int(input())):</line-15>
<line-16> m=int(input())</line-16>
<line-17> S=int(input()) </line-17>
<line-18> arr=[int(i) for i in input().split()]</line-18>
<line-19> </line-19>
<line-20> n=len(arr)</line-20>
<line-21></line-21>
<line-22> print(countsubsetsum(S, arr, n))</line-22>
<line-24> pass</line-24>
|
{"code": "<line-2> def countsubsetsum(S,arr,n):</line-2>\n<line-23>except EOFError as e:</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>import sys</line-1>
<line-3>parents = [int(x)-1 for x in input().split(' ')]</line-3>
<line-4>values = list(map(int , input().split(' ')))</line-4>
<line-5>parents = [0]+parents</line-5>
<line-6># print(parents)</line-6>
<line-7># print(values)</line-7>
<line-8>def single_node_cost(i):</line-8>
<line-9> cost = 0</line-9>
<line-10> # print('started with ',i)</line-10>
<line-11> min_value = sys.maxsize</line-11>
<line-12> while i != 0:</line-12>
<line-13> min_value = min(min_value,values[i])</line-13>
<line-14> cost += min_value</line-14>
<line-15> # print(i,min_value)</line-15>
<line-16> i = parents[i]</line-16>
<line-17> cost += min(values[0],min_value)</line-17>
<line-18> return cost</line-18>
<line-20> print(single_node_cost(i), end=' ')</line-20>
|
{"code": "<line-2>n = eval(input())</line-2>\n<line-19>for i in range(n):</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> laddus=0</line-3>
<line-4> for j in range(int(n)):</line-4>
<line-5> t=input().split()</line-5>
<line-6> if t[0]=='CONTEST_WON':</line-6>
<line-7> if(int(t[1])<=20):</line-7>
<line-8> laddus+=300+20-int(t[1])</line-8>
<line-9> else:</line-9>
<line-10> laddus+=300</line-10>
<line-11> elif t[0]=='TOP_CONTRIBUTOR':</line-11>
<line-12> laddus+=300</line-12>
<line-13> elif t[0]=='BUG_FOUND':</line-13>
<line-14> laddus+=int(t[1])</line-14>
<line-15> elif t[0]=='CONTEST_HOSTED':</line-15>
<line-16> laddus+=50</line-16>
<line-17> if(k=='INDIAN'):</line-17>
<line-18> print(laddus//200)</line-18>
<line-20> print(laddus//400)</line-20>
|
{"code": "<line-2> n,k=input().split()</line-2>\n<line-19> else:</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>def posSearch(arr, num):</line-1>
<line-3> r = len(arr)</line-3>
<line-4> if num < arr[l]:</line-4>
<line-5> return 0</line-5>
<line-6> elif num > arr[r-1]:</line-6>
<line-7> return r</line-7>
<line-8> while l < r:</line-8>
<line-9> m = (l+r)//2</line-9>
<line-10> if arr[m] == num:</line-10>
<line-11> return -1</line-11>
<line-12> if arr[m] < num < arr[m+1]:</line-12>
<line-13> return m+1</line-13>
<line-14> if arr[m] > num:</line-14>
<line-15> r = m</line-15>
<line-16> elif arr[m] < num:</line-16>
<line-17> l = m+1 </line-17>
<line-18> </line-18>
<line-19>for _ in range(int(input())):</line-19>
<line-20> n = int(input())</line-20>
<line-21> narr = list(map(int, input().split()))</line-21>
<line-22> q = int(input())</line-22>
<line-23> for i in range(q):</line-23>
<line-24> x, y = list(map(int, input().split()))</line-24>
<line-25> a = x+y</line-25>
<line-27> print(j)</line-27>
<line-28> </line-28>
|
{"code": "<line-2> l = 0</line-2>\n<line-26> j = posSearch(narr, a)</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> a=[int(z) for z in input().split()]</line-3>
<line-4> m=0</line-4>
<line-5> a1=list(set(a))</line-5>
<line-6> for i in range(len(a1)):</line-6>
<line-7> if a.count(a1[i])>m:</line-7>
<line-9> print(n-m)</line-9>
<line-10> </line-10>
<line-11> </line-11>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-8> m=a.count(a1[i])</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>try:</line-1>
<line-3> n=a[0]</line-3>
<line-4> k=a[1]</line-4>
<line-5> hi=[]</line-5>
<line-6> for i in range(n):</line-6>
<line-7> hi.append(int(input()))</line-7>
<line-8> hi.sort()</line-8>
<line-9> diff=[]</line-9>
<line-10> for i in range(n-k+1):</line-10>
<line-11> diff.append(hi[i+k-1]-hi[i])</line-11>
<line-12> print(min(diff))</line-12>
<line-14> pass</line-14>
|
{"code": "<line-2> a=list(map(int,input().split()))</line-2>\n<line-13>except:</line-13>", "lines": [2, 13]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3></line-3>
<line-4>for _ in range(testcases):</line-4>
<line-5> (N,K)=list(map(int,input().split()))</line-5>
<line-6> array=list(map(int,input().split()))</line-6>
<line-7> </line-7>
<line-8> max=array[0]</line-8>
<line-9> min=array[0]</line-9>
<line-10> </line-10>
<line-11> for i in array:</line-11>
<line-12> if i>max:</line-12>
<line-13> max=i</line-13>
<line-14> if i<min:</line-14>
<line-15> min=i</line-15>
<line-16> </line-16>
<line-17> max=max+K </line-17>
<line-19> </line-19>
<line-20> print(abs(max-min))</line-20>
|
{"code": "<line-2>testcases=int(input())</line-2>\n<line-18> min=min-K</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> if(a==b):</line-3>
<line-4> print('YES')</line-4>
<line-5> elif(c==d):</line-5>
<line-6> print('NO')</line-6>
<line-7> </line-7>
<line-8> else:</line-8>
<line-9> if(abs(a-b)%abs(c-d)==0):</line-9>
<line-10> print('YES')</line-10>
<line-12> print('NO')</line-12>
|
{"code": "<line-2> a,b,c,d=list(map(int,input().split()))</line-2>\n<line-11> else:</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> if x>0:</line-3>
<line-4> a=list(map(int,input().split()))</line-4>
<line-5> if y>0:</line-5>
<line-6> b=list(map(int,input().split()))</line-6>
<line-7> if x>0 and y>0:</line-7>
<line-8> a=a+b</line-8>
<line-9> c=n-len(list(set(a)))</line-9>
<line-10> else:</line-10>
<line-11> l=x+y</line-11>
<line-12> c=n-l</line-12>
<line-14> print(x)</line-14>
|
{"code": "<line-2> n,r,x,y=map(int,input().split())</line-2>\n<line-13> x=min(c,r)</line-13>", "lines": [2, 13]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>stringa=list(map(int,input().split()))</line-3>
<line-4>counter=0</line-4>
<line-5>counter1=0</line-5>
<line-6>counter3=0</line-6>
<line-7>somma1=0</line-7>
<line-8>somma2=0</line-8>
<line-9>massimo=0</line-9>
<line-10>massimo1=0</line-10>
<line-11>massimo3=0 </line-11>
<line-12>stack=[]</line-12>
<line-13>for par in stringa:</line-13>
<line-14> if par==1 or par==3:</line-14>
<line-15> if counter1==0 and par==1:</line-15>
<line-16> counter1=1</line-16>
<line-17> somma1=1</line-17>
<line-18> massimo1=max(massimo1, 1)</line-18>
<line-19> elif counter1>0:</line-19>
<line-20> counter1+=1 </line-20>
<line-21> somma1+=1</line-21>
<line-22> massimo1=max(massimo1, somma1)</line-22>
<line-23> if counter3==0 and par==3:</line-23>
<line-24> counter3=1</line-24>
<line-25> somma3=1</line-25>
<line-26> massimo3=max(massimo3, 1)</line-26>
<line-27> elif counter3>0:</line-27>
<line-28> counter3+=1</line-28>
<line-29> somma3+=1</line-29>
<line-30> massimo3=max(massimo3, somma3)</line-30>
<line-31> if counter==0:</line-31>
<line-32> counter=1 </line-32>
<line-33> massimo=max(massimo,1)</line-33>
<line-34> if len(stack)>0 and par!=stack[-1]:</line-34>
<line-35> counter+=1 </line-35>
<line-36> massimo=max(massimo,counter)</line-36>
<line-37> stack.append(par)</line-37>
<line-38> else:</line-38>
<line-39> if counter1>0:</line-39>
<line-40> counter1-=1 </line-40>
<line-41> somma1+=1</line-41>
<line-42> massimo1=max(massimo1, somma1)</line-42>
<line-43> if counter3>0:</line-43>
<line-44> counter3-=1 </line-44>
<line-45> somma3+=1</line-45>
<line-46> massimo3=max(massimo3, somma3)</line-46>
<line-47> appo=stack.pop()</line-47>
<line-48> if len(stack)>0 and appo==stack[-1]:</line-48>
<line-49> pass</line-49>
<line-50> else:</line-50>
<line-52>print(massimo, massimo1, massimo3)</line-52>
|
{"code": "<line-2>n=int(input())</line-2>\n<line-51> counter-=1</line-51>", "lines": [2, 51]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> for _ in range(int(input())):</line-3>
<line-4> n = int(input())</line-4>
<line-5> li = [i for i in input()]</line-5>
<line-6> a = 0</line-6>
<line-7> while a+1<len(li):</line-7>
<line-8> li[a],li[a+1] = li[a+1],li[a]</line-8>
<line-9> a+=2</line-9>
<line-10> li2 = li.copy()</line-10>
<line-11> for i in li2:</line-11>
<line-12> fh = 109</line-12>
<line-13> sh = 110</line-13>
<line-14> li.remove(i)</line-14>
<line-15> if ord(i)>fh:</line-15>
<line-16> li.append(chr(fh-(ord(i)-sh)))</line-16>
<line-17> else:</line-17>
<line-18> li.append(chr(sh+(fh-ord(i))))</line-18>
<line-19> for i in li:</line-19>
<line-20> print(i,end="")</line-20>
<line-21> print()</line-21>
<line-23> pass </line-23>
|
{"code": "<line-2>try:</line-2>\n<line-22>except:</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> if(n<=2 or n>1000000007):</line-3>
<line-4> print("0")</line-4>
<line-5> else:</line-5>
<line-6> prod=1</line-6>
<line-7> for i in range(2,n):</line-7>
<line-8> prod*=i</line-8>
<line-9> if(prod>1000000007):</line-9>
<line-11> print(((prod)*(n*prod-2))%1000000007)</line-11>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-10> prod=prod%1000000007</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>def for1(M,k):</line-1>
<line-3> x = k*k+0.0</line-3>
<line-4> z=x</line-4>
<line-5> for m in range(1,M):</line-5>
<line-6> ret+=(M-m)/x</line-6>
<line-7> x*=z</line-7>
<line-8> return ret </line-8>
<line-9> </line-9>
<line-10>def for2(M,k):</line-10>
<line-11> ret = 0.0</line-11>
<line-12> x = k+0.0</line-12>
<line-13> for m in range(1,M):</line-13>
<line-14> ret+=(M-m)/x</line-14>
<line-15> </line-15>
<line-16> x*=k</line-16>
<line-17> return ret </line-17>
<line-18> </line-18>
<line-19>def ans(M,N,K):</line-19>
<line-20></line-20>
<line-21> return int(round(M*N+M*for2(N,K)+N*for2(M,K)+K*for1(M,K)*for1(N,K),0))</line-21>
<line-23>print(ans(M,N,K)) </line-23>
|
{"code": "<line-2> ret = 0.0</line-2>\n<line-22>M,N,K = list(map(int,input().split()))</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>for t in range(int(input())):</line-1>
<line-3> ans = 0</line-3>
<line-4> while n>0:</line-4>
<line-5> ans+=b</line-5>
<line-6> half = (n+1)/2 if n%2 else n/2</line-6>
<line-7> ans+=m*half</line-7>
<line-8> m*=2</line-8>
<line-10> print(ans-b)</line-10>
<line-11> </line-11>
|
{"code": "<line-2> n,b,m = list(map(int,input().split()))</line-2>\n<line-9> n=n-half</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>t=eval(input())</line-1>
<line-3> l=eval(input())</line-3>
<line-4> a=input().split()</line-4>
<line-5> a=[int(x) for x in a]</line-5>
<line-6> a=sorted(a)</line-6>
<line-7> for i in range(l-1):</line-7>
<line-9> print(min(a[0:l-1]))</line-9>
|
{"code": "<line-2>for q in range(t):</line-2>\n<line-8> a[i]=(a[i+1]-a[i]) </line-8>", "lines": [2, 8]}
#### 0
|
<line-1># cook your code here</line-1>
<line-3>x=len(n)</line-3>
<line-4>no=list(map(int,n))</line-4>
<line-5>temp=[0]*x</line-5>
<line-6>if (x>2):</line-6>
<line-7> sum=99</line-7>
<line-8> for i in range(3,x):</line-8>
<line-9> sum=sum+90</line-9>
<line-10> sum=sum+10*(int(n[0])-1)</line-10>
<line-11> sum=sum+int(n[1])</line-11>
<line-12> f=int(n[0])%10</line-12>
<line-13> </line-13>
<line-14> s=int(n[1])%10</line-14>
<line-15> </line-15>
<line-16> cd=s-f</line-16>
<line-17> </line-17>
<line-18> temp[0]=n[0]</line-18>
<line-19> temp[1]=n[1]</line-19>
<line-20> for i in range(2,x):</line-20>
<line-21> nxt=(s+cd)%10</line-21>
<line-22> temp[i]=(chr(nxt+48))</line-22>
<line-23> s=nxt</line-23>
<line-24> temp=list(map(int,temp))</line-24>
<line-25> if(temp<=no):</line-25>
<line-26> sum=sum+1</line-26>
<line-27> print(sum)</line-27>
<line-29> print(n)</line-29>
|
{"code": "<line-2>n=input()</line-2>\n<line-28>else:</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>s = sys.stdin.readline().strip()</line-4>
<line-5></line-5>
<line-6>alph = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"</line-6>
<line-7></line-7>
<line-8>arr = [0]*26</line-8>
<line-9>pref = []</line-9>
<line-10></line-10>
<line-11>for i in range(len(s)):</line-11>
<line-12> for j in range(26):</line-12>
<line-13> if alph[j] == s[i]:</line-13>
<line-14> arr[j] += 1</line-14>
<line-15> break</line-15>
<line-16> pref += [arr[:]]</line-16>
<line-17></line-17>
<line-18># for x in pref:</line-18>
<line-19># print(x)</line-19>
<line-20></line-20>
<line-21>q = int(sys.stdin.readline().strip())</line-21>
<line-22></line-22>
<line-23>for _ in range(q):</line-23>
<line-24> r, c = sys.stdin.readline().strip().split()</line-24>
<line-25></line-25>
<line-26> for i in range(26):</line-26>
<line-27> if alph[i] == c:</line-27>
<line-28> ind = i</line-28>
<line-29> break</line-29>
<line-30></line-30>
<line-31> r = int(r)</line-31>
<line-32></line-32>
<line-33> prev = ((r-1)**2 + r-1)//2</line-33>
<line-34></line-34>
<line-35> done = prev%len(s)</line-35>
<line-36></line-36>
<line-37> ans = 0</line-37>
<line-38> rem = (len(s) - done)%len(s)</line-38>
<line-39></line-39>
<line-40> if r <= rem:</line-40>
<line-41> print(pref[done+r-1][ind] - pref[done-1][ind])</line-41>
<line-42> continue</line-42>
<line-43></line-43>
<line-44> if rem != 0:</line-44>
<line-45> ans += pref[-1][ind] - pref[done-1][ind]</line-45>
<line-46> r -= rem</line-46>
<line-47></line-47>
<line-48> ans += pref[-1][ind] * (r//len(s))</line-48>
<line-49> r %= len(s)</line-49>
<line-50></line-50>
<line-51> # print("AA", ans, r)</line-51>
<line-52></line-52>
<line-53> if r != 0:</line-53>
<line-54> ans += pref[r-1][ind]</line-54>
<line-55></line-55>
<line-57></line-57>
<line-58></line-58>
<line-59> # print(rem, done, prev)</line-59>
|
{"code": "<line-3>n = int(sys.stdin.readline().strip())</line-3>\n<line-56>\tprint(ans)</line-56>", "lines": [3, 56]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> l = list(map(int, input().split()))</line-4>
<line-5> counter = 0</line-5>
<line-6> even = 0</line-6>
<line-7> for num in l:</line-7>
<line-8> if num % 2 == 0:</line-8>
<line-9> even += 1 </line-9>
<line-10> if num % 2 == 1:</line-10>
<line-12> print(counter)</line-12>
<line-13> </line-13>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-11> counter += even</line-11>", "lines": [2, 11]}
#### 0
|
<line-1># coding: utf-8</line-1>
<line-3></line-3>
<line-4>n=int(input())</line-4>
<line-5>a=[]</line-5>
<line-6>for i in range(n):</line-6>
<line-7> x=int(input())</line-7>
<line-8> a.append(x)</line-8>
<line-9> </line-9>
<line-10># print(a)</line-10>
<line-11>ans=0</line-11>
<line-12>m=[1]*n</line-12>
<line-13>for i in range(n):</line-13>
<line-14> for j in range(i):</line-14>
<line-15> if a[i]%a[j]==0:</line-15>
<line-17> </line-17>
<line-18> </line-18>
<line-19> </line-19>
<line-20>print(max(m))</line-20>
|
{"code": "<line-2># Your code here!</line-2>\n<line-16> m[i]=max(m[i],m[j]+1)</line-16>", "lines": [2, 16]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.