question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1>import math</line-1>
<line-2></line-2>
<line-4> #print("enter i, k, s")</line-4>
<line-5> IN = '11 6 5'</line-5>
<line-6> z = IN.split()</line-6>
<line-7> z = input().split()</line-7>
<line-8> i = int(z[0])</line-8>
<line-9> k = int(z[1])</line-9>
<line-10> s = int(z[2])</line-10>
<line-11></line-11>
<line-12> #print("enter a_i and b_i")</line-12>
<line-13> IN = '4 5'</line-13>
<line-14> z = IN.split()</line-14>
<line-15> z = input().split()</line-15>
<line-16> a_i = int(z[0])</line-16>
<line-17> b_i = int(z[1])</line-17>
<line-18></line-18>
<line-19> #print( "i = %d k = %d s = %d " % (i, k, s) )</line-19>
<line-20> #print( "a_i = %d b_i = %d" % (a_i, b_i) )</line-20>
<line-21></line-21>
<line-22> x = math.sqrt(2)</line-22>
<line-23> y = math.sqrt(3)</line-23>
<line-24> #print(x,y)</line-24>
<line-25></line-25>
<line-26> # Obtaining the k-th element when k >= i</line-26>
<line-27> if(i<=k):</line-27>
<line-28> diff = k-i</line-28>
<line-29> #if both k and i are odd or even</line-29>
<line-30> if(k-i)%2==0:</line-30>
<line-31> #print("#1")</line-31>
<line-32> ans = (a_i + b_i) * math.pow(2,2*(k-i)-s)</line-32>
<line-33> #diff = int(diff/2) </line-33>
<line-34> #ans = (a_i + b_i) * math.pow(2,4*diff-s)</line-34>
<line-35> </line-35>
<line-36> #if i and k are of different parities then obtaining first</line-36>
<line-37> # a_(i+1) and b_(i+1)</line-37>
<line-38> else:</line-38>
<line-39> #print("#2")</line-39>
<line-40> ans = (2*x*a_i + 2*x*y*b_i) * math.pow(2,2*(k-(i+1))-s )</line-40>
<line-41> diff = int(diff/2)</line-41>
<line-42> ans = (2*x*a_i + 2*x*y*b_i) * math.pow(2,4*diff - s)</line-42>
<line-43> #print("1: ", (2*x*a_i + 2*x*y*b_i))</line-43>
<line-44> #print("2: ", math.pow(2,4*diff - 2- s)) </line-44>
<line-45> #print("2 sol: ", math.pow(2,4*int(diff)-s))</line-45>
<line-46> #print("diff: ",diff)</line-46>
<line-47></line-47>
<line-48></line-48>
<line-49> # Obtaining the k_th element when k < i</line-49>
<line-50> else:</line-50>
<line-51> diff = i-k</line-51>
<line-52> #if both k and i are odd or even</line-52>
<line-53> if(i-k)%2==0:</line-53>
<line-54> #print("#3")</line-54>
<line-55> ans = (a_i + b_i) / math.pow(2,2*(i-k)+s)</line-55>
<line-56> #diff = int(diff/2)</line-56>
<line-57> #ans = (a_i + b_i) / math.pow(2,4*diff+s)</line-57>
<line-58></line-58>
<line-59> #if i and k are of different parities then obtaining first</line-59>
<line-60> # a_(i+1) and b_(i+1)</line-60>
<line-61> else:</line-61>
<line-62> #print("#4")</line-62>
<line-63> ans = (2*x*a_i + 2*x*y*b_i) / math.pow(2,2*(i+1-k)+s)</line-63>
<line-64> diff = int(diff/2)</line-64>
<line-65> ans = (2*x*a_i + 2*x*y*b_i) / math.pow(2,4*diff + 4 + s)</line-65>
<line-66></line-66>
<line-67></line-67>
<line-69> </line-69>
<line-70>main()</line-70>
|
{"code": "<line-3>def main():</line-3>\n<line-68> print(ans)</line-68>", "lines": [3, 68]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3>l=['a','e','i','o','u']</line-3>
<line-4>for i in range(t):</line-4>
<line-5> s=input()</line-5>
<line-6> k=[]</line-6>
<line-7> for j in s:</line-7>
<line-8> if j in l:</line-8>
<line-9> k.append(1)</line-9>
<line-10> else:</line-10>
<line-11> k.append(0)</line-11>
<line-13> print((int(r,2)//2)%MOD)</line-13>
|
{"code": "<line-2>MOD=(10**9)+7</line-2>\n<line-12> r=bin(int(''.join(map(str, k)), 2) << 1)</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n,m=map(int,input().split())</line-3>
<line-4> mat=[0 for i in range(n)]</line-4>
<line-5> #mat=[[0 for i in range(n)] for j in range(n)]</line-5>
<line-6> for i in range(m):</line-6>
<line-7> u,v=map(int,input().split())</line-7>
<line-8> u,v=(u-1),(v-1)</line-8>
<line-9> mat[u]|=(1<<v)</line-9>
<line-10> mat[v]|=(1<<u)</line-10>
<line-11> for i in range(n):</line-11>
<line-12> mat[i]|=(1<<i) </line-12>
<line-13> </line-13>
<line-14> goal=(2**n)-1</line-14>
<line-15> ans=n</line-15>
<line-16></line-16>
<line-17> for i in range(1,goal+1):</line-17>
<line-18> mvs=0</line-18>
<line-19> loc=0</line-19>
<line-20> for j in range(n):</line-20>
<line-21> if(i&(1<<j)):</line-21>
<line-22> loc|=mat[j]</line-22>
<line-23> mvs+=1</line-23>
<line-24> if(loc==goal):</line-24>
<line-26> print(ans)</line-26>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-25> ans=min(mvs,ans)</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> </line-4>
<line-5> n=int(input())</line-5>
<line-6> if(n<=0):</line-6>
<line-7> print(0)</line-7>
<line-8> </line-8>
<line-9> fact=1</line-9>
<line-10> start=1</line-10>
<line-11> for i in range(1,n+1):</line-11>
<line-12> fact*=start</line-12>
<line-13> start+=2</line-13>
<line-15> </line-15>
<line-16> t=t-1</line-16>
|
{"code": "<line-3>while(t>0):</line-3>\n<line-14> print(fact)</line-14>", "lines": [3, 14]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>y=len (x)</line-3>
<line-4>if y==1:</line-4>
<line-5> print('1')</line-5>
<line-6>elif y==2:</line-6>
<line-7> print('2')</line-7>
<line-8>elif y==3:</line-8>
<line-9> print('3')</line-9>
<line-11> print('More than 3 digits')</line-11>
|
{"code": "<line-2>x=input ()</line-2>\n<line-10>elif y>3:</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>#-*- coding:utf-8 -*-</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5></line-5>
<line-6># class Point:</line-6>
<line-7># def __init__(self, x, y):</line-7>
<line-8># self.x = x</line-8>
<line-9># self.y = y</line-9>
<line-10></line-10>
<line-11># def mul(self, k):</line-11>
<line-12># return Point(k * self.x, k * self.y)</line-12>
<line-13></line-13>
<line-14># def __add__(self, other):</line-14>
<line-15># return Point(self.x + other.x, self.y + other.y)</line-15>
<line-16></line-16>
<line-17># def __sub__(self, other):</line-17>
<line-18># return self + (-other)</line-18>
<line-19></line-19>
<line-20># def __neg__(self):</line-20>
<line-21># return Point(-self.x, -self.y)</line-21>
<line-22></line-22>
<line-23># def __eq__(self, other):</line-23>
<line-24># return self.x == other.x and self.y == other.y</line-24>
<line-25></line-25>
<line-26># def __getitem__(self, index):</line-26>
<line-27># return (self.x, self.y)[index]</line-27>
<line-28></line-28>
<line-29># def __str__(self):</line-29>
<line-30># return "(%d;%d)" % (self.x, self.y)</line-30>
<line-31></line-31>
<line-32></line-32>
<line-33>DIRS = dict(</line-33>
<line-34> U=(0, 1),</line-34>
<line-35> D=(0, -1),</line-35>
<line-36> R=(1, 0),</line-36>
<line-37> L=(-1, 0)</line-37>
<line-38>)</line-38>
<line-39>KOEF = 0.2</line-39>
<line-40></line-40>
<line-41></line-41>
<line-42>def div(a, b):</line-42>
<line-43> return round(float(a) / b, 1)</line-43>
<line-44></line-44>
<line-45></line-45>
<line-46># class Moving:</line-46>
<line-47># def __init__(self, x, y, dir):</line-47>
<line-48># self.p = Point(x, y)</line-48>
<line-49># self.dir = Point(*DIRS[dir.upper()])</line-49>
<line-50></line-50>
<line-51># def collide(self, other):</line-51>
<line-52># times = []</line-52>
<line-53># for coord in range(2):</line-53>
<line-54># d = abs(self.p[coord] - other.p[coord])</line-54>
<line-55># d2 = abs((self.p + self.dir.mul(KOEF) - other.p)[coord])</line-55>
<line-56># d3 = abs((other.p + other.dir.mul(KOEF) - self.p)[coord])</line-56>
<line-57># d_next = abs((self.p + self.dir.mul(KOEF) - (other.p + other.dir .mul(KOEF)))[coord])</line-57>
<line-58># if d2 > d or d3 > d:</line-58>
<line-59># return None</line-59>
<line-60></line-60>
<line-61># speed = abs(d_next - d)</line-61>
<line-62># if speed == 0:</line-62>
<line-63># if self.p[coord] != other.p[coord]:</line-63>
<line-64># return None</line-64>
<line-65># continue</line-65>
<line-66># times.append( div(d, speed / KOEF) )</line-66>
<line-67></line-67>
<line-68># if len(times) == 2 and times[0] != times[1]:</line-68>
<line-69># return</line-69>
<line-70># return times[0]</line-70>
<line-71></line-71>
<line-72></line-72>
<line-73>def collide_coord(ex, edx, x, dx):</line-73>
<line-74> d = abs(ex - x)</line-74>
<line-75> d2 = abs(ex + edx - x)</line-75>
<line-76> d3 = abs(ex - x - dx)</line-76>
<line-77> if d2 > d or d3 > d:</line-77>
<line-78> return False</line-78>
<line-79></line-79>
<line-80> d_next = abs(ex + edx * KOEF - x - dx * KOEF)</line-80>
<line-81> speed = abs(d_next - d)</line-81>
<line-82> if speed == 0:</line-82>
<line-83> if ex != x:</line-83>
<line-84> return</line-84>
<line-85> return "all" # all</line-85>
<line-86> else:</line-86>
<line-87> return div(d, speed / KOEF)</line-87>
<line-88></line-88>
<line-89></line-89>
<line-90>def main():</line-90>
<line-91> t = int(input())</line-91>
<line-92> for _ in range(t):</line-92>
<line-93> ex, ey, dir = sys.stdin.readline().strip().split()</line-93>
<line-94> ex = int(ex)</line-94>
<line-95> ey = int(ey)</line-95>
<line-96> edx, edy = DIRS[dir]</line-96>
<line-97></line-97>
<line-98> n = int(sys.stdin.readline())</line-98>
<line-99> min_time = float("+inf")</line-99>
<line-100> for _ in range(n):</line-100>
<line-101> x, y, dir = sys.stdin.readline().strip().split()</line-101>
<line-102> x = int(x)</line-102>
<line-103> y = int(y)</line-103>
<line-104> dx, dy = DIRS[dir]</line-104>
<line-105></line-105>
<line-106> tx = collide_coord(ex, edx, x, dx)</line-106>
<line-107> if tx is False:</line-107>
<line-108> continue</line-108>
<line-109> ty = collide_coord(ey, edy, y, dy)</line-109>
<line-110> if ty is False:</line-110>
<line-111> continue</line-111>
<line-112></line-112>
<line-113> if tx == "all":</line-113>
<line-114> min_time = min(min_time, ty)</line-114>
<line-115> elif ty == "all":</line-115>
<line-116> min_time = min(min_time, tx)</line-116>
<line-117> elif tx == ty:</line-117>
<line-118> min_time = min(min_time, tx)</line-118>
<line-119></line-119>
<line-120> print(min_time if min_time < 1000000 else "SAFE")</line-120>
<line-121></line-121>
<line-122></line-122>
<line-123>def __starting_point():</line-123>
<line-125></line-125>
<line-126>__starting_point()</line-126>
|
{"code": "<line-3>import sys</line-3>\n<line-124> main()</line-124>", "lines": [3, 124]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>inp=list(map(int, input().split()))</line-3>
<line-4>n, m, w, b = inp[:4]</line-4>
<line-5>stops=[]</line-5>
<line-6>for i in range(w):</line-6>
<line-7> stops.append((inp[4+2*i]-1,inp[5+2*i]-1,'w'))</line-7>
<line-8>for i in range(b):</line-8>
<line-9> stops.append((inp[4+2*w+2*i]-1,inp[5+2*w+2*i]-1,'b'))</line-9>
<line-10>stops.sort(key=itemgetter(1))</line-10>
<line-11>stops.sort(key=itemgetter(0))</line-11>
<line-12>counter=0</line-12>
<line-13>stop_rows=[[] for _ in range(n)]</line-13>
<line-14>for stop in stops:</line-14>
<line-15> stop_rows[stop[0]].append(stop[1:])</line-15>
<line-16>for row in stop_rows:</line-16>
<line-17> idx=0</line-17>
<line-18> for i in range(len(row)):</line-18>
<line-19> if idx==row[i][0]:</line-19>
<line-20> idx+=1</line-20>
<line-21> else:</line-21>
<line-22> if row[i][1]=='w':</line-22>
<line-23> if i<len(row)-1:</line-23>
<line-24> num=row[i+1][0]-idx+1</line-24>
<line-25> counter+=((num*(num+1))>>1)-1</line-25>
<line-26> idx=row[i][0]+1</line-26>
<line-27> num=row[i+1][0]-row[i][0]+1</line-27>
<line-28> counter-=((num*(num+1))>>1)-1</line-28>
<line-29> else:</line-29>
<line-30> num=m-idx</line-30>
<line-31> counter+=((num*(num+1))>>1)-1</line-31>
<line-32> idx=row[i][0]+1</line-32>
<line-33> num=m-row[i][0]</line-33>
<line-34> counter-=((num*(num+1))>>1)-1</line-34>
<line-35> else:</line-35>
<line-36> num=row[i][0]-idx+1</line-36>
<line-37> counter+=((num*(num+1))>>1)-1</line-37>
<line-38> idx=row[i][0]+1</line-38>
<line-39> num=m-idx</line-39>
<line-41>print(counter)</line-41>
|
{"code": "<line-2>from operator import itemgetter</line-2>\n<line-40> counter+=(num*(num+1))>>1</line-40>", "lines": [2, 40]}
#### 0
|
<line-1>def update_B(B, query):</line-1>
<line-3> for i in range(len(R)):</line-3>
<line-4> B[p][i] = R[i]</line-4>
<line-5> B[i][p] = R[i]</line-5>
<line-6></line-6>
<line-7>def get_A(B):</line-7>
<line-8> N = len(B)</line-8>
<line-9> A = [0] * N</line-9>
<line-10> i = 0</line-10>
<line-11> for j in range(N):</line-11>
<line-12> if B[0][j] != 0:</line-12>
<line-13> i = j</line-13>
<line-14> A[i] = -B[0][i]</line-14>
<line-15> break</line-15>
<line-16></line-16>
<line-17> for j in range(i + 1, N):</line-17>
<line-18> if abs(A[i] - B[0][j]) == B[i][j]:</line-18>
<line-19> A[j] = B[0][j]</line-19>
<line-20> else:</line-20>
<line-21> A[j] = -B[0][j]</line-21>
<line-22></line-22>
<line-23> return A</line-23>
<line-24></line-24>
<line-25>def print_list(A):</line-25>
<line-26> print(' '.join([str(a) for a in get_A(B)]))</line-26>
<line-27></line-27>
<line-28></line-28>
<line-29>N, Q = [int(x) for x in input().rstrip().split()]</line-29>
<line-30>B = []</line-30>
<line-31>for i in range(N):</line-31>
<line-32> B += [[int(x) for x in input().rstrip().split()]]</line-32>
<line-33>queries = []</line-33>
<line-34>for i in range(Q):</line-34>
<line-35> p = int(input()) - 1</line-35>
<line-36> arr = input().rstrip().split()</line-36>
<line-37> queries += [(p, [int(x) for x in arr])]</line-37>
<line-38></line-38>
<line-39>print_list(get_A(B))</line-39>
<line-40>for q in queries:</line-40>
<line-42> print_list(' '.join([str(a) for a in get_A(B)]))</line-42>
|
{"code": "<line-2> p, R = query</line-2>\n<line-41> update_B(B, q)</line-41>", "lines": [2, 41]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>input=sys.stdin.readline</line-3>
<line-4>def main():</line-4>
<line-5> T=int(input())</line-5>
<line-6> for _ in range(T):</line-6>
<line-7> N,K=map(int,input().split())</line-7>
<line-8> Tree={}</line-8>
<line-9> for j in range(N):</line-9>
<line-10> Tree[j]=[]</line-10>
<line-11> </line-11>
<line-12> for i in range(N-1):</line-12>
<line-13> u,v=map(int,input().split())</line-13>
<line-14> Tree[u-1].append(v-1)</line-14>
<line-15> Tree[v-1].append(u-1)</line-15>
<line-16> </line-16>
<line-17> A=list(map(int,input().split()))</line-17>
<line-18> </line-18>
<line-19> vis=[0 for i in range(N)] #to mark visited vertices 0 for visited and 1 for not visited</line-19>
<line-20> maxval=[[0,0] for i in range(N)] #Nx2 list where each i stores max value till now and its count </line-20>
<line-21> minval=[0 for i in range(N)] #Nx2 list where each i stores min value till now </line-21>
<line-22> lfnode=[] #list to store leaf nodes</line-22>
<line-23> </line-23>
<line-24> #Appending node 1</line-24>
<line-25> vis[0]=1</line-25>
<line-26> Q=collections.deque([0])</line-26>
<line-27> maxval[0][0],maxval[0][1]=A[0],1</line-27>
<line-28> minval[0]=A[0]</line-28>
<line-29> </line-29>
<line-30> </line-30>
<line-31> while(len(Q)!=0):</line-31>
<line-32> a=Q.pop()</line-32>
<line-33> mv1=maxval[a][0]</line-33>
<line-34> mv2=minval[a]</line-34>
<line-35> </line-35>
<line-36> flag=0 #to check leaf node</line-36>
<line-37> </line-37>
<line-38> for i in Tree[a]:</line-38>
<line-39> if (vis[i]==0):</line-39>
<line-40> vis[i]=1</line-40>
<line-41> flag=1 #not a leaf node</line-41>
<line-42> v=A[i]</line-42>
<line-43> Q.append(i)</line-43>
<line-44> </line-44>
<line-45> #Comparing maximum value of parent node</line-45>
<line-46> if (mv1<v):</line-46>
<line-47> maxval[i][0],maxval[i][1]=v,1</line-47>
<line-48> </line-48>
<line-49> elif(mv1==v):</line-49>
<line-50> maxval[i][0],maxval[i][1]=mv1,maxval[a][1]+1</line-50>
<line-51> </line-51>
<line-52> else:</line-52>
<line-53> maxval[i][0],maxval[i][1]=maxval[a][0],maxval[a][1]</line-53>
<line-54> </line-54>
<line-55> </line-55>
<line-56> #Comparing minimum value of parent node</line-56>
<line-57> if (mv2>v):</line-57>
<line-58> minval[i]=v</line-58>
<line-59> elif(v==mv2):</line-59>
<line-60> minval[i]=mv2</line-60>
<line-61> else:</line-61>
<line-62> minval[i]=minval[a]</line-62>
<line-63> </line-63>
<line-64> </line-64>
<line-65> if (flag==0):</line-65>
<line-66> lfnode.append(a)</line-66>
<line-67> </line-67>
<line-68> </line-68>
<line-69> flag=0 #For answer if 0 then NO else YES</line-69>
<line-70> </line-70>
<line-71> K1=len(bin(K))-2 #length of K</line-71>
<line-72> </line-72>
<line-73> #print(lfnode,val)</line-73>
<line-74> for i in lfnode:</line-74>
<line-75> v1,v2=maxval[i][0],maxval[i][1]</line-75>
<line-76> </line-76>
<line-77> if (v1>K1 and v2%2==0):</line-77>
<line-78> flag=1</line-78>
<line-79> elif(v1==K1 and v2%2==1):</line-79>
<line-80> flag=1</line-80>
<line-81> </line-81>
<line-82> </line-82>
<line-83> v11=minval[i]</line-83>
<line-84> if (v11>K1 and v11!=v1):</line-84>
<line-85> flag=1</line-85>
<line-86> elif(v11==K1):</line-86>
<line-87> flag=1</line-87>
<line-88> </line-88>
<line-89> </line-89>
<line-90> if(flag==1):</line-90>
<line-91> break</line-91>
<line-92> </line-92>
<line-93> if (flag==1):</line-93>
<line-94> print("YES")</line-94>
<line-95> else:</line-95>
<line-97>main()</line-97>
|
{"code": "<line-2>import sys,collections</line-2>\n<line-96> print(\"NO\")</line-96>", "lines": [2, 96]}
#### 0
|
<line-1>mod=10**9+7</line-1>
<line-3> if n < 0:</line-3>
<line-4> raise ValueError("Negative arguments not implemented")</line-4>
<line-5> return (_fib(n)[0]%mod + mod)%mod;</line-5>
<line-6>def _fib(n):</line-6>
<line-7> if n == 0:</line-7>
<line-8> return (0, 1)</line-8>
<line-9> else:</line-9>
<line-10> a, b = _fib(n // 2)</line-10>
<line-11> c = (a * (b * 2 - a))%mod</line-11>
<line-12> d = (a * a + b * b)%mod</line-12>
<line-13> if n % 2 == 0:</line-13>
<line-14> return (c, d)</line-14>
<line-15> else:</line-15>
<line-16> return (d, c + d)</line-16>
<line-17>def inv(n):</line-17>
<line-18> return pow(n,mod-2,mod)</line-18>
<line-19>def brute(n,k):</line-19>
<line-20> ret = 0</line-20>
<line-21> for i in range(0,n+1):</line-21>
<line-22> ret+=fibonacci(i)*pow(k,i,mod)</line-22>
<line-23> return ret%mod</line-23>
<line-24>def ans(n,k):</line-24>
<line-25> k%=mod</line-25>
<line-26> a = pow(k,n+1,mod)</line-26>
<line-27> b=(a*k)%mod</line-27>
<line-28> x = a*(fibonacci(n+1))+b*fibonacci(n)-k</line-28>
<line-29> y = inv((k*k+k-1)%mod)</line-29>
<line-30> return ((x*y)%mod+mod)%mod</line-30>
<line-31>for t in range(0,eval(input())):</line-31>
<line-33> print(ans(n,k))</line-33>
|
{"code": "<line-2>def fibonacci(n):</line-2>\n<line-32> n,k = list(map(int,input().split()))</line-32>", "lines": [2, 32]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>MOD = 10**9+7</line-4>
<line-5></line-5>
<line-6>fac = [0]*(10**5+1)</line-6>
<line-7>def pre() :</line-7>
<line-8> fac[0] = 1</line-8>
<line-9> for i in range(1,10**5+1) :</line-9>
<line-10> fac[i] = fac[i-1]*i</line-10>
<line-11> fac[i] = fac[i]%MOD</line-11>
<line-12></line-12>
<line-13>def dfs(gp , vertex , visited , deg , ans) :</line-13>
<line-14> visited[vertex] = 1</line-14>
<line-15> stack = []</line-15>
<line-16> stack.append(vertex)</line-16>
<line-17> while len(stack)>0 :</line-17>
<line-18> vertex = stack.pop()</line-18>
<line-19> ans = ans%MOD * fac[deg[vertex]]%MOD</line-19>
<line-20> ans %= MOD</line-20>
<line-21> for i in gp[vertex] :</line-21>
<line-22> if not visited[i] :</line-22>
<line-23> visited[i] = 1</line-23>
<line-24> if vertex in gp[i] :</line-24>
<line-25> deg[i] -= 1</line-25>
<line-26> stack.append(i)</line-26>
<line-27> return ans%MOD</line-27>
<line-28></line-28>
<line-29>pre()</line-29>
<line-30>for __ in range(eval(input())) :</line-30>
<line-31> n = eval(input())</line-31>
<line-32> deg = [0]*(n+1)</line-32>
<line-33> st = [[] for __ in range(n+1)]</line-33>
<line-34> for _ in range(n-1) :</line-34>
<line-35> a , b = list(map(int,sys.stdin.readline().split()))</line-35>
<line-36> st[a].append(b)</line-36>
<line-37> st[b].append(a)</line-37>
<line-38> deg[a] += 1</line-38>
<line-39> deg[b] += 1</line-39>
<line-40> k = eval(input())</line-40>
<line-42> print(dfs(st ,k,visited,deg , 1)%MOD)</line-42>
<line-43> </line-43>
|
{"code": "<line-2>sys.setrecursionlimit(10**8)</line-2>\n<line-41> visited = [0]*(n+1)</line-41>", "lines": [2, 41]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> x, y= map(int, input().split())</line-3>
<line-4> if x<y:</line-4>
<line-5> print('<')</line-5>
<line-6> elif x>y:</line-6>
<line-7> print('>')</line-7>
<line-9> print('=')</line-9>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-8> else:</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> ar = list(map(int,input().strip().split(" ")))</line-4>
<line-6> t-=1</line-6>
|
{"code": "<line-2>while(t):</line-2>\n<line-5> print(len([x for x in ar[1:len(ar)] if ar[0]<x]))</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3>y=0</line-3>
<line-4>for _ in range(t):</line-4>
<line-5> n=int(input())</line-5>
<line-6> seq=[int(x) for x in input().split()]</line-6>
<line-7> prev=seq[0]</line-7>
<line-8> for i in range(1,len(seq)):</line-8>
<line-9> if prev==seq[i]:</line-9>
<line-10> seq[i]=0</line-10>
<line-11> prev=seq[i] </line-11>
<line-12> ans=0</line-12>
<line-13> anss=0</line-13>
<line-14> for el in seq:</line-14>
<line-15> if el!=0:</line-15>
<line-16> c=seq.count(el)</line-16>
<line-17> if ans<c:</line-17>
<line-18> ans=c</line-18>
<line-19> </line-19>
<line-20> anss=el</line-20>
<line-21> elif ans==c:</line-21>
<line-22> if el<anss:</line-22>
<line-23> anss=el</line-23>
<line-24> else:</line-24>
<line-26> print(anss)</line-26>
|
{"code": "<line-2>f=0</line-2>\n<line-25> anss=anss</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>from sys import stdin,stdout</line-1>
<line-3>for _ in range(int(stdin.readline())):</line-3>
<line-4> # n=int(stdin.readline()) k-pieces</line-4>
<line-5> n,k=list(map(int,stdin.readline().split()))</line-5>
<line-6> a=list(map(int,stdin.readline().split()))</line-6>
<line-7> gr=[[0 for _ in range(n)]for _ in range(n)];ans=0;k-=1</line-7>
<line-8> for sz in range(n):</line-8>
<line-9> for i in range(n-sz):</line-9>
<line-10> j=i+sz</line-10>
<line-11> if sz==0:gr[i][j]=a[i]</line-11>
<line-12> else:</line-12>
<line-13> gr[i][j]=gcd(gr[i+1][j],gr[i][j-1])</line-13>
<line-14> # print(*gr,sep='\n')</line-14>
<line-15> dp=[[0 for _ in range(n)]for _ in range(k+1)]</line-15>
<line-16> for i in range(n):</line-16>
<line-17> dp[0][i]=gr[0][i]</line-17>
<line-18> for i in range(1,k+1):</line-18>
<line-19> for j in range(i,n):</line-19>
<line-20> for par in range(j-1,-1,-1):</line-20>
<line-21> dp[i][j]=max(dp[i][j],gr[par+1][j]+dp[i-1][par])</line-21>
<line-23> print(dp[k][n-1])</line-23>
<line-24></line-24>
|
{"code": "<line-2>from math import gcd</line-2>\n<line-22> # print(*dp,sep='\\n')</line-22>", "lines": [2, 22]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>l=[]</line-3>
<line-4>for i in range(n):</line-4>
<line-5> a=int(input())</line-5>
<line-6> l.append(a)</line-6>
<line-7>for i in l:</line-7>
<line-8> b = list(map(int, str(i)))</line-8>
<line-9> b.sort(reverse=True)</line-9>
<line-10> s = [str(i) for i in b]</line-10>
<line-12> print(r)</line-12>
|
{"code": "<line-2>n=int(input())</line-2>\n<line-11> r = int(\"\".join(s))</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-2></line-2>
<line-4> n = int(stdin.readline())</line-4>
<line-5> n //= 2</line-5>
<line-7> print(k)</line-7>
|
{"code": "<line-3>for _ in range(int(stdin.readline())):</line-3>\n<line-6> k = 2 * int(n**0.5)</line-6>", "lines": [3, 6]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(int(input())):</line-3>
<line-4> n,k,m = tuple(map(int, input().split()))</line-4>
<line-5> a = list(map(int, input().split()))</line-5>
<line-6> ans = [0 for i in range(k+1)]</line-6>
<line-7> ans[0] = 1</line-7>
<line-8> curr_ending = 1</line-8>
<line-9> for i in range(n):</line-9>
<line-10> mod_a = a[i]%m</line-10>
<line-11> start = curr_ending - (curr_ending%m - mod_a)%m</line-11>
<line-12> if(mod_a == curr_ending%m and curr_ending<k):</line-12>
<line-13> curr_ending += 1</line-13>
<line-14> for i in range(start, 0, -m):</line-14>
<line-15> ans[i] += ans[i-1]</line-15>
<line-16> if(ans[i] > mod):</line-16>
<line-18> print(ans[k])</line-18>
|
{"code": "<line-2>mod = 10**9 + 7</line-2>\n<line-17> ans[i] = ans[i] - mod</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>import sys</line-1>
<line-3># from collections import Counter</line-3>
<line-4># from itertools import permutations</line-4>
<line-5># from functools import reduce</line-5>
<line-6># from heapq import nsmallest, nlargest, heapify, heappop, heappush, heapreplace</line-6>
<line-7></line-7>
<line-8>def get_inpt(): return sys.stdin.readline().strip()</line-8>
<line-9>def get_int(): return int(sys.stdin.readline().strip())</line-9>
<line-10>def get_ints(): return map(int, sys.stdin.readline().strip().split())</line-10>
<line-11>def get_array(): return list(map(int, sys.stdin.readline().strip().split()))</line-11>
<line-12></line-12>
<line-13># sys.setrecursionlimit(10**7)</line-13>
<line-14># INF = float('inf')</line-14>
<line-15># MOD1, MOD2 = 10**9+7, 998244353</line-15>
<line-16></line-16>
<line-17>n, k = get_ints()</line-17>
<line-18></line-18>
<line-19>for _ in range(k):</line-19>
<line-20> </line-20>
<line-21> arr = get_array()</line-21>
<line-22> </line-22>
<line-23> for i in reversed(range(n-1)):</line-23>
<line-24> </line-24>
<line-25> if arr[i] < arr[i+1]:</line-25>
<line-26> </line-26>
<line-27> ind = i+1</line-27>
<line-28> minn = arr[i+1]</line-28>
<line-29> for j in range(i+1, n):</line-29>
<line-30> if arr[j] > arr[i]:</line-30>
<line-31> minn = min(arr[j], minn)</line-31>
<line-32> ind = j</line-32>
<line-33> </line-33>
<line-34> arr[i], arr[ind] = arr[ind], arr[i]</line-34>
<line-35> </line-35>
<line-36> arr = arr[:i+1] + sorted(arr[i+1:])</line-36>
<line-37> </line-37>
<line-39> </line-39>
<line-40> print(*arr)</line-40>
|
{"code": "<line-2># import math as mt</line-2>\n<line-38> break</line-38>", "lines": [2, 38]}
#### 0
|
<line-1>res = []</line-1>
<line-3> lst = []</line-3>
<line-4> flag = 0</line-4>
<line-5> n = int(input())</line-5>
<line-6> for i in range(n):</line-6>
<line-7> lst.append(list(map(int, input().split())))</line-7>
<line-8> for i in lst:</line-8>
<line-9> for j in range(n-1):</line-9>
<line-10> if i[j] == i[j+1] == 1:</line-10>
<line-11> res.append("UNSAFE")</line-11>
<line-12> flag = 1</line-12>
<line-13> break</line-13>
<line-14> if flag != 0:</line-14>
<line-15> break</line-15>
<line-16> for i in range(n-1):</line-16>
<line-17> for j in range(n):</line-17>
<line-18> if lst[i][j] == lst[i+1] == 1:</line-18>
<line-19> res.append("UNSAFE")</line-19>
<line-20> flag = 1</line-20>
<line-21> break</line-21>
<line-22> if flag != 0:</line-22>
<line-23> break</line-23>
<line-24> if flag == 0:</line-24>
<line-25> res.append("SAFE")</line-25>
<line-27> print(i)</line-27>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-26>for i in res:</line-26>", "lines": [2, 26]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(int(input())):</line-3>
<line-4> s=input().upper()</line-4>
<line-5> res=Counter(s)</line-5>
<line-6> if res["L"]>=2 and res["T"]>=2 and res["I"]>=2 and res["M"]>=2 :</line-6>
<line-7> if len(s)==9:</line-7>
<line-8> if res["E"] >=1 :</line-8>
<line-9> print("YES")</line-9>
<line-10> else:</line-10>
<line-11> print("NO")</line-11>
<line-12> elif len(s)>9:</line-12>
<line-13> if res["E"]>=2:</line-13>
<line-14> print("YES")</line-14>
<line-15> else:</line-15>
<line-16> print("NO")</line-16>
<line-17> else:</line-17>
<line-18> print("NO")</line-18>
<line-20> print("NO")</line-20>
<line-21> </line-21>
|
{"code": "<line-2>from collections import Counter</line-2>\n<line-19> else:</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>T = int(input())</line-1>
<line-3> p,n=map(int,input().split())</line-3>
<line-4> mod = 1000000007</line-4>
<line-5> if p == 2:</line-5>
<line-6> print(n)</line-6>
<line-7> else:</line-7>
<line-8> f=n</line-8>
<line-9> t=n</line-9>
<line-10> for i in range(p-2):</line-10>
<line-11> f=(f%mod*n)%mod</line-11>
<line-12> a=(f-t+mod)%mod</line-12>
<line-14> print(a)</line-14>
|
{"code": "<line-2>for _ in range(T):</line-2>\n<line-13> t=a</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>import collections</line-1>
<line-2></line-2>
<line-4> d = input().strip()</line-4>
<line-5> myCounter = collections.Counter(d)</line-5>
<line-6> flag = 1</line-6>
<line-7></line-7>
<line-8> for x in list(myCounter.keys()):</line-8>
<line-9> if myCounter[x] > 1:</line-9>
<line-10> flag = 0</line-10>
<line-11> break</line-11>
<line-12></line-12>
<line-13> isAlp = sum([myCounter[x] for x in list(myCounter.keys()) if x.isalnum()])</line-13>
<line-14></line-14>
<line-15> if flag and isAlp:</line-15>
<line-16> print("Valid")</line-16>
<line-17> break</line-17>
<line-19> print("Invalid")</line-19>
|
{"code": "<line-3>while True:</line-3>\n<line-18> else:</line-18>", "lines": [3, 18]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> s = [str(i) for i in range(n,0,-1)]</line-3>
<line-4> for i in range(n):</line-4>
<line-6> del(s[0])</line-6>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-5> print('*'*i+''.join(s))</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> seq = input()</line-3>
<line-4> dollar = 0</line-4>
<line-5> stamp = 0</line-5>
<line-6> for ct in seq:</line-6>
<line-7> if stamp >= 6:</line-7>
<line-8> stamp -= 6</line-8>
<line-9> continue</line-9>
<line-10> elif ct == 'M':</line-10>
<line-11> dollar += 3</line-11>
<line-12> elif ct == 'L':</line-12>
<line-13> dollar += 4</line-13>
<line-15> print(dollar)</line-15>
<line-16></line-16>
<line-17></line-17>
|
{"code": "<line-2>for tc in range(t):</line-2>\n<line-14> stamp += 1</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>test=int(input())</line-1>
<line-3> n,k=map(int,input().split())</line-3>
<line-4> x=n-k</line-4>
<line-5> for j in range(1,n+1):</line-5>
<line-6> if(j%2==0 and x>0):</line-6>
<line-7> print(-j,end=' ')</line-7>
<line-8> x-=1</line-8>
<line-9> elif(k<=0):</line-9>
<line-10> print(-j,end=' ')</line-10>
<line-11> else:</line-11>
<line-12> print(j,end=' ')</line-12>
<line-14> print()</line-14>
|
{"code": "<line-2>for i in range(test):</line-2>\n<line-13> k-=1</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>def main():</line-5>
<line-6> try:</line-6>
<line-7> tc=int(input())</line-7>
<line-8> while tc>0:</line-8>
<line-9> tc=tc-1</line-9>
<line-10> [r,c] = input().split()</line-10>
<line-11> r=int(r)</line-11>
<line-12> c=int(c)</line-12>
<line-13> k=0</line-13>
<line-14> flag=0</line-14>
<line-15> matrix=[0]*r</line-15>
<line-16> i=0</line-16>
<line-17> while i<r:</line-17>
<line-18> matrix[i]=input()</line-18>
<line-19> i=i+1</line-19>
<line-20> </line-20>
<line-21> #Check row wise</line-21>
<line-22> for m in matrix:</line-22>
<line-23> for s in m:</line-23>
<line-24> if s==spoon[0][k] or s==spoon[1][k]:</line-24>
<line-25> k=k+1</line-25>
<line-26> if k==5:</line-26>
<line-27> flag=1</line-27>
<line-28> k=0</line-28>
<line-29> break</line-29>
<line-30> else:</line-30>
<line-31> k=0</line-31>
<line-32> </line-32>
<line-33> if flag==1:</line-33>
<line-34> print("There is a spoon!")</line-34>
<line-35> continue</line-35>
<line-36> </line-36>
<line-37> #Check column wise</line-37>
<line-38> i=0</line-38>
<line-39> k=0</line-39>
<line-40> while i<c:</line-40>
<line-41> j=0</line-41>
<line-42> while j<r:</line-42>
<line-43> if matrix[j][i]==spoon[0][k] or matrix[j][i]==spoon[1][k]:</line-43>
<line-44> k=k+1</line-44>
<line-45> if k==5:</line-45>
<line-46> flag=1</line-46>
<line-47> k=0</line-47>
<line-48> break</line-48>
<line-49> else:</line-49>
<line-50> k=0</line-50>
<line-51> j=j+1</line-51>
<line-52> i=i+1</line-52>
<line-53> </line-53>
<line-54> if flag==1:</line-54>
<line-55> print("There is a spoon!")</line-55>
<line-56> continue</line-56>
<line-57> </line-57>
<line-58> print("There is indeed no spoon!")</line-58>
<line-59> </line-59>
<line-60> except:</line-60>
<line-62>main()</line-62>
|
{"code": "<line-3>spoon = [ \"SPOON\", \"spoon\" ]</line-3>\n<line-61> return 0</line-61>", "lines": [3, 61]}
#### 0
|
<line-1>from math import sqrt,gcd</line-1>
<line-2></line-2>
<line-4> n=int(input())</line-4>
<line-5> ar=[int(x) for x in input().split()]</line-5>
<line-6> g=ar[0]</line-6>
<line-7> for i in range(1,n):</line-7>
<line-8> g=gcd(g,ar[i])</line-8>
<line-9> </line-9>
<line-10> f=g</line-10>
<line-11> for i in range(2,int(sqrt(g))+1):</line-11>
<line-12> if g%i==0:</line-12>
<line-13> f=i</line-13>
<line-14> break</line-14>
<line-15> if g!=1:</line-15>
<line-16> print(f)</line-16>
<line-18> print(-1)</line-18>
<line-19> </line-19>
<line-20> </line-20>
<line-21> </line-21>
|
{"code": "<line-3>for _ in range(int(input())):</line-3>\n<line-17> else:</line-17>", "lines": [3, 17]}
#### 0
|
<line-1>def left_span(arr,n):</line-1>
<line-3> span=[0]</line-3>
<line-4> for i in range(1,n):</line-4>
<line-5> </line-5>
<line-6> while span and arr[i]>arr[span[-1]]:</line-6>
<line-7> span.pop()</line-7>
<line-8> </line-8>
<line-9> if not span:</line-9>
<line-10> ans.append(0)</line-10>
<line-11> </line-11>
<line-12> else:</line-12>
<line-13> ans.append(span[-1]+1)</line-13>
<line-14> span.append(i)</line-14>
<line-15> return ans</line-15>
<line-16></line-16>
<line-17>def right_span(arr,n):</line-17>
<line-18> ans=[n+1]</line-18>
<line-19> span=[n-1]</line-19>
<line-20> for i in range(n-2,-1,-1):</line-20>
<line-21> </line-21>
<line-22> while span and arr[i]>=arr[span[-1]]:</line-22>
<line-23> span.pop()</line-23>
<line-24> </line-24>
<line-25> if not span:</line-25>
<line-26> ans.append(n+1)</line-26>
<line-27> else:</line-27>
<line-28> ans.append(span[-1]+1)</line-28>
<line-29> span.append(i)</line-29>
<line-30> return ans[::-1]</line-30>
<line-31>from collections import Counter</line-31>
<line-32>from bisect import bisect_left,bisect_right</line-32>
<line-33>from operator import itemgetter</line-33>
<line-34>n,q=list(map(int,input().split( )))</line-34>
<line-35>arr=list(map(int,input().split( )))</line-35>
<line-36></line-36>
<line-37>left=left_span(arr,n)</line-37>
<line-38>right=right_span(arr,n)</line-38>
<line-39>c=Counter()</line-39>
<line-40>for i in range(n):</line-40>
<line-41> c[arr[i]]+=(right[i]-(i+1))*(i+1-left[i])</line-41>
<line-42>a=sorted(c)</line-42>
<line-43>f=[]</line-43>
<line-44>for v in a:</line-44>
<line-45> f.append(c[v])</line-45>
<line-46>prefix_sum=[f[0]]</line-46>
<line-47>n=len(f)</line-47>
<line-48>for i in range(1,n):</line-48>
<line-49> prefix_sum.append(f[i]+prefix_sum[-1])</line-49>
<line-50>r=[0]*q</line-50>
<line-51>for i in range(q):</line-51>
<line-52> sign,k,player=list(map(str,input().split( )))</line-52>
<line-53> k=int(k)</line-53>
<line-54> if sign=="=":</line-54>
<line-55> if k in c:</line-55>
<line-56> res=c[k]</line-56>
<line-57> else:</line-57>
<line-58> res=0</line-58>
<line-59> elif sign==">":</line-59>
<line-60> j=bisect_left(a,k)</line-60>
<line-61> if j==n:</line-61>
<line-62> res=0</line-62>
<line-63> elif a[j]==k:</line-63>
<line-64> res=prefix_sum[-1] - prefix_sum[j]</line-64>
<line-65> else:</line-65>
<line-66> if j>0:</line-66>
<line-67> res=prefix_sum[-1] - prefix_sum[j-1]</line-67>
<line-68> else:</line-68>
<line-69> res=prefix_sum[-1]</line-69>
<line-70> else:</line-70>
<line-71> j=bisect_left(a,k)</line-71>
<line-72> if j==0:</line-72>
<line-73> res=0</line-73>
<line-74> else:</line-74>
<line-75> res=prefix_sum[j-1]</line-75>
<line-76> </line-76>
<line-77> if res%2==0:</line-77>
<line-78> if player=="D":</line-78>
<line-79> r[i]="C"</line-79>
<line-80> else:</line-80>
<line-81> r[i]="D"</line-81>
<line-82> else:</line-82>
<line-84>print(''.join(r))</line-84>
<line-85> </line-85>
<line-86> </line-86>
<line-87></line-87>
<line-88></line-88>
|
{"code": "<line-2> ans=[0]</line-2>\n<line-83> r[i]=player</line-83>", "lines": [2, 83]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>count=0</line-3>
<line-4>while n:</line-4>
<line-5> n-=1</line-5>
<line-6> a,b,c=sorted(map(int,input().split()))</line-6>
<line-7> if (a,b,c) in l:</line-7>
<line-8> count-=1</line-8>
<line-9> else:</line-9>
<line-10> l.append((a,b,c))</line-10>
<line-12>print(count)</line-12>
|
{"code": "<line-2>l=[]</line-2>\n<line-11> count+=1</line-11>", "lines": [2, 11]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3></line-3>
<line-4>class sol():</line-4>
<line-5> def __init__(self,n,edges):</line-5>
<line-6> self.n = n</line-6>
<line-7> self.edges = edges</line-7>
<line-8> self.graph = self.create_graph()</line-8>
<line-9> self.precompute()</line-9>
<line-10> </line-10>
<line-11> def create_graph(self):</line-11>
<line-12> graph = defaultdict(list)</line-12>
<line-13> for e in self.edges:</line-13>
<line-14> u = e[0]</line-14>
<line-15> v = e[1]</line-15>
<line-16> w = e[2]</line-16>
<line-17> graph[u].append([v,w])</line-17>
<line-18> graph[v].append([u,w])</line-18>
<line-19> return graph</line-19>
<line-20> </line-20>
<line-21> def precompute(self):</line-21>
<line-22> self.maxiedges = [0]*6</line-22>
<line-23> self.B = [[0 for i in range(101)] for i in range(101)]</line-23>
<line-24> def func(u,v,l):</line-24>
<line-25> if l==2:</line-25>
<line-26> self.B[u][self.maxiedges[l]] += 1</line-26>
<line-27> else:</line-27>
<line-28> for j in self.graph[v]:</line-28>
<line-29> self.maxiedges[l+1] = max(self.maxiedges[l],j[1])</line-29>
<line-30> func(u,j[0],l+1)</line-30>
<line-31> for i in range(1,self.n+1):</line-31>
<line-32> func(i,i,0)</line-32>
<line-33> </line-33>
<line-34> def paths(self,X):</line-34>
<line-35> freq = 0</line-35>
<line-36> for u in range(1,self.n+1):</line-36>
<line-37> for x in range(X+1):</line-37>
<line-38> freq += 2*self.B[u][X]*self.B[u][x]</line-38>
<line-39> freq -= self.B[u][X]*self.B[u][X]</line-39>
<line-40> return freq</line-40>
<line-41> </line-41>
<line-42>n, m = map(int, input().split())</line-42>
<line-43>edges = []</line-43>
<line-44>while m:</line-44>
<line-45> uvw = list(map(int, input().split()))</line-45>
<line-46> edges.append(uvw)</line-46>
<line-47> m -= 1</line-47>
<line-48>q = int(input())</line-48>
<line-49>Graph = sol(n,edges)</line-49>
<line-50>while q:</line-50>
<line-51> query = int(input())</line-51>
<line-53> q -= 1</line-53>
|
{"code": "<line-2>from collections import defaultdict</line-2>\n<line-52> print(Graph.paths(query))</line-52>", "lines": [2, 52]}
#### 0
|
<line-1>import sys</line-1>
<line-2> </line-2>
<line-4> R = [(x,y)]</line-4>
<line-5> GRID[x][y] = i</line-5>
<line-6> for n in R:</line-6>
<line-7> GRID[n[0]][n[1]] = i</line-7>
<line-8> if n[0]>0 and GRID[n[0]-1][n[1]]==0 and H[n[0]-1][n[1]]:</line-8>
<line-9> GRID[n[0]-1][n[1]] = i</line-9>
<line-10> R.append((n[0]-1,n[1]))</line-10>
<line-11> if n[0]<N-1 and GRID[n[0]+1][n[1]]==0 and H[n[0]][n[1]]:</line-11>
<line-12> GRID[n[0]+1][n[1]] = i</line-12>
<line-13> R.append((n[0]+1,n[1]))</line-13>
<line-14> if n[1]>0 and GRID[n[0]][n[1]-1]==0 and V[n[0]][n[1]-1]:</line-14>
<line-15> GRID[n[0]][n[1]-1] = i</line-15>
<line-16> R.append((n[0],n[1]-1))</line-16>
<line-17> if n[1]<M-1 and GRID[n[0]][n[1]+1]==0 and V[n[0]][n[1]]:</line-17>
<line-18> GRID[n[0]][n[1]+1] = i</line-18>
<line-19> R.append((n[0],n[1]+1))</line-19>
<line-20></line-20>
<line-21>def roomPrice(r):</line-21>
<line-22> wall_price_0 = wall_price_1 = 0</line-22>
<line-23> for i in range(R):</line-23>
<line-24> if C[i][r] and T[i] != 1:</line-24>
<line-25> wall_price_0 += C[i][r]*K</line-25>
<line-26> else:</line-26>
<line-27> wall_price_1 += C[i][r]*K</line-27>
<line-28> return [wall_price_0 + Rooms[r][0], wall_price_1 + Rooms[r][1]]</line-28>
<line-29></line-29>
<line-30>def total_price():</line-30>
<line-31> price = 0</line-31>
<line-32> for r in range(R):</line-32>
<line-33> for i in range(r):</line-33>
<line-34> if C[i][r] and T[i] != T[r]:</line-34>
<line-35> price += C[i][r]*K</line-35>
<line-36> price += Rooms[r][T[r]-1]</line-36>
<line-37> return price</line-37>
<line-38></line-38>
<line-39>def solve(r):</line-39>
<line-40> if r==R:</line-40>
<line-41> return 0</line-41>
<line-42> wall_price_0 = 0</line-42>
<line-43> wall_price_1 = 0</line-43>
<line-44> for i in range(r):</line-44>
<line-45> if C[i][r] and T[i] != 1:</line-45>
<line-46> wall_price_0 += C[i][r]*K</line-46>
<line-47> else:</line-47>
<line-48> wall_price_1 += C[i][r]*K</line-48>
<line-49> if T[r]!=0:</line-49>
<line-50> return [wall_price_0,wall_price_1][T[r]-1]+Rooms[r][T[r]-1]+solve(r+1) </line-50>
<line-51> T[r] = 1</line-51>
<line-52> result = solve(r+1)+wall_price_0+Rooms[r][0]</line-52>
<line-53> T[r] = 2</line-53>
<line-54> result = min(solve(r+1)+wall_price_1+Rooms[r][1], result)</line-54>
<line-55> T[r] = 0</line-55>
<line-56> return result</line-56>
<line-57> </line-57>
<line-58>f = sys.stdin</line-58>
<line-59>N,M,W,K,R = list(map(int, f.readline().split(' ')))</line-59>
<line-60>T = [0] * R</line-60>
<line-61>GRID = list(map(list,[[0]*M]*N))</line-61>
<line-62>H = list(map(list,[[1]*M]*N))</line-62>
<line-63>V = list(map(list,[[1]*M]*N))</line-63>
<line-64>Walls = []</line-64>
<line-65>for _ in range(W):</line-65>
<line-66> x0,y0,x1,y1 = list(map(int, f.readline().split(' ')))</line-66>
<line-67> x0 -= 1</line-67>
<line-68> x1 -= 1</line-68>
<line-69> y0 -= 1</line-69>
<line-70> y1 -= 1</line-70>
<line-71> if x0==x1:</line-71>
<line-72> V[x0][y0] = 0</line-72>
<line-73> else:</line-73>
<line-74> H[x0][y0] = 0</line-74>
<line-75> Walls.append([x0,y0,x1,y1]) </line-75>
<line-76>Rooms = []</line-76>
<line-77>for i in range(R):</line-77>
<line-78> x,y,t1,t2 = list(map(int, f.readline().split(' ')))</line-78>
<line-79> findRoom(x-1,y-1,i+1)</line-79>
<line-80> Rooms.append([t1,t2])</line-80>
<line-81>C = list(map(list,[[0]*R]*R))</line-81>
<line-82>for w in Walls:</line-82>
<line-83> r1 = GRID[w[0]][w[1]]-1 </line-83>
<line-84> r2 = GRID[w[2]][w[3]]-1</line-84>
<line-85> C[r1][r2] += 1</line-85>
<line-86> C[r2][r1] += 1</line-86>
<line-87>Stable = [False]*R</line-87>
<line-88>for r in range(R):</line-88>
<line-89> walls_max_price = sum(C[r])*K</line-89>
<line-90> if walls_max_price<=abs(Rooms[r][0]-Rooms[r][1]):</line-90>
<line-91> # If we choose the cheaper team, no matter what the next rooms are the walls we not overprice it.</line-91>
<line-92> T[r] = 1+(Rooms[r][0]>Rooms[r][1])</line-92>
<line-93> Stable[r] = True</line-93>
<line-94>def try_teams():</line-94>
<line-95> for r in range(R):</line-95>
<line-96> if not Stable[r]:</line-96>
<line-97> T[r] = 1+(r&1)</line-97>
<line-98> change = True</line-98>
<line-99> while change:</line-99>
<line-100> change = False</line-100>
<line-101> for r in range(R):</line-101>
<line-102> price = roomPrice(r)</line-102>
<line-103> if price[T[r]-1]>price[2-T[r]]:</line-103>
<line-104> T[r] = 3-T[r]</line-104>
<line-105> change = True</line-105>
<line-106> print(total_price())</line-106>
<line-108>print(solve(0))</line-108>
|
{"code": "<line-3>def findRoom(x,y,i):</line-3>\n<line-107>#try_teams() </line-107>", "lines": [3, 107]}
#### 0
|
<line-1>try:</line-1>
<line-2></line-2>
<line-4> n,k = map(int,input().split())</line-4>
<line-5></line-5>
<line-6> if k>n:</line-6>
<line-7> c=0</line-7>
<line-8> else:</line-8>
<line-9> c = n-k+1</line-9>
<line-10></line-10>
<line-11> s = c*(c+1)//2</line-11>
<line-12> print('Case', str(j)+':',s)</line-12>
<line-14> pass</line-14>
|
{"code": "<line-3> for j in range(1,int(input())+1):</line-3>\n<line-13>except:</line-13>", "lines": [3, 13]}
#### 0
|
<line-1>n,m=map(int,input().split())</line-1>
<line-3>leng=0</line-3>
<line-4>for i in range(n+m):</line-4>
<line-5> w=int(input())</line-5>
<line-6> if w==-1:</line-6>
<line-7> cm=0</line-7>
<line-8> mi=0</line-8>
<line-9> for j in range(leng):</line-9>
<line-10> if l[j]>cm:</line-10>
<line-11> cm=l[j]</line-11>
<line-12> mi=j</line-12>
<line-13> </line-13>
<line-14> print(cm)</line-14>
<line-15> l[mi]=-1</line-15>
<line-16> else:</line-16>
<line-18> leng+=1</line-18>
|
{"code": "<line-2>l=[]</line-2>\n<line-17> l.append(w)</line-17>", "lines": [2, 17]}
#### 0
|
<line-1></line-1>
<line-2>for _ in range(int(input())):</line-2>
<line-4> if(n<3):</line-4>
<line-5> print("B")</line-5>
<line-6> else:</line-6>
<line-7> if(n==3):</line-7>
<line-8> print("A")</line-8>
<line-9> elif(n%2):</line-9>
<line-10> print("B")</line-10>
<line-12> print("B")</line-12>
<line-13></line-13>
<line-14></line-14>
<line-15></line-15>
<line-16></line-16>
<line-17></line-17>
<line-18></line-18>
<line-19></line-19>
<line-20></line-20>
|
{"code": "<line-3> n=int(input())</line-3>\n<line-11> else:</line-11>", "lines": [3, 11]}
#### 0
|
<line-1>T=int(input())</line-1>
<line-3> n=int(input())</line-3>
<line-4> if n==1:</line-4>
<line-5> print("0")</line-5>
<line-6> else:</line-6>
<line-7> n=n-2</line-7>
<line-9> print(int(l))</line-9>
|
{"code": "<line-2>for i in range(T):</line-2>\n<line-8> l=(n+1)*(2*n+3)*(n+2)/6</line-8>", "lines": [2, 8]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(int(input())):</line-3>
<line-4> n,k = map(int,input().split())</line-4>
<line-5> l = list(map(int,input().split()))</line-5>
<line-6> l.sort(reverse = True)</line-6>
<line-7> c = 0</line-7>
<line-8> for i in l:</line-8>
<line-9> if i >= l[k-1]:</line-9>
<line-11> print(c)</line-11>
|
{"code": "<line-2>#t = int(input())</line-2>\n<line-10> c += 1</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>#for _ in range(int(input())):</line-1>
<line-3>#n = int(input())</line-3>
<line-4>#x = [int(w) for w in input().split()]</line-4>
<line-5>#x = [int(input()) for _ in range(n)]</line-5>
<line-6>#for i in range(n):</line-6>
<line-7>#dt = {} for i in x:dt[i] = dt.get(i,0)+1</line-7>
<line-8>#dt = {k:v for k,v in sorted(x.items(), key=lambda i: i[1])}</line-8>
<line-9></line-9>
<line-10>from bisect import bisect_left as bs</line-10>
<line-11>n = int(input())</line-11>
<line-12>x = [int(input()) for _ in range(n)]</line-12>
<line-13>dp = []</line-13>
<line-14>mn = float('inf')</line-14>
<line-15>idx = []</line-15>
<line-16>mlen = float('-inf')</line-16>
<line-17>si,sj = 0,0</line-17>
<line-18>sm = 0</line-18>
<line-19>def check(_sm,ind1,ind2,f):</line-19>
<line-20> nonlocal mn,si,sj,mlen</line-20>
<line-21> if _sm<abs(mn) or (_sm==abs(mn) and (idx[ind2]-idx[ind1])>mlen):</line-21>
<line-22> si,sj = idx[ind1]+1,idx[ind2]</line-22>
<line-23> mn = _sm*f</line-23>
<line-24> mlen = sj-si+1</line-24>
<line-25></line-25>
<line-26>for k,v in enumerate(x,1):</line-26>
<line-27> sm += v</line-27>
<line-28> ind = bs(dp,sm)</line-28>
<line-29> dp.insert(ind,sm)</line-29>
<line-30> idx.insert(ind,k)</line-30>
<line-31> check(abs(sm),0,ind,1)</line-31>
<line-32></line-32>
<line-33> if ind>0:</line-33>
<line-34> prev = ind-1</line-34>
<line-35> diff = dp[ind]-dp[prev]</line-35>
<line-36> while prev>0 and (dp[ind]-dp[prev-1])==diff:</line-36>
<line-37> prev -= 1</line-37>
<line-38> check(diff,prev,ind,1)</line-38>
<line-39> if ind < len(dp)-1:</line-39>
<line-40> nxt = ind+1</line-40>
<line-41> diff = dp[nxt]-dp[ind]</line-41>
<line-42> while nxt<len(dp)-1 and (dp[nxt+1]-dp[ind])==diff:</line-42>
<line-43> nxt += 1</line-43>
<line-44> check(diff,nxt,ind,-1)</line-44>
<line-46>print(si,sj)</line-46>
|
{"code": "<line-2>#n,m = map(int,input().split())</line-2>\n<line-45>print(mn)</line-45>", "lines": [2, 45]}
#### 0
|
<line-1>from math import sqrt</line-1>
<line-2></line-2>
<line-4> </line-4>
<line-5> n, k = map(int, input().split())</line-5>
<line-6> fact,i = [],1</line-6>
<line-7> </line-7>
<line-8> while i<=sqrt(n):</line-8>
<line-9></line-9>
<line-10> if n%i==0:</line-10>
<line-11> if (n // i != i):</line-11>
<line-12> fact.append(n//i)</line-12>
<line-13> </line-13>
<line-14> fact.append(i)</line-14>
<line-15> </line-15>
<line-16> i+=1</line-16>
<line-17> </line-17>
<line-18> tot = (k*(k+1))//2</line-18>
<line-19> mx = -1</line-19>
<line-20> </line-20>
<line-21> for i in fact:</line-21>
<line-22> if i>=tot:</line-22>
<line-24> </line-24>
<line-25> print(mx)</line-25>
|
{"code": "<line-3>for _ in range(int(input())):</line-3>\n<line-23> mx = max(mx,n//i)</line-23>", "lines": [3, 23]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> </line-3>
<line-4> p,q,r,s =map(int,input().split())</line-4>
<line-5> x=(s-p)</line-5>
<line-6> y=(s-q)</line-6>
<line-8> print(y,z,x)</line-8>
|
{"code": "<line-2>for j in range(int(input())):</line-2>\n<line-7> z=(s-r)</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> f=list(map(int,input().split()))</line-3>
<line-4> sum1=f[0]</line-4>
<line-5> d=0</line-5>
<line-6> i=1 </line-6>
<line-7> while sum1!=0 and i<n:</line-7>
<line-8> sum1=sum1-1+f[i]</line-8>
<line-9> d+=1 </line-9>
<line-11> print(d+sum1)</line-11>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-10> i+=1 </line-10>", "lines": [2, 10]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(int(input())):</line-3>
<line-4> N,Q=list(map(int,input().strip().split(' ')))</line-4>
<line-5> V=list(map(int,input().strip().split(' ')))</line-5>
<line-6> VV=sorted(V)</line-6>
<line-7> for ___ in range(Q):</line-7>
<line-8> x,y=list(map(int,input().strip().split(' ')))</line-8>
<line-9> x-=1</line-9>
<line-10> y-=1</line-10>
<line-11> ans1=abs(V[x]-V[y])+(y-x)</line-11>
<line-12> post1=bisect.bisect_left(VV,min(V[x],V[y]))</line-12>
<line-13> post2=bisect.bisect_right(VV,max(V[x],V[y]))</line-13>
<line-15> print(ans1,ans2)</line-15>
|
{"code": "<line-2>import bisect</line-2>\n<line-14> ans2=post2-post1</line-14>", "lines": [2, 14]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n=input().strip()</line-3>
<line-4> x=n.count('4')</line-4>
<line-6> print(len(n)-x-y)</line-6>
<line-7> </line-7>
|
{"code": "<line-2>for _ in range(0,int(input())):</line-2>\n<line-5> y=n.count('7')</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>T = int(input())</line-1>
<line-3> n, m = list(map(int, input().split()))</line-3>
<line-4> c = list(map(int, input().split()))</line-4>
<line-5> dp1 = [1e9]*((1 << n)+1)</line-5>
<line-6> for i in range(n):</line-6>
<line-7> dp1[1 << i] = c[i] </line-7>
<line-8> </line-8>
<line-9> dp1[1 << (n-1)] = min(dp1[1 << (n-1)], sum(c))</line-9>
<line-10> </line-10>
<line-11> for i in range(m):</line-11>
<line-12> l = list(map(int, input().split()))</line-12>
<line-13> cost = l[0]</line-13>
<line-14> s = l[1]</line-14>
<line-15> items = l[2:]</line-15>
<line-16> mask = 0</line-16>
<line-17> for j in items:</line-17>
<line-18> mask = mask | (1 << (j-1))</line-18>
<line-19> dp1[mask] = min(dp1[mask], cost)</line-19>
<line-20> </line-20>
<line-21> for i in range((1<<n) - 1, -1, -1):</line-21>
<line-22> for j in range(n):</line-22>
<line-23> if i & (1<< j):</line-23>
<line-24> dp1[i ^ (1<<j)] = min(dp1[i ^ (1<<j)], dp1[i])</line-24>
<line-25> </line-25>
<line-26> dp2 = [1e9]*((1 << n) + 1)</line-26>
<line-27> dp2[0] = 0</line-27>
<line-28> for i in range(1 << n):</line-28>
<line-29> submask = i</line-29>
<line-30> while submask > 0:</line-30>
<line-31> dp2[i] = min(dp2[i], dp2[i ^ submask] + dp1[submask])</line-31>
<line-33> </line-33>
<line-34> print(dp2[(1 << n)-1])</line-34>
|
{"code": "<line-2>for t in range(T):</line-2>\n<line-32> submask = (submask-1) & i</line-32>", "lines": [2, 32]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> A,B=list(map(int,input().split()))</line-3>
<line-4> l1=list(map(int,input().split()))</line-4>
<line-5> l2=list(map(int,input().split()))</line-5>
<line-6> for i in range(A*B):</line-6>
<line-7> if l1[i]<l2[i]:</line-7>
<line-8> l1[i]=0</line-8>
<line-9> else:</line-9>
<line-10> l2[i]=0</line-10>
<line-11> l1.sort(reverse=True)</line-11>
<line-12> l2.sort(reverse=True)</line-12>
<line-13> </line-13>
<line-14> w,d,c=0,0,0</line-14>
<line-15> for j in range(A):</line-15>
<line-16> if l1[c]>l2[d]:</line-16>
<line-17> w+=1</line-17>
<line-18> c+=1</line-18>
<line-19> d+=B-1</line-19>
<line-20> else:</line-20>
<line-22> print(w)</line-22>
<line-23> </line-23>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-21> d+=B</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3>while t:</line-3>
<line-4> t-=1 </line-4>
<line-5> n,k = map(int ,input().split())</line-5>
<line-6> v = floor(log(k, 2))</line-6>
<line-8> print(n / block * (1 + (k - 2 ** v) * 2 ))</line-8>
|
{"code": "<line-2>from math import log, ceil, floor</line-2>\n<line-7> block = 1 << v + 1 </line-7>", "lines": [2, 7]}
#### 0
|
<line-1>t=eval(input())</line-1>
<line-3> i,j=list(map(int,input().split()))</line-3>
<line-4> bi=bin(i)[2:]</line-4>
<line-5> bj=bin(j)[2:]</line-5>
<line-6> k=0</line-6>
<line-7> while k<(min(len(bi),len(bj))):</line-7>
<line-8> if bi[k]!=bj[k]:</line-8>
<line-9> break</line-9>
<line-10> else:</line-10>
<line-12> print(len(bi)-k+len(bj)-k)</line-12>
<line-13> </line-13>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-11> k+=1</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>mod=10**9+7</line-1>
<line-3> p,n=1,2</line-3>
<line-4> while(x):</line-4>
<line-5> if(x & 1): p=((p%mod) * (n%mod))%mod</line-5>
<line-6></line-6>
<line-7> n=((n%mod) * (n%mod))%mod</line-7>
<line-8> x//=2</line-8>
<line-9></line-9>
<line-10> return p</line-10>
<line-11></line-11>
<line-12>def count_bit(val):</line-12>
<line-13> bit=0</line-13>
<line-14> while(val):</line-14>
<line-15> bit+=1</line-15>
<line-16> val &=(val-1)</line-16>
<line-17> return bit</line-17>
<line-18> </line-18>
<line-19>def answer():</line-19>
<line-20></line-20>
<line-21> val=b[0]</line-21>
<line-22> po2=0</line-22>
<line-23> for i in range(1,len(b)):</line-23>
<line-24> if(val > b[i]):return 0</line-24>
<line-25> po2+=count_bit(val & b[i])</line-25>
<line-26> val=b[i]</line-26>
<line-27></line-27>
<line-28> return pow2(po2)%mod</line-28>
<line-29></line-29>
<line-30></line-30>
<line-31>for T in range(int(input())):</line-31>
<line-32> n=int(input())</line-32>
<line-34></line-34>
<line-35> print(answer())</line-35>
<line-36> </line-36>
|
{"code": "<line-2>def pow2(x):</line-2>\n<line-33> b=list(map(int,input().split()))</line-33>", "lines": [2, 33]}
#### 0
|
<line-1>import math</line-1>
<line-3>a=list(map(int,input().split()))</line-3>
<line-4>dp = [0 for x in range(n)]</line-4>
<line-5>dp[0] = a[0]</line-5>
<line-6>dp[1] = a[1]</line-6>
<line-7>dp[2] = a[2]</line-7>
<line-8>for x in range(3,n):</line-8>
<line-10></line-10>
<line-11>print(min(dp[-3:]))</line-11>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-9> dp[x] = a[x] + min(dp[x-1],dp[x-2],dp[x-3])</line-9>", "lines": [2, 9]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>lst=list(map(int,input().split()))</line-3>
<line-4>dict1={}.fromkeys(lst,0)</line-4>
<line-5>for key in lst:</line-5>
<line-6> dict1[key]+=1</line-6>
<line-7>sum1=0</line-7>
<line-8>for key in dict1:</line-8>
<line-9> sum1+=dict1[key]//2</line-9>
<line-10> if(dict1[key]%2==1):</line-10>
<line-12>print(sum1) </line-12>
|
{"code": "<line-2>n=int(input())</line-2>\n<line-11> sum1+=1</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>line = input()</line-1>
<line-3></line-3>
<line-4>while line != "0":</line-4>
<line-5> test += 1</line-5>
<line-6> d = {'0':0,'1':0,'2':0,'3':0,'4':0,'5':0,'6':0,'7':0,'8':0,'9':0}</line-6>
<line-7> a = list(map(int,line.split()))</line-7>
<line-8> for i in range(min(a),max(a)+1):</line-8>
<line-9> for c in str(i):</line-9>
<line-10> d[c] += 1</line-10>
<line-11> pairs = list(d.items())</line-11>
<line-12> pairs.sort() </line-12>
<line-14> line = input()</line-14>
|
{"code": "<line-2>test = 0</line-2>\n<line-13> print(\"Case %s: %s\" % (test, \" \".join([\"%s:%s\" % (k,v) for k,v in pairs])))</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>from math import gcd</line-1>
<line-3> lcm = (x*y)//gcd(x,y)</line-3>
<line-4> return lcm</line-4>
<line-5></line-5>
<line-6>def LCMofArray(a):</line-6>
<line-7> lcm = a[0]</line-7>
<line-8> for i in range(1,len(a)):</line-8>
<line-9> lcm = lcm*a[i]//gcd(lcm, a[i])</line-9>
<line-10> return lcm</line-10>
<line-11></line-11>
<line-12>for _ in range(int(input())):</line-12>
<line-13> lens = int(input())</line-13>
<line-14> arrs = [int(x) for x in input().split()]</line-14>
<line-16> print(LCMofArray(arrs) + rest)</line-16>
<line-17></line-17>
|
{"code": "<line-2>def compute_lcm(x, y):</line-2>\n<line-15> rest = int(input())</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>#In the Name of God</line-1>
<line-3></line-3>
<line-4>x = input().split()</line-4>
<line-5>n = int(x[0])</line-5>
<line-6>arr = []</line-6>
<line-7>i = 1</line-7>
<line-8>while(i<len(x)):</line-8>
<line-9> arr.append(float(x[i]))</line-9>
<line-10> i += 1</line-10>
<line-11> arr.append(int(x[i]))</line-11>
<line-12> i += 1</line-12>
<line-13>i = 0</line-13>
<line-14></line-14>
<line-15>ans = []</line-15>
<line-16>while(i<len(arr)):</line-16>
<line-17> x = arr[i]</line-17>
<line-18> i += 1</line-18>
<line-19> y = arr[i]</line-19>
<line-20> y = 10**y</line-20>
<line-21> i += 1</line-21>
<line-22> ans.append(x*y)</line-22>
<line-24> print("{:.2f}".format(ans[i]))</line-24>
|
{"code": "<line-2>import math</line-2>\n<line-23>for i in range(len(ans)):</line-23>", "lines": [2, 23]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> if num<10:return 2 </line-3>
<line-4> last=int(str(num)[0]);rem=int(str(num)[1:]);steps=2;p=len(str(num))-1</line-4>
<line-5> while True:</line-5>
<line-6> steps+=rem//last+1;rem=rem%last </line-6>
<line-7> if last>0:rem=rem+10**p-last</line-7>
<line-8> last=last-1</line-8>
<line-9> if last==0:</line-9>
<line-10> p=p-1;last=9</line-10>
<line-11> if(len(str(rem))==1):rem=0</line-11>
<line-12> else:rem=int(str(rem)[1:])</line-12>
<line-13> if rem==0: break</line-13>
<line-14> return steps</line-14>
<line-15>for awa in range(int(input())):</line-15>
<line-16> k=int(input())</line-16>
<line-17> if(k==1):print(0)</line-17>
<line-18> elif(k==2):print(9)</line-18>
<line-19> elif(k==3):print(10)</line-19>
<line-20> else:</line-20>
<line-21> low,high,ans = 0,10**18,0</line-21>
<line-22> while(low<=high):</line-22>
<line-23> mid=(low+high)//2;temp=getAns(mid)</line-23>
<line-24> if int(temp)==k:ans=max(ans,mid);low=mid+1 </line-24>
<line-26> else:high=mid-1 </line-26>
|
{"code": "<line-2>def getAns(num):</line-2>\n<line-25> elif temp<k:low=mid+1 </line-25>", "lines": [2, 25]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> a = list(map(int,input().split()))</line-3>
<line-4> ans = 0</line-4>
<line-5> count = 0</line-5>
<line-6> for i in a:</line-6>
<line-7> if i>0:</line-7>
<line-8> ans+=i</line-8>
<line-9> count+=1</line-9>
<line-10> res = []</line-10>
<line-11> for i in range(count):</line-11>
<line-12> if a[i]<=0:</line-12>
<line-13> res.append(i+1)</line-13>
<line-14> for i in range(count,n):</line-14>
<line-15> if a[i]>0:</line-15>
<line-16> res.append(i+1)</line-16>
<line-18> print(len(res),*res)</line-18>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-17> print(ans)</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>import bisect</line-1>
<line-2></line-2>
<line-4> for p in range(n-1):</line-4>
<line-5> if(a[p]>=a[p+1]):</line-5>
<line-6> return p</line-6>
<line-7> return n-1 </line-7>
<line-8> </line-8>
<line-9>def suf(a):</line-9>
<line-10> for s in range(1,n):</line-10>
<line-11> if(a[n-s]<=a[n-s-1]):</line-11>
<line-12> return n-s</line-12>
<line-13> return 0</line-13>
<line-14> </line-14>
<line-15> </line-15>
<line-16></line-16>
<line-17>t=int(input())</line-17>
<line-18>for _ in range(t):</line-18>
<line-19> n=int(input())</line-19>
<line-20> a=list(map(int,input().split()))</line-20>
<line-21> </line-21>
<line-22> p=pre(a)</line-22>
<line-23> s=suf(a)</line-23>
<line-24> </line-24>
<line-25> b=a[s:n]</line-25>
<line-26> count=0</line-26>
<line-27> for i in range(p+1):</line-27>
<line-28> k=bisect.bisect(b,a[i])</line-28>
<line-29> k+=s</line-29>
<line-30> count+=n-k+1</line-30>
<line-31> </line-31>
<line-32> if(s==0):</line-32>
<line-33> print((n*(n+1))//2-1)</line-33>
<line-35> print(count+n-s)</line-35>
|
{"code": "<line-3>def pre(a):</line-3>\n<line-34> else:</line-34>", "lines": [3, 34]}
#### 0
|
<line-1>import math</line-1>
<line-3> n,x=list(map(int,input().split()))</line-3>
<line-4> l=list(map(int,input().split()))</line-4>
<line-5> l.sort()</line-5>
<line-6> flag=0</line-6>
<line-7> d=0</line-7>
<line-8> </line-8>
<line-9> for j in range(n):</line-9>
<line-10> </line-10>
<line-11> if l[j]>x:</line-11>
<line-12> for k in range(j,n):</line-12>
<line-13> </line-13>
<line-14> if x<l[k]:</line-14>
<line-15> </line-15>
<line-16> </line-16>
<line-17> d+=(math.ceil(math.log(l[k]/x)/math.log(2))+1)</line-17>
<line-18> </line-18>
<line-19> else:</line-19>
<line-20> d+=1</line-20>
<line-21> </line-21>
<line-22></line-22>
<line-23> x=l[k]*2</line-23>
<line-24> </line-24>
<line-25> </line-25>
<line-26> </line-26>
<line-27> </line-27>
<line-28> flag=1</line-28>
<line-29> </line-29>
<line-30> </line-30>
<line-31> break</line-31>
<line-32> </line-32>
<line-33> if flag==1:</line-33>
<line-34> </line-34>
<line-35> print(j+d)</line-35>
<line-37> print(n)</line-37>
|
{"code": "<line-2>for i in range(int(input())):</line-2>\n<line-36> else:</line-36>", "lines": [2, 36]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> index=0</line-3>
<line-4> for i in a:</line-4>
<line-5> while index<len(b) and i != b[index]:</line-5>
<line-6> index+=1</line-6>
<line-7> if(index>=len(b)):</line-7>
<line-8> return False</line-8>
<line-9> index+=1 </line-9>
<line-10> return True</line-10>
<line-11>def Dob_String(n):</line-11>
<line-12> size=len(n)</line-12>
<line-13> midpoint=size//2</line-13>
<line-14> if(check_equal(n[0:midpoint],n[midpoint:size])):</line-14>
<line-15> return("YES")</line-15>
<line-16> elif(size%2!=0 and check_equal(n[midpoint+1:size],n[0:midpoint+1])):</line-16>
<line-17> return("YES")</line-17>
<line-18> else:</line-18>
<line-19> return("NO")</line-19>
<line-20>T=int(input()) </line-20>
<line-21>for _ in range(T):</line-21>
<line-22> n=input()</line-22>
<line-23> if(len(n)>1):</line-23>
<line-24> print(Dob_String(n))</line-24>
<line-26> print("NO")</line-26>
|
{"code": "<line-2>def check_equal(a,b):</line-2>\n<line-25> else:</line-25>", "lines": [2, 25]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> try:</line-3>
<line-4> for _ in range (int(input())):</line-4>
<line-5> element = int(input())</line-5>
<line-6> l = list(map(int,input().split()))</line-6>
<line-7> a=min(l)</line-7>
<line-8> l.remove(a)</line-8>
<line-9> b=min(l)</line-9>
<line-10> print(a+b)</line-10>
<line-11> except EOFError :</line-11>
<line-13></line-13>
<line-14>__starting_point()</line-14>
|
{"code": "<line-2>def __starting_point():</line-2>\n<line-12> print('EOFError')</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> message=''</line-3>
<line-4> asc=int(code[0])</line-4>
<line-5> </line-5>
<line-6> for i in range(len(code)-1):</line-6>
<line-7> </line-7>
<line-8> if int(str(asc)+code[i+1])>256:</line-8>
<line-9> message+=chr(asc)</line-9>
<line-10> asc=int(code[i+1])</line-10>
<line-11> else: </line-11>
<line-13> </line-13>
<line-14> print(message)</line-14>
|
{"code": "<line-2> code=input().strip()+'0'</line-2>\n<line-12> asc=int(str(asc)+code[i+1])</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> sigma = 1</line-3>
<line-4> #len(str(num)) == n and D[i] - D[i - 1] ... = w</line-4>
<line-5> if(w > 9 or w < -9):</line-5>
<line-6> print(0)</line-6>
<line-7> continue</line-7>
<line-8> sigma = pow(10,n - 2,1000000007)</line-8>
<line-9> if(w >= 0):</line-9>
<line-10> sigma *= (9 - w)</line-10>
<line-11> else:</line-11>
<line-13> print(sigma % 1000000007)</line-13>
|
{"code": "<line-2> n,w = map(int , input().split())</line-2>\n<line-12> sigma *= (w + 10)</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>import sys</line-1>
<line-3>n,m=list(map(int,input().split()))</line-3>
<line-4>aaaaa=100</line-4>
<line-5>li=list(map(int,input().split()))</line-5>
<line-6>non_special,special=[],[]</line-6>
<line-7>for i in range(m):</line-7>
<line-8> ans+=1</line-8>
<line-9> f,p,s=list(map(str,input().split()))</line-9>
<line-10> f=int(f)</line-10>
<line-11> poww=pow(1,2)</line-11>
<line-12> p=int(p)</line-12>
<line-13> if f not in li:</line-13>
<line-14> ans+=1</line-14>
<line-15> non_special.append((p,s))</line-15>
<line-16> ans-=1</line-16>
<line-17> else:</line-17>
<line-18> ans+=1</line-18>
<line-19> special.append((p,s))</line-19>
<line-20> </line-20>
<line-21>non_special.sort(reverse=True)</line-21>
<line-22>aaaa=pow(1,2)</line-22>
<line-23>special.sort(reverse=True)</line-23>
<line-24></line-24>
<line-25>for temp in range(len(special)):</line-25>
<line-26> ans+=1</line-26>
<line-27> print(special[temp][1])</line-27>
<line-28>for temp in non_special:</line-28>
<line-30> print(temp[1])</line-30>
|
{"code": "<line-2>ans=0</line-2>\n<line-29> ans+=1</line-29>", "lines": [2, 29]}
#### 0
|
<line-1>from collections import defaultdict</line-1>
<line-3>#def dfs(l,r,dct):</line-3>
<line-4>def dfs(l,r,dct):</line-4>
<line-5> visit=[0 for i in range(n+1)]</line-5>
<line-6> arr=[l]</line-6>
<line-7> while(arr):</line-7>
<line-8> node=arr.pop()</line-8>
<line-9> if node==r:return True</line-9>
<line-10> visit[node]=1</line-10>
<line-11> for lnk in dct[node]:</line-11>
<line-12> if not visit[lnk]:</line-12>
<line-13> arr.append(lnk)</line-13>
<line-14> return False</line-14>
<line-15> </line-15>
<line-16>def ok(mid,cst):</line-16>
<line-17> for i,j in edges:</line-17>
<line-18> cst[i][j]-=mid</line-18>
<line-19> </line-19>
<line-20> d=[10**9]*(n+1)</line-20>
<line-21> d[l]=0</line-21>
<line-22> for _ in range(n-1):</line-22>
<line-23> for i,j in edges:</line-23>
<line-24> d[j]=min(d[j],d[i]+cst[i][j])</line-24>
<line-25> </line-25>
<line-26> if d[r]<=0:return 1</line-26>
<line-27> for i,j in edges:</line-27>
<line-28> if d[j]>d[i]+cst[i][j] and dfs(l,i,dct) and dfs(j,r,dct):</line-28>
<line-29> return 1</line-29>
<line-30> return 0</line-30>
<line-31> </line-31>
<line-32>for _ in range(int(input())):</line-32>
<line-33> n,m=map(int,input().split())</line-33>
<line-34> dct=defaultdict(list)</line-34>
<line-35> </line-35>
<line-36> cost=[[1000 for i in range(n+1)] for j in range(n+1)]</line-36>
<line-37> edges=[]</line-37>
<line-38> for i in range(m):</line-38>
<line-39> a,b,w=map(int,input().split())</line-39>
<line-40> edges.append([a,b])</line-40>
<line-41> dct[a].append(b)</line-41>
<line-42> cost[a][b]=min(cost[a][b],w)</line-42>
<line-43> </line-43>
<line-44> l,r=map(int,input().split())</line-44>
<line-45> if not dfs(l,r,dct):</line-45>
<line-46> print(-1)</line-46>
<line-47> continue</line-47>
<line-48> #print(cost)</line-48>
<line-49> lo=1</line-49>
<line-50> hi=101</line-50>
<line-51> for i in range(100):</line-51>
<line-52> cst=copy.deepcopy(cost)</line-52>
<line-53> mid=(lo+hi)/2</line-53>
<line-54> if ok(mid,cst):hi=mid-1</line-54>
<line-56> print("%.7f"%mid)</line-56>
|
{"code": "<line-2>import copy</line-2>\n<line-55> else:lo=mid+1</line-55>", "lines": [2, 55]}
#### 0
|
<line-1>from sys import *</line-1>
<line-3>for u in range(int(input())):</line-3>
<line-4> s=int(input())</line-4>
<line-5> if(s%3==0):</line-5>
<line-6> print(1)</line-6>
<line-8> print(0)</line-8>
|
{"code": "<line-2>input=stdin.readline</line-2>\n<line-7> else:</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>m= 1000000007</line-1>
<line-3> return [(a[0]*b[0]+a[1]*b[2])%m,</line-3>
<line-4> (a[0]*b[1]+a[1]*b[3])%m,</line-4>
<line-5> (a[2]*b[0]+a[3]*b[2])%m,</line-5>
<line-6> (a[2]*b[1]+a[3]*b[3])%m] </line-6>
<line-7>def f(n):</line-7>
<line-8> if n==0:</line-8>
<line-9> return 0</line-9>
<line-10> v1, v2, v3 = 1, 1, 0 </line-10>
<line-11> for rec in bin(n)[3:]:</line-11>
<line-12> v2=v2%m</line-12>
<line-13> v1=v1%m</line-13>
<line-14> v3=v3%m</line-14>
<line-15> calc = (v2*v2)</line-15>
<line-16> v1, v2, v3 = (v1*v1+calc), ((v1+v3)*v2), (calc+v3*v3)</line-16>
<line-17> if rec=='1': v1, v2, v3 = v1+v2, v1, v2</line-17>
<line-18> return [v1+1,v2,v2,v3+1]</line-18>
<line-19></line-19>
<line-20>def q(X,Y):</line-20>
<line-21> nonlocal A</line-21>
<line-22> s = [1,0,0,1]</line-22>
<line-23> for v in A[X-1:Y]:</line-23>
<line-24> s = mul(s,f(v))</line-24>
<line-25> return s[1]%m</line-25>
<line-26></line-26>
<line-27>N,M = list(map(int,input().split()))</line-27>
<line-28>A=list(map(int,input().split()))</line-28>
<line-29>for _ in range(M):</line-29>
<line-30> [T,X,Y] = input().split()</line-30>
<line-31> X,Y = int(X),int(Y)</line-31>
<line-32> if T=='Q':</line-32>
<line-33> print(q(X,Y))</line-33>
<line-35> A[X-1]=Y</line-35>
|
{"code": "<line-2>def mul(a,b):</line-2>\n<line-34> else:</line-34>", "lines": [2, 34]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> arr=list(map(int,input().split()))</line-3>
<line-4> d=set()</line-4>
<line-5> for i in arr:</line-5>
<line-6> d.add(i)</line-6>
<line-7> for i in range(n):</line-7>
<line-8> if i in d:</line-8>
<line-9> print(i,end=" ")</line-9>
<line-10> else:</line-10>
<line-12> print()</line-12>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-11> print(0,end=\" \")</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>from collections import Counter</line-1>
<line-3>for i in range(t):</line-3>
<line-4> k=int(input())</line-4>
<line-5> l=list(map(int,input().split()))</line-5>
<line-6> a=Counter(l)</line-6>
<line-7> b=list(a.keys())</line-7>
<line-8> b.sort()</line-8>
<line-9> for x in b:</line-9>
<line-11> print(s)</line-11>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-10> s=str(x)+': '+str(a[x])</line-10>", "lines": [2, 10]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> if px[1]==x[1]:</line-3>
<line-4> return (x[2]-px[2])<=(x[0]-px[0]) and (x[2]>=px[2])</line-4>
<line-5> else:</line-5>
<line-6> return (x[2]-px[2]+1)<=(x[0]-px[0]) and (x[2]>=px[2])</line-6>
<line-7> </line-7>
<line-8>def checkdouble(px,x):</line-8>
<line-9> if px[3]==x[3]:</line-9>
<line-10> return (x[4]-px[4])<=(x[0]-px[0]) and (x[4]>=px[4])</line-10>
<line-11> else:</line-11>
<line-12> return (x[4]-px[4]+1)<=(x[0]-px[0]) and (x[4]>=px[4])</line-12>
<line-13> </line-13>
<line-14></line-14>
<line-15>for _ in range(int(input())):</line-15>
<line-16> px=[0,1,1,2,1]</line-16>
<line-17> g=True</line-17>
<line-18> for _ in range(int(input())):</line-18>
<line-19> x=list(map(int,input().split()))</line-19>
<line-20> if x[1]==x[3] and x[2]==x[4]:</line-20>
<line-21> g=False</line-21>
<line-22> if not g:</line-22>
<line-23> continue</line-23>
<line-24> g=check(px,x)</line-24>
<line-25> if g:</line-25>
<line-26> g=checkdouble(px,x)</line-26>
<line-27> px=x</line-27>
<line-28> if not g:</line-28>
<line-29> print("no")</line-29>
<line-31> print("yes")</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>
|
{"code": "<line-2>def check(px,x):</line-2>\n<line-30> else:</line-30>", "lines": [2, 30]}
#### 0
|
<line-1>A = [0] * 100001</line-1>
<line-3></line-3>
<line-4>def nCk(n, k):</line-4>
<line-5> if k ==0 or k ==n:</line-5>
<line-6> return 1</line-6>
<line-7> r = (A[n-k]*A[k])%M</line-7>
<line-8> x = (A[n]*pow(r, M-2, M))%M</line-8>
<line-9> return x</line-9>
<line-10></line-10>
<line-11>for _ in range(int(input())):</line-11>
<line-12> n, k = list(map(int, input().split()))</line-12>
<line-13> for i in range(n-1):</line-13>
<line-14> u,v = input().split()</line-14>
<line-15> summ = 0</line-15>
<line-16> A[0] = 1</line-16>
<line-17> for i in range(1, len(A)):</line-17>
<line-18> A[i] = (i*A[i-1])%M</line-18>
<line-19> for i in range(min(n, k)):</line-19>
<line-20> b = nCk(k,i+1)</line-20>
<line-21> c = (nCk(n-1,i)*b)%M</line-21>
<line-22> c *= A[i+1]</line-22>
<line-23> summ += (c%M)</line-23>
<line-25> print(summ)</line-25>
|
{"code": "<line-2>M = 1000000007</line-2>\n<line-24> summ %= M</line-24>", "lines": [2, 24]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> while(val >= n):</line-3>
<line-4> val = val//2</line-4>
<line-5> return n - val</line-5>
<line-6>t = int(input())</line-6>
<line-7>for _ in range(t):</line-7>
<line-8> n = int(input())</line-8>
<line-9> arr = list(map(int,input().split())) </line-9>
<line-10> new = [0 for i in range(n)]</line-10>
<line-11> for i in range(n):</line-11>
<line-12> if arr[i]<=n :</line-12>
<line-13> new[i] = arr[i] + arr[arr[i]-1]</line-13>
<line-14> else:</line-14>
<line-16> print(*new)</line-16>
|
{"code": "<line-2>def index(n,val):</line-2>\n<line-15> new[i] = arr[index(n,arr[i]) - 1]</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>t=[[1]]</line-1>
<line-3> ## Swap start and stop if start > stop</line-3>
<line-4> if stop < start: start, stop = stop, start</line-4>
<line-5> if start < 1: start = 1</line-5>
<line-6> if stop < 1: stop = 1</line-6>
<line-7> c = 1 ## Bell numbers count</line-7>
<line-8> while c <= stop:</line-8>
<line-9> if c >= start:</line-9>
<line-10> yield t[-1][0] ## Yield the Bell number of the previous row</line-10>
<line-11> row = [t[-1][-1]] ## Initialize a new row</line-11>
<line-12> for b in t[-1]:</line-12>
<line-13> row.append((row[-1] + b)%1000000007)</line-13>
<line-14> c += 1 ## We have found another Bell number</line-14>
<line-15> t.append(row) ## Append the row to the triangle</line-15>
<line-16></line-16>
<line-17>ar=[0]*1001</line-17>
<line-18>i=0</line-18>
<line-19>for b in bell_numbers(1,1001):</line-19>
<line-20> ar[i]=b</line-20>
<line-21> i+=1</line-21>
<line-22>T=eval(input())</line-22>
<line-23>while T:</line-23>
<line-24> N=eval(input())</line-24>
<line-26> T-=1</line-26>
|
{"code": "<line-2>def bell_numbers(start, stop):</line-2>\n<line-25> print(ar[N])</line-25>", "lines": [2, 25]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n=int(input())</line-3>
<line-4> lst=list(map(int,input().split()))</line-4>
<line-5> f=0</line-5>
<line-6> t=0</line-6>
<line-7> p=1</line-7>
<line-8> for i in lst:</line-8>
<line-9> if(i==5):</line-9>
<line-10> f+=1</line-10>
<line-11> elif(i==10):</line-11>
<line-12> if(f>0):</line-12>
<line-13> f-=1</line-13>
<line-14> t+=1</line-14>
<line-15> else:</line-15>
<line-16> p=0</line-16>
<line-17> break</line-17>
<line-18> else:</line-18>
<line-19> if(t>0):</line-19>
<line-20> t-=1</line-20>
<line-21> else:</line-21>
<line-22> if(f>1):</line-22>
<line-23> f-=2</line-23>
<line-24> else:</line-24>
<line-25> p=0</line-25>
<line-26> break</line-26>
<line-27> if(p==1):</line-27>
<line-28> print("YES")</line-28>
<line-30> print("NO")</line-30>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-29> else:</line-29>", "lines": [2, 29]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3></line-3>
<line-4>for _ in range(int(input())):</line-4>
<line-5> w,k=map(str, input().split())</line-5>
<line-6> k=int(k)</line-6>
<line-7> n=len(w)</line-7>
<line-8> w=list(w)</line-8>
<line-9> w.sort()</line-9>
<line-10> w.append('0')</line-10>
<line-11> c=1</line-11>
<line-12> l=0</line-12>
<line-13> l1=[]</line-13>
<line-14> l2=[]</line-14>
<line-15> for i in range(1, n+1):</line-15>
<line-16> if w[i]==w[i-1]:</line-16>
<line-17> c+=1</line-17>
<line-18> else:</line-18>
<line-19> a=bisect.bisect_left(l1, c)</line-19>
<line-20> if a==l:</line-20>
<line-21> l1.append(c)</line-21>
<line-22> l2.append(1)</line-22>
<line-23> l+=1</line-23>
<line-24> elif l1[a]==c:</line-24>
<line-25> l2[a]=l2[a]+1</line-25>
<line-26> else:</line-26>
<line-27> l1.insert(a, c)</line-27>
<line-28> l2.insert(a, 1)</line-28>
<line-29> l+=1</line-29>
<line-30> c=1</line-30>
<line-31> a=l1[-1]-l1[0]</line-31>
<line-32> if a<=k:</line-32>
<line-33> print(0)</line-33>
<line-34> else:</line-34>
<line-35> ans=n </line-35>
<line-36> for i in range(l):</line-36>
<line-37> temp=l2[i]*l1[i]</line-37>
<line-38> for j in range(i+1, l):</line-38>
<line-39> p=l1[j]-l1[i]</line-39>
<line-40> if p<=k:</line-40>
<line-41> temp+=(l2[j]*l1[j])</line-41>
<line-42> else:</line-42>
<line-43> p1=p-k</line-43>
<line-44> temp+=(l2[j]*(l1[j]-p1))</line-44>
<line-46> </line-46>
<line-47> print(ans)</line-47>
|
{"code": "<line-2>import bisect</line-2>\n<line-45> ans=min(ans, (n-temp))</line-45>", "lines": [2, 45]}
#### 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> odd=0</line-5>
<line-6> even=0</line-6>
<line-7> if n==1:</line-7>
<line-8> print(0)</line-8>
<line-9> continue</line-9>
<line-10> for i in range(n):</line-10>
<line-11> if ar[i]%2==1:</line-11>
<line-12> odd+=1</line-12>
<line-13> else:</line-13>
<line-14> even+=1</line-14>
<line-15> if odd>0:</line-15>
<line-16> vo=(odd-1)*2+even</line-16>
<line-17> else:</line-17>
<line-18> vo=even</line-18>
<line-19> if even>0:</line-19>
<line-20> ve=(even-1)*2+odd</line-20>
<line-21> else:</line-21>
<line-23> print(min(vo,ve))</line-23>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-22> ve=odd</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>for _ in range(eval(input())):</line-1>
<line-3> m1=len(S1)/2</line-3>
<line-4></line-4>
<line-5> S2=input()</line-5>
<line-6> m2=len(S2)/2</line-6>
<line-7> d1={}</line-7>
<line-8> d2={}</line-8>
<line-9> for i in range(len(S1)):</line-9>
<line-10> c=S1[i]</line-10>
<line-11> v=abs(m1-i)</line-11>
<line-12> if c in d1:</line-12>
<line-13> if v<d1[c][0]:</line-13>
<line-14> d1[c]=[v,i]</line-14>
<line-15> else:</line-15>
<line-16> d1[c]=[v,i]</line-16>
<line-17> for i in range(len(S2)):</line-17>
<line-18> c=S2[i]</line-18>
<line-19> v=abs(m2-i)</line-19>
<line-20> if c in d2:</line-20>
<line-21> if v<d2[c][0]:</line-21>
<line-22> d2[c]=[v,i]</line-22>
<line-23> else:</line-23>
<line-24> d2[c]=[v,i]</line-24>
<line-25></line-25>
<line-26> mini=999999999999999999999999999999999</line-26>
<line-27> for i in d1:</line-27>
<line-28> if i in d2:</line-28>
<line-29> L1=d1[i][1]</line-29>
<line-30> L3=len(S1)-L1-1</line-30>
<line-31> L2=d2[i][1]</line-31>
<line-32> L4=len(S2)-L2-1</line-32>
<line-33> v=abs(L1-L2)+abs(L2-L3)+abs(L3-L4)+abs(L4-L1)</line-33>
<line-34> if v<mini:</line-34>
<line-36> print(mini)</line-36>
|
{"code": "<line-2> S1=input()</line-2>\n<line-35> mini=v</line-35>", "lines": [2, 35]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>n, k = map(int, input().split())</line-3>
<line-4>lst = list(map(int, input().split()))</line-4>
<line-5>temp = (10**9)+7</line-5>
<line-6>for i in range(k):</line-6>
<line-7> lst = list(accumulate(lst))</line-7>
<line-9> print(i%(temp), end = ' ')</line-9>
|
{"code": "<line-2>from itertools import accumulate</line-2>\n<line-8>for i in lst:</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>"""</line-1>
<line-3>4</line-3>
<line-4>4 3 1 2</line-4>
<line-5>6</line-5>
<line-6>1 2 2 1 3 1</line-6>
<line-7>5</line-7>
<line-8>10 1 2 10 5</line-8>
<line-9>4</line-9>
<line-10>1 2 1 2</line-10>
<line-11>"""</line-11>
<line-12>tests = int(input())</line-12>
<line-13></line-13>
<line-14>for _ in range(tests):</line-14>
<line-15></line-15>
<line-16> n = int(input())</line-16>
<line-17> ls = list(map(int, input().split()))</line-17>
<line-18></line-18>
<line-19> if ls[0] < ls[1]:</line-19>
<line-20> ls[0] = -ls[0]</line-20>
<line-21></line-21>
<line-22> if ls[-1] < ls[-2]:</line-22>
<line-23> ls[-1] = -ls[-1]</line-23>
<line-24></line-24>
<line-25> for i in range(1, n - 1):</line-25>
<line-26> if ls[i] < ls[i - 1] and ls[i] < ls[i + 1]:</line-26>
<line-27> ls[i] = -ls[i]</line-27>
<line-28> '''</line-28>
<line-29> if i > 1 and ls[i - 2] < 0 and ls[i] - ls[i-2] >= ls[i-1]:</line-29>
<line-30> # There can be only one!</line-30>
<line-31> if -ls[i-2] < ls[i]:</line-31>
<line-32> # We win!</line-32>
<line-33> ls[i-2] = -ls[i-2]</line-33>
<line-34> ls[i] = -ls[i]</line-34>
<line-35> #else:</line-35>
<line-36> # They win!</line-36>
<line-37> # Do nothing</line-37>
<line-38> else:</line-38>
<line-39> # We both can go negative</line-39>
<line-40> ls[i] = -ls[i]</line-40>
<line-41> '''</line-41>
<line-42> </line-42>
<line-43> #print(ls)</line-43>
<line-44> </line-44>
<line-45> ind = 1</line-45>
<line-46></line-46>
<line-47> while ind < n - 1:</line-47>
<line-48></line-48>
<line-49> started = False</line-49>
<line-50> pos = []</line-50>
<line-51> while ind < n - 1 and ls[ind] + ls[ind - 1] + ls[ind + 1] <= 0:</line-51>
<line-52> if not started:</line-52>
<line-53> pos.append(ind - 1)</line-53>
<line-54> pos.append(ind + 1)</line-54>
<line-55> started = True</line-55>
<line-56> else:</line-56>
<line-57> pos.append(ind + 1)</line-57>
<line-58> ind += 2</line-58>
<line-59></line-59>
<line-60> #print(pos,ls)</line-60>
<line-61></line-61>
<line-62> if started:</line-62>
<line-63> rec = [0] * (len(pos) + 1)</line-63>
<line-64></line-64>
<line-65> for i in pos:</line-65>
<line-66> ls[i] = -ls[i]</line-66>
<line-67></line-67>
<line-68> rec[0] = 0</line-68>
<line-69> rec[1] = ls[pos[0]]</line-69>
<line-70></line-70>
<line-71> for i in range(2, len(pos) + 1):</line-71>
<line-72> rec[i] = max(rec[i - 1], ls[pos[i - 1]] + rec[i - 2])</line-72>
<line-73></line-73>
<line-74> itr = len(pos)</line-74>
<line-75> while itr > 0:</line-75>
<line-76> if itr == 1 or rec[itr] == ls[pos[itr - 1]] + rec[itr - 2]:</line-76>
<line-77> ls[pos[itr - 1]] = -ls[pos[itr - 1]]</line-77>
<line-78> itr -= 2</line-78>
<line-79> else:</line-79>
<line-80> itr -= 1</line-80>
<line-81></line-81>
<line-82> ind += 1</line-82>
<line-83></line-83>
<line-84> for i in ls:</line-84>
<line-86> print() </line-86>
<line-87></line-87>
<line-88> </line-88>
<line-89></line-89>
|
{"code": "<line-2>4</line-2>\n<line-85> print(i, end = ' ')</line-85>", "lines": [2, 85]}
#### 0
|
<line-1>val = 10**9 + 7</line-1>
<line-3> aans = a</line-3>
<line-4> ans = 1</line-4>
<line-5> while b>0:</line-5>
<line-6> ans = (ans*aans)%val</line-6>
<line-7> aans = (aans*aans)%val</line-7>
<line-8> b/=2</line-8>
<line-9> return ans%val</line-9>
<line-10> </line-10>
<line-11></line-11>
<line-12></line-12>
<line-13>for i in range(eval(input())): </line-13>
<line-14> n,d= list(map(int,input().split()))</line-14>
<line-15> a=int(str(d)*n)</line-15>
<line-16> sqr = str(a*a)</line-16>
<line-17> ans =0</line-17>
<line-18> count=0</line-18>
<line-19> for ii in sqr :</line-19>
<line-20> ans= ans+int(ii)*23**count</line-20>
<line-21> count+=1</line-21>
<line-23> print(ans % (10**9+7))</line-23>
<line-24> </line-24>
<line-25> </line-25>
|
{"code": "<line-2>def MOD(a,b):</line-2>\n<line-22> z=int(ii)*ans</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> n, c = list(map(int,input().split()))</line-4>
<line-5></line-5>
<line-6> pts = {}</line-6>
<line-7> moves = 0</line-7>
<line-8></line-8>
<line-9> for i in range(n):</line-9>
<line-10> x, y = list(map(int,input().split()))</line-10>
<line-11> if (y-x,x%c) in pts:</line-11>
<line-12> pts[(y-x,x%c)].append(x)</line-12>
<line-13> else:</line-13>
<line-14> pts[(y-x,x%c)] = [x]</line-14>
<line-15> </line-15>
<line-16> for i in pts:</line-16>
<line-17> arc = sorted(pts[i])</line-17>
<line-18> </line-18>
<line-19> for j in arc:</line-19>
<line-21> </line-21>
<line-22> print(len(pts),moves)</line-22>
<line-23></line-23>
<line-24></line-24>
<line-25> </line-25>
<line-26></line-26>
<line-27></line-27>
|
{"code": "<line-3>for i in range(t):</line-3>\n<line-20> moves = moves + abs((j-arc[len(arc)//2]))//c</line-20>", "lines": [3, 20]}
#### 0
|
<line-1>tb=str(input())</line-1>
<line-3>if("c" in tb or "k" in tb):</line-3>
<line-4> print(0)</line-4>
<line-5>else:</line-5>
<line-6> ans=1</line-6>
<line-7> i=0</line-7>
<line-8> while(i<len(tb)):</line-8>
<line-9> if(tb[i]=="g" or tb[i]=="f"):</line-9>
<line-10> my=tb[i]</line-10>
<line-11> i+=1</line-11>
<line-12> ct=1</line-12>
<line-13> while(i<len(tb) and tb[i]==my):</line-13>
<line-14> ct+=1</line-14>
<line-15> i+=1</line-15>
<line-16> if(ct>3):</line-16>
<line-17> ct+=1</line-17>
<line-18> ans*=ct</line-18>
<line-19> else:</line-19>
<line-21> print(ans)</line-21>
|
{"code": "<line-2>tb=list(tb)</line-2>\n<line-20> i+=1</line-20>", "lines": [2, 20]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(N):</line-3>
<line-4> n=int(input())</line-4>
<line-5> arr=list(map(int,input().split()))[:n]</line-5>
<line-6> count=0</line-6>
<line-7> last=0</line-7>
<line-8> for i in range(n):</line-8>
<line-9> if(arr[i]!=0):</line-9>
<line-10> break</line-10>
<line-11> last=i</line-11>
<line-12> count+=1</line-12>
<line-13> for i in arr[-1:last:-1]:</line-13>
<line-14> if(i!=0):</line-14>
<line-15> break</line-15>
<line-16> count+=1</line-16>
<line-17> ans=n-count</line-17>
<line-18> if(ans==0):</line-18>
<line-19> print(1)</line-19>
<line-21> print(ans)</line-21>
|
{"code": "<line-2>N=int(input())</line-2>\n<line-20> else:</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>from sys import stdin,stdout</line-1>
<line-2></line-2>
<line-3></line-3>
<line-4></line-4>
<line-5></line-5>
<line-7>def find(a):</line-7>
<line-8> if par[a]==a:</line-8>
<line-9> return a</line-9>
<line-10> else:</line-10>
<line-11> par[a]=find(par[a])</line-11>
<line-12> return par[a]</line-12>
<line-13>def union(a,b,c):</line-13>
<line-14> a,b=find(a),find(b)</line-14>
<line-15> nonlocal total_cost</line-15>
<line-16> total_cost+=(rank[a]*rank[b]*c)</line-16>
<line-17> if a!=b:</line-17>
<line-18> if rank[a]>rank[b]:</line-18>
<line-19> par[b]=a</line-19>
<line-20> rank[a]+=rank[b]</line-20>
<line-21> elif rank[b]>rank[a]:</line-21>
<line-22> par[a]=b</line-22>
<line-23> rank[b]+=rank[a]</line-23>
<line-24> else:</line-24>
<line-25> par[a]=b;</line-25>
<line-26> rank[b]+=rank[a]</line-26>
<line-27></line-27>
<line-28>n=int(stdin.readline().strip())</line-28>
<line-29>par=[i for i in range(n)]</line-29>
<line-30>rank=[1 for i in range(n)]</line-30>
<line-31>edges=[]</line-31>
<line-32>for i in range(n-1):</line-32>
<line-33> u,v,c=stdin.readline().strip().split(' ')</line-33>
<line-34> u,v,c=int(u)-1,int(v)-1,int(c)</line-34>
<line-35> edges.append((c,u,v))</line-35>
<line-36>edges.sort()</line-36>
<line-37>tw=0</line-37>
<line-38>for i in edges:</line-38>
<line-39> union(i[1],i[2],i[0])</line-39>
<line-41></line-41>
<line-42>stdout.write(str(tw-(total_cost/((n*(n-1))/2))))</line-42>
|
{"code": "<line-6>total_cost=0</line-6>\n<line-40> tw+=i[0]</line-40>", "lines": [6, 40]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> h,x=map(int,input().split())</line-3>
<line-4> if(h>=x):</line-4>
<line-5> print("Yes")</line-5>
<line-7> print("No")</line-7>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-6> else:</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>from math import sqrt </line-1>
<line-2></line-2>
<line-4>for i in range(test):</line-4>
<line-5> sum = 0</line-5>
<line-6> max = int(input())</line-6>
<line-7> if max==1:</line-7>
<line-8> sum = 0</line-8>
<line-9> elif max==2:</line-9>
<line-10> sum += 2</line-10>
<line-11> else: </line-11>
<line-12> sum = sum + 2</line-12>
<line-13> for x in range(3,max+1):</line-13>
<line-14> half = int(sqrt(x)) + 1</line-14>
<line-15> if all(x%y!=0 for y in range(2,half)):</line-15>
<line-17> print(sum) </line-17>
|
{"code": "<line-3>test = int(input())</line-3>\n<line-16> sum = sum + x</line-16>", "lines": [3, 16]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3></line-3>
<line-4> while int(n) >= 5:</line-4>
<line-6> break</line-6>
|
{"code": "<line-2> k, n = input().split()</line-2>\n<line-5> print(len(set(k)) ** 3)</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> y=[int(e) for e in yy.split()]</line-3>
<line-4> zz=input()</line-4>
<line-5> z=[int(e) for e in zz.split()]</line-5>
<line-6> count=0</line-6>
<line-7> for i in z:</line-7>
<line-8> a=i+y[1]</line-8>
<line-9> if a%7==0:</line-9>
<line-11> print(count)</line-11>
|
{"code": "<line-2> yy=input()</line-2>\n<line-10> count+=1</line-10>", "lines": [2, 10]}
#### 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> ar=list(map(int,input().split()))</line-5>
<line-6> if (ar[0]**2 + ar[1]**2 > ar[2]**2 + ar[3]**2):</line-6>
<line-7> print("B IS CLOSER")</line-7>
<line-8> else:</line-8>
<line-9> print("A IS CLOSER")</line-9>
<line-10> </line-10>
<line-11> </line-11>
<line-12> </line-12>
<line-14> pass</line-14>
<line-15> </line-15>
<line-16> </line-16>
|
{"code": "<line-2>try:</line-2>\n<line-13>except:</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>def main():</line-1>
<line-3> while(t!=0):</line-3>
<line-4> n,k = list(map(int , input().split()))</line-4>
<line-5> arr = list(map(int, input().split()))</line-5>
<line-6> freq = [0]*100001</line-6>
<line-7> k=k-1</line-7>
<line-8> st=0</line-8>
<line-9> end=0</line-9>
<line-10> currentCount=0</line-10>
<line-11> previousElement = 0</line-11>
<line-12> for i in range(n):</line-12>
<line-13> freq[arr[i]]+=1</line-13>
<line-14> if(freq[arr[i]]==1):</line-14>
<line-15> currentCount+=1</line-15>
<line-16></line-16>
<line-17> while(currentCount>k):</line-17>
<line-18> freq[arr[previousElement]]-=1</line-18>
<line-19> if(freq[arr[previousElement]]==0):</line-19>
<line-20> currentCount-=1</line-20>
<line-21></line-21>
<line-22> previousElement+=1</line-22>
<line-23></line-23>
<line-24> if(i-previousElement+1 >= end-st+1):</line-24>
<line-25> end=i</line-25>
<line-26> st=previousElement</line-26>
<line-27></line-27>
<line-28> print(end-st+1)</line-28>
<line-29> t=t-1</line-29>
<line-30></line-30>
<line-31>def __starting_point():</line-31>
<line-33></line-33>
<line-34></line-34>
<line-35></line-35>
<line-36></line-36>
<line-37></line-37>
<line-38>__starting_point()</line-38>
|
{"code": "<line-2> t= int(input())</line-2>\n<line-32> main()</line-32>", "lines": [2, 32]}
#### 0
|
<line-1>t=eval(input())</line-1>
<line-3> t=t-1</line-3>
<line-4> f1,f2,r1,r2,r3,r4=list(map(int,input().split()))</line-4>
<line-5> p1,p2,p3,p4=list(map(float,input().split()))</line-5>
<line-6> s1=(1-p1)*(-f1)+(r2-f1)*(1-p2)*p1+p1*p2*(r1-f1)</line-6>
<line-7> s2=(1-p3)*(-f2)+(r3-f2)*(p3)*(1-p4)+p3*p4*(r3+r4-f2)</line-7>
<line-8> if s1>s2:</line-8>
<line-9> print('FIRST')</line-9>
<line-10> elif s1<s2:</line-10>
<line-11> print('SECOND')</line-11>
<line-13> print('BOTH')</line-13>
<line-14> </line-14>
|
{"code": "<line-2>while t>0:</line-2>\n<line-12> else:</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3></line-3>
<line-4> s = int(input())</line-4>
<line-5></line-5>
<line-6> while s % 10 == 0 : </line-6>
<line-7> s /= 10</line-7>
<line-8></line-8>
<line-10></line-10>
<line-11> t = t - 1</line-11>
|
{"code": "<line-2>while t > 0:</line-2>\n<line-9> print(''.join(reversed(str(s))))</line-9>", "lines": [2, 9]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n,k=map(int,input().split())</line-3>
<line-4> c=[int(i) for i in input().split()]</line-4>
<line-5> i=0</line-5>
<line-6> m=0</line-6>
<line-7> if(n==2 and k==5):</line-7>
<line-8> c1=c</line-8>
<line-9> c.sort()</line-9>
<line-10> d=dict()</line-10>
<line-11> for i in range(len(c)):</line-11>
<line-12> for j in range(len(c1)):</line-12>
<line-13> if(c[i]==c1[j]):</line-13>
<line-14> d[i]=j</line-14>
<line-15> c1[j]=-1</line-15>
<line-16> break</line-16>
<line-17> </line-17>
<line-18> while(m<n):</line-18>
<line-19> if (i==n):</line-19>
<line-20> print(d[n],k,d[n-1],0)</line-20>
<line-21> c[n]-=k</line-21>
<line-22> m+=1</line-22>
<line-23> else:</line-23>
<line-24> if(c[i]>=k):</line-24>
<line-25> print(d[i],k,d[i+1],0)</line-25>
<line-26> c[i]=c[i]-k</line-26>
<line-27> m+=1</line-27>
<line-28> elif(c[i]==0):</line-28>
<line-29> i+=1</line-29>
<line-30> else:</line-30>
<line-31> for j in range(i+1,n+1):</line-31>
<line-32> if(c[i]+c[j]>=k):</line-32>
<line-33> print(d[i],c[i],d[j],k-c[i])</line-33>
<line-34> c[j]-=k-c[i]</line-34>
<line-35> c[i]=0</line-35>
<line-36> m+=1</line-36>
<line-37> break</line-37>
<line-38> </line-38>
<line-39> else:</line-39>
<line-40> while(m<n):</line-40>
<line-41> if (i==n):</line-41>
<line-42> print(n,k,n-1,0)</line-42>
<line-43> c[n]-=k</line-43>
<line-44> m+=1</line-44>
<line-45> else:</line-45>
<line-46> if(c[i]>=k):</line-46>
<line-47> print(i,k,i+1,0)</line-47>
<line-48> c[i]=c[i]-k</line-48>
<line-49> m+=1</line-49>
<line-50> elif(c[i]==0):</line-50>
<line-51> i+=1</line-51>
<line-52> else:</line-52>
<line-53> for j in range(i+1,n+1):</line-53>
<line-54> if(c[i]+c[j]>=k):</line-54>
<line-55> print(i,c[i],j,k-c[i])</line-55>
<line-56> c[j]-=k-c[i]</line-56>
<line-57> c[i]=0</line-57>
<line-59> break</line-59>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-58> m+=1</line-58>", "lines": [2, 58]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> x1,y1,x2,y2=map(int,input().split())</line-3>
<line-4> av1=(x1+y1)/2</line-4>
<line-5> av2=(x2+y2)/2</line-5>
<line-6> if(av1>av2):</line-6>
<line-7> print(av1-av2," DEGREE(S) ABOVE NORMAL")</line-7>
<line-9> print(av2-av1," DEGREE(S) BELOW NORMAL")</line-9>
|
{"code": "<line-2>for _ in range (int(input())):</line-2>\n<line-8> else:</line-8>", "lines": [2, 8]}
#### 0
|
<line-2>for i in range(k):</line-2>
<line-3> print(a%(n+1),end=' ')</line-3>
<line-4> a=a//(n+1)</line-4>
|
{"code": "<line-1>a,n,k = map(int,input().split())</line-1>", "lines": [1]}
#### 0
|
<line-1>import sys,math</line-1>
<line-2></line-2>
<line-4> inputfile = open(filename,'rU')</line-4>
<line-5> data = inputfile.readlines()</line-5>
<line-6> T=data.pop(0)</line-6>
<line-7> ans=[]</line-7>
<line-8> ansstring=str()</line-8>
<line-9> explored=[]</line-9>
<line-10> for i in T:</line-10>
<line-11> if i in explored:</line-11>
<line-12> #print explored</line-12>
<line-13> for j in range(len(ans)):</line-13>
<line-14> if ans[j][0]==i:</line-14>
<line-15> ans[j][1] += 1</line-15>
<line-16> else:</line-16>
<line-17> ans.append([i,1])</line-17>
<line-18> explored.append(i)</line-18>
<line-19> for i in ans:</line-19>
<line-20> ansstring += i[0]+str(i[1])</line-20>
<line-21> print(ansstring) </line-21>
<line-22> </line-22>
<line-23></line-23>
<line-24></line-24>
<line-25> inputfile.close()</line-25>
<line-26></line-26>
<line-27>def __starting_point():</line-27>
<line-29>__starting_point()</line-29>
|
{"code": "<line-3>def main(filename):</line-3>\n<line-28> main(sys.argv[1])</line-28>", "lines": [3, 28]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3></line-3>
<line-4>for t in range(T):</line-4>
<line-6> </line-6>
<line-7> print(int(((N-1)*(N))/2))</line-7>
|
{"code": "<line-2>T = int(input())</line-2>\n<line-5> N = int(input())</line-5>", "lines": [2, 5]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(t):</line-3>
<line-4> n, k, d = list(map(int, input().split()))</line-4>
<line-5> x = list(map(int, input().split()))</line-5>
<line-6> l = list(map(int, input().split()))</line-6>
<line-7> lane = 3 - l[0]</line-7>
<line-8> switched = -float('inf')</line-8>
<line-9> ans = k</line-9>
<line-10> for i in range(n):</line-10>
<line-11> if l[i] == lane:</line-11>
<line-12> if switched + d < x[i] and x[i - 1] + 1 < x[i]:</line-12>
<line-13> lane = 3 - lane</line-13>
<line-14> switched = max(x[i - 1] + 1, switched + d)</line-14>
<line-15> else:</line-15>
<line-16> ans = x[i]</line-16>
<line-18> print(ans)</line-18>
|
{"code": "<line-2>t = int(input())</line-2>\n<line-17> break</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>x=int(input())</line-3>
<line-4>l=[]</line-4>
<line-5>for i in a:</line-5>
<line-6> if i<0:</line-6>
<line-7> l.append(-i)</line-7>
<line-8>l.sort()</line-8>
<line-9>m=len(l)</line-9>
<line-10>ans=0</line-10>
<line-11>if l:</line-11>
<line-12> if x>n:</line-12>
<line-13> ans=sum(l)</line-13>
<line-14> else:</line-14>
<line-16>print(ans)</line-16>
<line-17></line-17>
<line-18> </line-18>
|
{"code": "<line-2>a=list(map(int,input().split()))</line-2>\n<line-15> ans=sum(l[m-x:])</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>T = int(input())</line-1>
<line-3> N, K1, K2 = list(map(int, input().split()))</line-3>
<line-4> P1, P2, P3, P4 = list(map(int, input().split()))</line-4>
<line-5> ans = 0</line-5>
<line-6> arr = [0] * (1005)</line-6>
<line-7></line-7>
<line-8> length = len(arr)</line-8>
<line-9> for i in range(1,N+1):</line-9>
<line-10></line-10>
<line-11> j = 0</line-11>
<line-12> while j < length:</line-12>
<line-13> arr[j] += 1</line-13>
<line-14> j += i</line-14>
<line-15></line-15>
<line-16> for i in range(K1,K2+1):</line-16>
<line-17> if arr[i]==3:</line-17>
<line-18> ans += P1</line-18>
<line-19> elif arr[i]%2==1:</line-19>
<line-20> ans += P2</line-20>
<line-21> else:</line-21>
<line-23></line-23>
<line-24> print(ans)</line-24>
|
{"code": "<line-2>for _ in range(T):</line-2>\n<line-22> ans += P3</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-2></line-2>
<line-4> l = [*map(int, input())]</line-4>
<line-5></line-5>
<line-6> count = [0] * (n + 1)</line-6>
<line-7></line-7>
<line-8> for i in range(n - 1, -1, -1):</line-8>
<line-9> if l[i] == 1:</line-9>
<line-10> count[i] = count[i + 1] + 1</line-10>
<line-11></line-11>
<line-12> x,y = 0,0</line-12>
<line-13> for i in range(n):</line-13>
<line-14> if l[i] == 1:</line-14>
<line-15> x += 1</line-15>
<line-16> else:</line-16>
<line-17> try:</line-17>
<line-18> y = max(y, x + k + count[i + k])</line-18>
<line-19></line-19>
<line-20> except:</line-20>
<line-21> y = max(y, x + min(k, n - i))</line-21>
<line-22> x = 0</line-22>
<line-24> print(y)</line-24>
|
{"code": "<line-3> n, k = map(int, input().split())</line-3>\n<line-23> y = max(y,x)</line-23>", "lines": [3, 23]}
#### 0
|
<line-1>def __starting_point():</line-1>
<line-3> for _ in range(t):</line-3>
<line-4> n,p=input().split()</line-4>
<line-5> n,p=int(n),int(p)</line-5>
<line-6> s=input()</line-6>
<line-7> a,b=0,0</line-7>
<line-8> arr=[0]*n</line-8>
<line-9> for i in range(n):</line-9>
<line-10> arr[i]=s[i]</line-10>
<line-11> for c in s:</line-11>
<line-12> if c=='a':</line-12>
<line-13> a+=1</line-13>
<line-14> else:</line-14>
<line-15> b+=1</line-15>
<line-16> swap=0</line-16>
<line-17> for i in range(a):</line-17>
<line-18> if s[i]=='b':</line-18>
<line-19> swap+=1</line-19>
<line-20> tmpp=p</line-20>
<line-21> if p<=swap:</line-21>
<line-22> for i in range(n):</line-22>
<line-23> if p==0:</line-23>
<line-24> break</line-24>
<line-25> if arr[i]=='b':</line-25>
<line-26> arr[i]='a'</line-26>
<line-27> p-=1</line-27>
<line-28> p=tmpp</line-28>
<line-29> for i in range(n-1,-1,-1):</line-29>
<line-30> if p==0:</line-30>
<line-31> break</line-31>
<line-32> if arr[i]=='a':</line-32>
<line-33> arr[i]='b'</line-33>
<line-34> p-=1</line-34>
<line-35> for c in arr:</line-35>
<line-36> print(c,end="")</line-36>
<line-37> print()</line-37>
<line-38> else:</line-38>
<line-39> for i in range(n):</line-39>
<line-40> if i<a:</line-40>
<line-41> arr[i]='a'</line-41>
<line-42> else:</line-42>
<line-43> arr[i]='b'</line-43>
<line-44> p-=swap</line-44>
<line-45> for i in range(n):</line-45>
<line-46> if arr[i]=='b':</line-46>
<line-47> if s[i]=='b' and p>=2:</line-47>
<line-48> p-=2</line-48>
<line-49> arr[i]='a'</line-49>
<line-50> if s[i]=='a' and p>=1:</line-50>
<line-51> p-=1</line-51>
<line-52> arr[i]='a'</line-52>
<line-53> for c in arr:</line-53>
<line-54> print(c,end="")</line-54>
<line-56>__starting_point()</line-56>
|
{"code": "<line-2> t=int(input())</line-2>\n<line-55> print()</line-55>", "lines": [2, 55]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.