question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1>for _ in range(int(input())):</line-1>
<line-3> mass = []</line-3>
<line-4> zo = 0</line-4>
<line-5> oz = 0</line-5>
<line-6> zz = 0</line-6>
<line-7> oo = 0</line-7>
<line-8> ozs = []</line-8>
<line-9> zos = []</line-9>
<line-10> ozss = set()</line-10>
<line-11> zoss = set()</line-11>
<line-12> for j in range(n):</line-12>
<line-13> k = input()</line-13>
<line-14> mass.append(k)</line-14>
<line-15> if k[0] == '0' and k[-1] == '1':</line-15>
<line-16> zoss.add(k)</line-16>
<line-17> zos.append(j + 1)</line-17>
<line-18> zo += 1</line-18>
<line-19> elif k[0] == '1' and k[-1] == '0':</line-19>
<line-20> ozss.add(k)</line-20>
<line-21> ozs.append(j + 1)</line-21>
<line-22> oz += 1</line-22>
<line-23> elif k[0] == '0' and k[-1] == '0':</line-23>
<line-24> zz += 1</line-24>
<line-25> else:</line-25>
<line-26> oo += 1</line-26>
<line-27> if zz and oo and not oz and not zo:</line-27>
<line-28> print(-1)</line-28>
<line-29> continue</line-29>
<line-30> else:</line-30>
<line-31> if zo > oz:</line-31>
<line-32> print((zo - oz) // 2)</line-32>
<line-33> ans = []</line-33>
<line-34> need = (zo - oz) // 2</line-34>
<line-35> i = 0</line-35>
<line-36> while need:</line-36>
<line-37> zzz = mass[zos[i] - 1][len(mass[zos[i] - 1]) - 1:: -1]</line-37>
<line-38> if zzz not in ozss:</line-38>
<line-39> ans.append(zos[i])</line-39>
<line-40> need -= 1</line-40>
<line-41> i += 1</line-41>
<line-42> print(*ans)</line-42>
<line-43> else:</line-43>
<line-44> print((oz - zo) // 2)</line-44>
<line-45> ans = []</line-45>
<line-46> need = (oz - zo) // 2</line-46>
<line-47> i = 0</line-47>
<line-48> while need:</line-48>
<line-49> zzz = mass[ozs[i] - 1][len(mass[ozs[i] - 1]) - 1:: -1]</line-49>
<line-50> if zzz not in zoss:</line-50>
<line-51> ans.append(ozs[i])</line-51>
<line-52> need -= 1</line-52>
<line-54> print(*ans)</line-54>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-53> i += 1</line-53>", "lines": [2, 53]}
#### 0
|
<line-1>q=int(input())</line-1>
<line-2></line-2>
<line-4> x,y,k=list(map(int,input().split()))</line-4>
<line-5> x,y=abs(x),abs(y)</line-5>
<line-6> x,y=max(x,y),min(x,y)</line-6>
<line-7> </line-7>
<line-8> if(x%2!=k%2):</line-8>
<line-9> k-=1</line-9>
<line-10> y-=1</line-10>
<line-11> </line-11>
<line-12> </line-12>
<line-13> if(x>k):</line-13>
<line-14> print(-1)</line-14>
<line-15> continue</line-15>
<line-16> if((x-y)%2):</line-16>
<line-17> k-=1</line-17>
<line-19> print(k)</line-19>
<line-20> </line-20>
<line-21> </line-21>
<line-22> </line-22>
|
{"code": "<line-3>for e in range(q):</line-3>\n<line-18> x-=1</line-18>", "lines": [3, 18]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from fractions import Fraction</line-3>
<line-4>from math import *</line-4>
<line-5> </line-5>
<line-6>def input():</line-6>
<line-7> return sys.stdin.readline().strip()</line-7>
<line-8> </line-8>
<line-9>def iinput():</line-9>
<line-10> return int(input())</line-10>
<line-11></line-11>
<line-12>def finput():</line-12>
<line-13> return float(input())</line-13>
<line-14></line-14>
<line-15>def tinput():</line-15>
<line-16> return input().split()</line-16>
<line-17></line-17>
<line-18>def linput():</line-18>
<line-19> return list(input())</line-19>
<line-20> </line-20>
<line-21>def rinput():</line-21>
<line-22> return list(map(int, tinput()))</line-22>
<line-23></line-23>
<line-24>def fiinput():</line-24>
<line-25> return list(map(float, tinput()))</line-25>
<line-26> </line-26>
<line-27>def rlinput():</line-27>
<line-28> return list(map(int, input().split()))</line-28>
<line-29>def trinput():</line-29>
<line-30> return tuple(rinput())</line-30>
<line-31></line-31>
<line-32>def srlinput():</line-32>
<line-33> return sorted(list(map(int, input().split())))</line-33>
<line-34></line-34>
<line-35>def NOYES(fl):</line-35>
<line-36> if fl:</line-36>
<line-37> print("NO")</line-37>
<line-38> else:</line-38>
<line-39> print("YES")</line-39>
<line-40>def YESNO(fl):</line-40>
<line-41> if fl:</line-41>
<line-42> print("YES")</line-42>
<line-43> else:</line-43>
<line-44> print("NO")</line-44>
<line-45> </line-45>
<line-46>def main():</line-46>
<line-47> n = iinput()</line-47>
<line-48> #k = iinput() </line-48>
<line-49> #m = iinput() </line-49>
<line-50> #n = int(sys.stdin.readline().strip()) </line-50>
<line-51> #n, k = rinput()</line-51>
<line-52> #n, m = rinput()</line-52>
<line-53> #m, k = rinput()</line-53>
<line-54> #n, k, m = rinput()</line-54>
<line-55> #n, m, k = rinput()</line-55>
<line-56> #k, n, m = rinput()</line-56>
<line-57> #k, m, n = rinput() </line-57>
<line-58> #m, k, n = rinput()</line-58>
<line-59> #m, n, k = rinput()</line-59>
<line-60> q = [rlinput(), rlinput(), rlinput()]</line-60>
<line-61> #q = linput()</line-61>
<line-62> ans = q[0].copy()</line-62>
<line-63> for i in range(1, n):</line-63>
<line-64> if ans[i] == ans[i - 1]:</line-64>
<line-65> ans[i] = q[1][i]</line-65>
<line-66> if i == n - 1:</line-66>
<line-67> o = 0</line-67>
<line-68> while q[o][i] == ans[n - 2] or q[o][i] == ans[0]:</line-68>
<line-69> o += 1</line-69>
<line-70> ans[i] = q[o][i]</line-70>
<line-71> print(*ans)</line-71>
<line-72></line-72>
<line-73> </line-73>
<line-74></line-74>
<line-75> </line-75>
<line-76> </line-76>
<line-77> </line-77>
<line-78> </line-78>
<line-79> </line-79>
<line-80> </line-80>
<line-81> </line-81>
<line-82> </line-82>
<line-83> </line-83>
<line-84> </line-84>
<line-85> </line-85>
<line-86></line-86>
<line-88> main()</line-88>
|
{"code": "<line-2>import random</line-2>\n<line-87>for i in range(iinput()):</line-87>", "lines": [2, 87]}
#### 0
|
<line-1>def solve():</line-1>
<line-3> lst = list(map(int,input().split()))</line-3>
<line-4> lst.sort()</line-4>
<line-5> ans = 0</line-5>
<line-6> for i in range(n - k - 1, n):</line-6>
<line-7> ans += lst[i]</line-7>
<line-8> print(ans)</line-8>
<line-10> solve()</line-10>
|
{"code": "<line-2> n, k = map(int,input().split())</line-2>\n<line-9>for i in range(int(input())):</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> nums = [int(x) for x in input().split()]</line-3>
<line-4> new_ar = list(zip(nums,[i for i in range(len(nums))]))</line-4>
<line-5> new_ar.sort()</line-5>
<line-6> </line-6>
<line-7> maxx = new_ar[0][1]</line-7>
<line-8> minn = new_ar[0][1]</line-8>
<line-9> s="1"</line-9>
<line-10> for j in range(1,len(new_ar)):</line-10>
<line-11> if(new_ar[j][1]>maxx):</line-11>
<line-12> maxx = new_ar[j][1]</line-12>
<line-13> if(new_ar[j][1]<minn):</line-13>
<line-14> minn = new_ar[j][1]</line-14>
<line-15> if(maxx-minn<j+1):</line-15>
<line-16> s+="1"</line-16>
<line-17> else:</line-17>
<line-19> </line-19>
<line-20> print(s)</line-20>
|
{"code": "<line-2> input()</line-2>\n<line-18> s+=\"0\"</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>def possible(a):</line-1>
<line-3> s = set()</line-3>
<line-4> lmax = 0</line-4>
<line-5> for i in range(len(a)):</line-5>
<line-6> lmax = max(lmax, a[i])</line-6>
<line-7> s.add(a[i])</line-7>
<line-8> if lmax == i + 1 and len(s) == i + 1:</line-8>
<line-9> ans.add(i + 1)</line-9>
<line-10> return ans</line-10>
<line-11></line-11>
<line-12></line-12>
<line-13>t = int(input())</line-13>
<line-14>for case_num in range(t):</line-14>
<line-15> n = int(input())</line-15>
<line-16> a = list(map(int, input().split(' ')))</line-16>
<line-17> left = possible(a)</line-17>
<line-18> a.reverse()</line-18>
<line-19> right = possible(a)</line-19>
<line-20> ans = []</line-20>
<line-21> for l in left:</line-21>
<line-22> if n - l in right:</line-22>
<line-23> ans.append(l)</line-23>
<line-24> print(len(ans))</line-24>
<line-26> print(l, n - l)</line-26>
|
{"code": "<line-2> ans = set()</line-2>\n<line-25> for l in ans:</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>import sys</line-1>
<line-3>for f in range(int(input())):</line-3>
<line-4> n,m=list(map(int,input().split()))</line-4>
<line-5> neig=[0]*n</line-5>
<line-6> for i in range(n):</line-6>
<line-7> neig[i]=[0]</line-7>
<line-8> </line-8>
<line-9> for i in range(m):</line-9>
<line-10> a,b=list(map(int,input().split()))</line-10>
<line-11> a-=1</line-11>
<line-12> b-=1</line-12>
<line-13> neig[a][0]+=1</line-13>
<line-14> neig[a].append(b)</line-14>
<line-15> lev=[1]*n</line-15>
<line-16> for i in range(n):</line-16>
<line-17> for j in range(1,neig[i][0]+1):</line-17>
<line-18> x=lev[i]+1</line-18>
<line-19> if x==4:</line-19>
<line-20> x=1</line-20>
<line-21> lev[neig[i][j]]=max(lev[neig[i][j]],x)</line-21>
<line-22> sol=0</line-22>
<line-23> s=[]</line-23>
<line-24> for i in range(n):</line-24>
<line-25> if lev[i]==3:</line-25>
<line-26> sol+=1</line-26>
<line-27> s.append(i+1)</line-27>
<line-29> print(*s)</line-29>
<line-30> </line-30>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-28> print(sol)</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>import sys</line-1>
<line-3> return sys.stdin.readline().rstrip()</line-3>
<line-4></line-4>
<line-5>class Heap:</line-5>
<line-6> def __init__( self ):</line-6>
<line-7> self.l = [ -1 ]</line-7>
<line-8> self.n = 0</line-8>
<line-9> def n( self ):</line-9>
<line-10> return self.n</line-10>
<line-11> def top( self ):</line-11>
<line-12> return self.l[ 1 ]</line-12>
<line-13> def ins( self, x ):</line-13>
<line-14> self.l.append( x )</line-14>
<line-15> n = len( self.l ) - 1</line-15>
<line-16> i = n</line-16>
<line-17> while i > 1:</line-17>
<line-18> j = i // 2</line-18>
<line-19> if self.l[ j ] > self.l[ i ]:</line-19>
<line-20> self.l[ j ], self.l[ i ] = self.l[ i ], self.l[ j ]</line-20>
<line-21> i = j</line-21>
<line-22> else:</line-22>
<line-23> break</line-23>
<line-24> def pop( self ):</line-24>
<line-25> r = self.l[ 1 ]</line-25>
<line-26> l = self.l.pop()</line-26>
<line-27> n = len( self.l ) - 1</line-27>
<line-28> if n:</line-28>
<line-29> self.l[ 1 ] = l</line-29>
<line-30> i = 1</line-30>
<line-31> while True:</line-31>
<line-32> j = i * 2</line-32>
<line-33> k = j + 1</line-33>
<line-34> if k < len( self.l ) and self.l[ i ] > max( self.l[ j ], self.l[ k ] ):</line-34>
<line-35> if self.l[ j ] == min( self.l[ j ], self.l[ k ] ):</line-35>
<line-36> self.l[ i ], self.l[ j ] = self.l[ j ], self.l[ i ]</line-36>
<line-37> i = j</line-37>
<line-38> else:</line-38>
<line-39> self.l[ i ], self.l[ k ] = self.l[ k ], self.l[ i ]</line-39>
<line-40> i = k</line-40>
<line-41> elif k < len( self.l ) and self.l[ i ] > self.l[ k ]:</line-41>
<line-42> self.l[ i ], self.l[ k ] = self.l[ k ], self.l[ i ]</line-42>
<line-43> i = k</line-43>
<line-44> elif j < len( self.l ) and self.l[ i ] > self.l[ j ]:</line-44>
<line-45> self.l[ i ], self.l[ j ] = self.l[ j ], self.l[ i ]</line-45>
<line-46> i = j</line-46>
<line-47> else:</line-47>
<line-48> break</line-48>
<line-49> return r</line-49>
<line-50></line-50>
<line-51>t = int( I() )</line-51>
<line-52>for _ in range( t ):</line-52>
<line-53> n = int( I() )</line-53>
<line-54> voter = [ list( map( int, I().split() ) ) for _ in range( n ) ]</line-54>
<line-55> h = Heap()</line-55>
<line-56> d = {}</line-56>
<line-57> for m, p in voter:</line-57>
<line-58> if m not in d:</line-58>
<line-59> d[ m ] = []</line-59>
<line-60> d[ m ].append( p )</line-60>
<line-61> need = {}</line-61>
<line-62> c = 0</line-62>
<line-63> sk = sorted( d.keys() )</line-63>
<line-64> for m in sk:</line-64>
<line-65> need[ m ] = max( 0, m - c )</line-65>
<line-66> c += len( d[ m ] )</line-66>
<line-67> c = 0</line-67>
<line-68> ans = 0</line-68>
<line-69> for m in sk[::-1]:</line-69>
<line-70> for p in d[ m ]:</line-70>
<line-71> h.ins( p )</line-71>
<line-72> while c < need[ m ]:</line-72>
<line-73> c += 1</line-73>
<line-75> print( ans )</line-75>
|
{"code": "<line-2>def I():</line-2>\n<line-74> ans += h.pop()</line-74>", "lines": [2, 74]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>def main():</line-4>
<line-5> n, k = map(int, input().split())</line-5>
<line-6> string = input().strip()</line-6>
<line-7> if "W" not in string:</line-7>
<line-8> ans = min(n, k) * 2 - 1</line-8>
<line-9> print(max(ans, 0))</line-9>
<line-10> return</line-10>
<line-11> </line-11>
<line-12> L_s = []</line-12>
<line-13> cnt = 0</line-13>
<line-14> bef = string[0]</line-14>
<line-15> ans = 0</line-15>
<line-16> for s in string:</line-16>
<line-17> if s == bef:</line-17>
<line-18> cnt += 1</line-18>
<line-19> else:</line-19>
<line-20> if bef == "L":</line-20>
<line-21> L_s.append(cnt)</line-21>
<line-22> else:</line-22>
<line-23> ans += cnt * 2 - 1</line-23>
<line-24> cnt = 1</line-24>
<line-25> bef = s</line-25>
<line-26> if bef == "W":</line-26>
<line-27> ans += cnt * 2 - 1</line-27>
<line-28> cnt = 0</line-28>
<line-29> </line-29>
<line-30> if string[0] == "L" and L_s:</line-30>
<line-31> cnt += L_s[0]</line-31>
<line-32> L_s = L_s[1:]</line-32>
<line-33> L_s.sort()</line-33>
<line-34> for l in L_s:</line-34>
<line-35> if k >= l:</line-35>
<line-36> ans += l * 2 + 1</line-36>
<line-37> k -= l</line-37>
<line-38> else:</line-38>
<line-39> ans += k * 2</line-39>
<line-40> k = 0</line-40>
<line-41> </line-41>
<line-42> ans += 2 * min(k, cnt)</line-42>
<line-43> print(ans)</line-43>
<line-44> </line-44>
<line-45> </line-45>
<line-46> </line-46>
<line-48> main()</line-48>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-47>for _ in range(int(input())):</line-47>", "lines": [2, 47]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> p = [i for i in s.split("0") if i!=""]</line-3>
<line-4> p.sort(reverse=True)</line-4>
<line-5> ans = 0</line-5>
<line-6> for i in range(0,len(p),2):</line-6>
<line-8> print(ans)</line-8>
<line-9></line-9>
|
{"code": "<line-2> s = input()</line-2>\n<line-7> ans+=len(p[i])</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> n = int(input())</line-3>
<line-4> arr = list(map(int, input().split()))</line-4>
<line-5> ans = [arr[0]]</line-5>
<line-6> for i in range(1, n - 1):</line-6>
<line-7> if arr[i - 1] < arr[i] and arr[i] > arr[i + 1]:</line-7>
<line-8> ans.append(arr[i])</line-8>
<line-9> elif arr[i - 1] > arr[i] and arr[i] < arr[i + 1]:</line-9>
<line-10> ans.append(arr[i])</line-10>
<line-11> ans.append(arr[-1])</line-11>
<line-13> print(*ans)</line-13>
|
{"code": "<line-2> # n, x = map(int, input().split())</line-2>\n<line-12> print(len(ans))</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-2></line-2>
<line-4> return (width+1) * (height+1)</line-4>
<line-5></line-5>
<line-6>def calcul(s1, c, s2) :</line-6>
<line-7> maxx, maxy, minx, miny = 0, 0, 0, 0</line-7>
<line-8> x, y = 0, 0</line-8>
<line-9> for k in range(len(s1)) :</line-9>
<line-10> if s1[k] == "W" :</line-10>
<line-11> y += 1</line-11>
<line-12> if s1[k] == "S" :</line-12>
<line-13> y -= 1</line-13>
<line-14> if s1[k] == "A" :</line-14>
<line-15> x -= 1</line-15>
<line-16> if s1[k] == "D" :</line-16>
<line-17> x += 1</line-17>
<line-18> maxx = max(maxx, x)</line-18>
<line-19> minx = min(minx, x)</line-19>
<line-20></line-20>
<line-21> maxy = max(maxy, y)</line-21>
<line-22> miny = min(miny, y)</line-22>
<line-23></line-23>
<line-24></line-24>
<line-25></line-25>
<line-26></line-26>
<line-27> if c == "W" :</line-27>
<line-28> y += 1</line-28>
<line-29> elif c == "S" :</line-29>
<line-30> y -= 1</line-30>
<line-31> elif c == "A" :</line-31>
<line-32> x -= 1</line-32>
<line-33> elif c == "D" :</line-33>
<line-34> x += 1</line-34>
<line-35> else :</line-35>
<line-36> print(c, "ok")</line-36>
<line-37></line-37>
<line-38> maxx = max(maxx, x)</line-38>
<line-39> minx = min(minx, x)</line-39>
<line-40></line-40>
<line-41> maxy = max(maxy, y)</line-41>
<line-42> miny = min(miny, y)</line-42>
<line-43></line-43>
<line-44> for k in range(len(s2)) :</line-44>
<line-45> if s2[k] == "W" :</line-45>
<line-46> y += 1</line-46>
<line-47> if s2[k] == "S" :</line-47>
<line-48> y -= 1</line-48>
<line-49> if s2[k] == "A" :</line-49>
<line-50> x -= 1</line-50>
<line-51> if s2[k] == "D" :</line-51>
<line-52> x += 1</line-52>
<line-53> maxx = max(maxx, x)</line-53>
<line-54> minx = min(minx, x)</line-54>
<line-55></line-55>
<line-56> maxy = max(maxy, y)</line-56>
<line-57> miny = min(miny, y)</line-57>
<line-58></line-58>
<line-59></line-59>
<line-60></line-60>
<line-61> diffx = maxx - minx</line-61>
<line-62> diffy = maxy - miny</line-62>
<line-63> tmp = area(diffx, diffy)</line-63>
<line-64></line-64>
<line-65></line-65>
<line-66> return tmp</line-66>
<line-67></line-67>
<line-68>def pre_calcul(s, moment, pre_avant, date_debut) :</line-68>
<line-69> x, y, maxx, minx, maxy, miny = pre_avant</line-69>
<line-70> for k in range(date_debut, moment) :</line-70>
<line-71> if s[k] == "W" :</line-71>
<line-72> y += 1</line-72>
<line-73> if s[k] == "S" :</line-73>
<line-74> y -= 1</line-74>
<line-75> if s[k] == "A" :</line-75>
<line-76> x -= 1</line-76>
<line-77> if s[k] == "D" :</line-77>
<line-78> x += 1</line-78>
<line-79> maxx = max(maxx, x)</line-79>
<line-80> minx = min(minx, x)</line-80>
<line-81></line-81>
<line-82> maxy = max(maxy, y)</line-82>
<line-83> miny = min(miny, y)</line-83>
<line-84></line-84>
<line-85> return (x, y, maxx, minx, maxy, miny)</line-85>
<line-86></line-86>
<line-87>def calcul2(s, c, moment, precalcul) :</line-87>
<line-88> x, y, maxx, minx, maxy, miny = precalcul</line-88>
<line-89></line-89>
<line-90></line-90>
<line-91></line-91>
<line-92> if c == "W" :</line-92>
<line-93> y += 1</line-93>
<line-94> elif c == "S" :</line-94>
<line-95> y -= 1</line-95>
<line-96> elif c == "A" :</line-96>
<line-97> x -= 1</line-97>
<line-98> elif c == "D" :</line-98>
<line-99> x += 1</line-99>
<line-100> else :</line-100>
<line-101> print(c, "ok")</line-101>
<line-102></line-102>
<line-103> maxx = max(maxx, x)</line-103>
<line-104> minx = min(minx, x)</line-104>
<line-105></line-105>
<line-106> maxy = max(maxy, y)</line-106>
<line-107> miny = min(miny, y)</line-107>
<line-108></line-108>
<line-109> for k in range(moment, len(s)) :</line-109>
<line-110> if s[k] == "W" :</line-110>
<line-111> y += 1</line-111>
<line-112> if s[k] == "S" :</line-112>
<line-113> y -= 1</line-113>
<line-114> if s[k] == "A" :</line-114>
<line-115> x -= 1</line-115>
<line-116> if s[k] == "D" :</line-116>
<line-117> x += 1</line-117>
<line-118> maxx = max(maxx, x)</line-118>
<line-119> minx = min(minx, x)</line-119>
<line-120></line-120>
<line-121> maxy = max(maxy, y)</line-121>
<line-122> miny = min(miny, y)</line-122>
<line-123></line-123>
<line-124></line-124>
<line-125></line-125>
<line-126> diffx = maxx - minx</line-126>
<line-127> diffy = maxy - miny</line-127>
<line-128> tmp = area(diffx, diffy)</line-128>
<line-129></line-129>
<line-130></line-130>
<line-131> return tmp</line-131>
<line-132></line-132>
<line-133>for _ in range(n) :</line-133>
<line-134> s = input()</line-134>
<line-135> maxx, maxy, minx, miny = 0, 0, 0, 0</line-135>
<line-136> x, y = 0, 0</line-136>
<line-137> momentminx, momentmaxx, momentminy, momentmaxy = -1, -1, -1, -1</line-137>
<line-138> for k in range(len(s)) :</line-138>
<line-139> if s[k] == "W" :</line-139>
<line-140> y += 1</line-140>
<line-141> if s[k] == "S" :</line-141>
<line-142> y -= 1</line-142>
<line-143> if s[k] == "A" :</line-143>
<line-144> x -= 1</line-144>
<line-145> if s[k] == "D" :</line-145>
<line-146> x += 1</line-146>
<line-147></line-147>
<line-148> if x > maxx :</line-148>
<line-149> momentmaxx = k</line-149>
<line-150> if y > maxy :</line-150>
<line-151> momentmaxy = k</line-151>
<line-152> if x < minx :</line-152>
<line-153> momentminx = k</line-153>
<line-154> if y < miny :</line-154>
<line-155> momentminy = k</line-155>
<line-156> maxx = max(maxx, x)</line-156>
<line-157> minx = min(minx, x)</line-157>
<line-158></line-158>
<line-159> maxy = max(maxy, y)</line-159>
<line-160> miny = min(miny, y)</line-160>
<line-161> diffx = maxx - minx</line-161>
<line-162> diffy = maxy - miny</line-162>
<line-163></line-163>
<line-164></line-164>
<line-165> tmp = 999999999999999999999999999999999999</line-165>
<line-166> l = [momentmaxx, momentmaxy, momentminx, momentminy]</line-166>
<line-167> l = list(set(l))</line-167>
<line-168> l = [i for i in l if i != -1]</line-168>
<line-169> l.sort()</line-169>
<line-170> if l != [] :</line-170>
<line-171> precalcul = pre_calcul(s, l[0], (0, 0, 0, 0, 0, 0), 0)</line-171>
<line-172> avant = l[0]</line-172>
<line-173> for moment in l :</line-173>
<line-174> precalcul = pre_calcul(s, moment, precalcul, avant)</line-174>
<line-175> avant = moment</line-175>
<line-176> tmp = min(tmp, calcul2(s, 'W', moment, precalcul))</line-176>
<line-177> tmp = min(tmp, calcul2(s, 'S', moment, precalcul))</line-177>
<line-178> tmp = min(tmp, calcul2(s, 'A', moment, precalcul))</line-178>
<line-180> print(tmp)</line-180>
|
{"code": "<line-3>def area(width, height) :</line-3>\n<line-179> tmp = min(tmp, calcul2(s, 'D', moment, precalcul))</line-179>", "lines": [3, 179]}
#### 0
|
<line-1>from math import *</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>for zz in range(int(input())):</line-5>
<line-6> n = int(input())</line-6>
<line-7> a = [ int(i) for i in input().split()]</line-7>
<line-8> b = [int(i) for i in input().split()]</line-8>
<line-9> ha = True</line-9>
<line-10> hp = False</line-10>
<line-11> hm = False</line-11>
<line-12> for i in range(n):</line-12>
<line-13> if b[i] != a[i]:</line-13>
<line-14> if b[i] > a[i]:</line-14>
<line-15> if (hp):</line-15>
<line-16> pass</line-16>
<line-17> else:</line-17>
<line-18> ha = False</line-18>
<line-19> break</line-19>
<line-20> else:</line-20>
<line-21> if (hm):</line-21>
<line-22> pass</line-22>
<line-23> else:</line-23>
<line-24> ha = False</line-24>
<line-25> break</line-25>
<line-26> if a[i] > 0:</line-26>
<line-27> hp = True</line-27>
<line-28> elif a[i] < 0:</line-28>
<line-29> hm = True</line-29>
<line-30></line-30>
<line-31> if ha:</line-31>
<line-32> print('YES')</line-32>
<line-34> print('NO')</line-34>
|
{"code": "<line-3>mod = 1000000007</line-3>\n<line-33> else:</line-33>", "lines": [3, 33]}
#### 0
|
<line-2> n,g,b=map(int,input().split())</line-2>
<line-3> nn=(n+1)//2</line-3>
<line-4> print(max(nn+(nn-1)//g*b,n))</line-4>
|
{"code": "<line-1>for i in range(int(input())):</line-1>", "lines": [1]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> a2, b2 = list(map(int, input().split()))</line-3>
<line-4> if a1 > b1:</line-4>
<line-5> a1, b1 = b1, a1</line-5>
<line-6> if a2 > b2:</line-6>
<line-7> a2, b2 = b2, a2</line-7>
<line-8> flag = False</line-8>
<line-9> if a1 == a2 and a1 == b1 + b2:</line-9>
<line-10> flag = True</line-10>
<line-11> if b1 == b2 and b1 == a1 + a2:</line-11>
<line-13> print('Yes' if flag else 'No')</line-13>
|
{"code": "<line-2> a1, b1 = list(map(int, input().split()))</line-2>\n<line-12> flag = True</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>from math import *</line-1>
<line-2></line-2>
<line-4>for zz in range(zzz):</line-4>
<line-6> print(max(x*b, (a-x-1)*b, y*a, (b - y - 1)*a))</line-6>
|
{"code": "<line-3>zzz = int(input())</line-3>\n<line-5> a, b, x, y = list(map(int, input().split()))</line-5>", "lines": [3, 5]}
#### 0
|
<line-1>from math import sqrt</line-1>
<line-3> def __init__(self,dif,sc):</line-3>
<line-4> self.dif=dif</line-4>
<line-5> self.sc=sc</line-5>
<line-6></line-6>
<line-7> def __lt__(self,other):</line-7>
<line-8> return self.dif>other.dif</line-8>
<line-9></line-9>
<line-10>T=int(input())</line-10>
<line-11>mul=[1]</line-11>
<line-12>for i in range(100):</line-12>
<line-13> mul.append(mul[i]*10/9)</line-13>
<line-14>inf=1000000007</line-14>
<line-15>for t in range(T):</line-15>
<line-16> n=int(input())</line-16>
<line-17> effi,tim=list(map(float,input().split()))</line-17>
<line-18> prob=[]</line-18>
<line-19> for i in range(n):</line-19>
<line-20> x,y=list(map(int,input().split()))</line-20>
<line-21> prob.append(pro(x,y))</line-21>
<line-22> prob.sort()</line-22>
<line-23> f=[[inf for i in range(n+1)] for j in range(1001)]</line-23>
<line-24> f[0][0]=0</line-24>
<line-25> totsc=0</line-25>
<line-26> for i in range(n):</line-26>
<line-27> totsc+=prob[i].sc</line-27>
<line-28> for j in range(totsc,prob[i].sc-1,-1):</line-28>
<line-29> for k in range(1,i+2):</line-29>
<line-30> f[j][k]=min(f[j][k],f[j-prob[i].sc][k-1]+prob[i].dif*mul[k])</line-30>
<line-31> for i in range(totsc,-1,-1):</line-31>
<line-32> flag=False</line-32>
<line-33> for j in range(n+1):</line-33>
<line-34> if sqrt(effi*f[i][j])>=1:</line-34>
<line-35> res=2*sqrt(f[i][j]/effi)-1/effi+10*j</line-35>
<line-36> else:</line-36>
<line-37> res=f[i][j]+10*j</line-37>
<line-38> if res<=tim:</line-38>
<line-39> print(i)</line-39>
<line-40> flag=True</line-40>
<line-41> break</line-41>
<line-43> break</line-43>
|
{"code": "<line-2>class pro(object):</line-2>\n<line-42> if flag==True:</line-42>", "lines": [2, 42]}
#### 0
|
<line-1>class BIT():</line-1>
<line-3> self.BIT=[0]*(n+1)</line-3>
<line-4> self.num=n</line-4>
<line-5></line-5>
<line-6> def query(self,idx):</line-6>
<line-7> res_sum = 0</line-7>
<line-8> while idx > 0:</line-8>
<line-9> res_sum += self.BIT[idx]</line-9>
<line-10> idx -= idx&(-idx)</line-10>
<line-11> return res_sum</line-11>
<line-12></line-12>
<line-13> #Ai += x O(logN)</line-13>
<line-14> def update(self,idx,x):</line-14>
<line-15> while idx <= self.num:</line-15>
<line-16> self.BIT[idx] += x</line-16>
<line-17> idx += idx&(-idx)</line-17>
<line-18> return</line-18>
<line-19></line-19>
<line-20>import sys,random</line-20>
<line-21></line-21>
<line-22>input=sys.stdin.readline</line-22>
<line-23></line-23>
<line-24>for _ in range(int(input())):</line-24>
<line-25> n=int(input())</line-25>
<line-26> a=list(map(int,input().split()))</line-26>
<line-27> pair=[[] for i in range(n+1)]</line-27>
<line-28> for i in range(n):</line-28>
<line-29> for j in range(i+1,n):</line-29>
<line-30> if a[i]==a[j]:</line-30>
<line-31> pair[i+1].append(j+1)</line-31>
<line-32></line-32>
<line-33> bit=BIT(n)</line-33>
<line-34> ans=0</line-34>
<line-35> for i in range(1,n+1):</line-35>
<line-36> minus=bit.query(i)</line-36>
<line-37> for r in pair[i]:</line-37>
<line-38> ans+=bit.query(r-1)-minus</line-38>
<line-39> for r in pair[i]:</line-39>
<line-41></line-41>
<line-42> print(ans)</line-42>
<line-43> </line-43>
|
{"code": "<line-2> def __init__(self,n):</line-2>\n<line-40> bit.update(r,1)</line-40>", "lines": [2, 40]}
#### 0
|
<line-1>import math</line-1>
<line-2></line-2>
<line-4>for _ in range(T):</line-4>
<line-6> print(1/math.tan(math.pi/2/n))</line-6>
|
{"code": "<line-3>T = int(input())</line-3>\n<line-5> n = int(input())</line-5>", "lines": [3, 5]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> a = list(map(int, input().split()))</line-3>
<line-4> s = {}</line-4>
<line-5> for q in range(d):</line-5>
<line-6> s[a[q]] = s.get(a[q], 0)+1</line-6>
<line-7> ans = len(s)</line-7>
<line-8> for q in range(d, n):</line-8>
<line-9> if s[a[q-d]] == 1:</line-9>
<line-10> del s[a[q-d]]</line-10>
<line-11> else:</line-11>
<line-12> s[a[q-d]] -= 1</line-12>
<line-13> s[a[q]] = s.get(a[q], 0)+1</line-13>
<line-15> print(ans)</line-15>
|
{"code": "<line-2> n, k, d = list(map(int, input().split()))</line-2>\n<line-14> ans = min(ans, len(s))</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>q = int(input())</line-1>
<line-3> n, m = list(map(int, input().split()))</line-3>
<line-4> info = [list(map(int, input().split())) for i in range(n)]</line-4>
<line-5> info = sorted(info)</line-5>
<line-6> now =(m, m)</line-6>
<line-7> time = 0</line-7>
<line-8> flag = True</line-8>
<line-9> for i in range(n):</line-9>
<line-10> t, l, h = info[i]</line-10>
<line-11> l_now = now[0] - (t - time)</line-11>
<line-12> h_now = now[1] + (t - time)</line-12>
<line-13> time = t</line-13>
<line-14> if h < l_now or h_now < l:</line-14>
<line-15> flag = False</line-15>
<line-16> else:</line-16>
<line-17> l_now = max(l_now, l)</line-17>
<line-18> h_now = min(h_now, h)</line-18>
<line-19> now = (l_now, h_now)</line-19>
<line-20> if flag:</line-20>
<line-21> print("YES")</line-21>
<line-23> print("NO")</line-23>
|
{"code": "<line-2>for _ in range(q):</line-2>\n<line-22> else:</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> n = list(input().strip())</line-4>
<line-5> s = list(map(int, input().strip().split()))</line-5>
<line-6></line-6>
<line-7> check = set(s)</line-7>
<line-8> found = False</line-8>
<line-9> for i in range(1, 1025):</line-9>
<line-10> newset = set([e^i for e in s])</line-10>
<line-11> if check == newset:</line-11>
<line-12> print(i)</line-12>
<line-13> found = True</line-13>
<line-14> break</line-14>
<line-16> print(-1)</line-16>
|
{"code": "<line-3>for _ in range(t):</line-3>\n<line-15> if not found:</line-15>", "lines": [3, 15]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>for _ in range(int(input())):</line-5>
<line-6> a, k = list(map(int, input().split()))</line-6>
<line-7> for _ in range(k - 1):</line-7>
<line-8> if '0' in str(a):</line-8>
<line-9> break</line-9>
<line-11> print(a)</line-11>
|
{"code": "<line-3>input = sys.stdin.readline</line-3>\n<line-10>\t\ta += int(min(list(str(a)))) * int(max(list(str(a))))</line-10>", "lines": [3, 10]}
#### 0
|
<line-1>import heapq</line-1>
<line-2></line-2>
<line-4> n = int(input())</line-4>
<line-5> voters = []</line-5>
<line-6> for i in range(n):</line-6>
<line-7> m,p = list(map(int, input().split()))</line-7>
<line-8> voters.append((m, -p))</line-8>
<line-9> voters.sort()</line-9>
<line-10> for i in range(n):</line-10>
<line-11> voters[i] = (voters[i][0], -voters[i][1])</line-11>
<line-12></line-12>
<line-13> ans = 0</line-13>
<line-14> costs = []</line-14>
<line-15> heapq.heapify(costs)</line-15>
<line-16> bought = 0</line-16>
<line-17> for i in range(n-1, -1, -1):</line-17>
<line-18> buysNeeded = voters[i][0] - i - bought</line-18>
<line-19> heapq.heappush(costs, voters[i][1])</line-19>
<line-20> while buysNeeded > 0 and len(costs) > 0:</line-20>
<line-21> ans += heapq.heappop(costs)</line-21>
<line-22> bought += 1</line-22>
<line-24></line-24>
<line-25> print(ans)</line-25>
|
{"code": "<line-3>for _ in range(int(input())):</line-3>\n<line-23> buysNeeded -= 1</line-23>", "lines": [3, 23]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> anws=False</line-3>
<line-4> if d**2>=4*d:</line-4>
<line-5> root=(d**2-4*d)**0.5</line-5>
<line-6> a=(d+root)/2</line-6>
<line-7> b=(d-root)/2</line-7>
<line-8> anws=True</line-8>
<line-9> if anws:</line-9>
<line-10> print("Y {:.9f} {:.9f}".format(a,b))</line-10>
<line-12> print("N")</line-12>
|
{"code": "<line-2> d=int(input())</line-2>\n<line-11> else:</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>import os</line-1>
<line-3>import sys</line-3>
<line-4>import threading</line-4>
<line-5></line-5>
<line-6></line-6>
<line-7>sys.setrecursionlimit(10 ** 9)</line-7>
<line-8>threading.stack_size(67108864)</line-8>
<line-9></line-9>
<line-10></line-10>
<line-11>def main():</line-11>
<line-12></line-12>
<line-13> # input = BytesIO(os.read(0, os.fstat(0).st_size)).readline</line-13>
<line-14></line-14>
<line-15> def ad(i, j):</line-15>
<line-16> nonlocal g</line-16>
<line-17> if j in g[i]:</line-17>
<line-18> g[i].remove(j)</line-18>
<line-19> g[j].remove(i)</line-19>
<line-20> else:</line-20>
<line-21> g[i].add(j)</line-21>
<line-22> g[j].add(i)</line-22>
<line-23></line-23>
<line-24> def dfs(v):</line-24>
<line-25> nonlocal used, g, nans</line-25>
<line-26> used[v] = True</line-26>
<line-27> nans.append(v + 1)</line-27>
<line-28> for el in g[v]:</line-28>
<line-29> if not used[el]:</line-29>
<line-30> dfs(el)</line-30>
<line-31></line-31>
<line-32> for _ in range(int(input())):</line-32>
<line-33> n = int(input())</line-33>
<line-34> cnt = [set() for i in range(n)]</line-34>
<line-35> g = [set() for i in range(n)]</line-35>
<line-36> used = [False] * n</line-36>
<line-37> triangles = []</line-37>
<line-38> for i in range(n - 2):</line-38>
<line-39> a, b, c = map(int, input().split())</line-39>
<line-40> a -= 1</line-40>
<line-41> b -= 1</line-41>
<line-42> c -= 1</line-42>
<line-43> cnt[a].add(i)</line-43>
<line-44> cnt[b].add(i)</line-44>
<line-45> cnt[c].add(i)</line-45>
<line-46> triangles.append((a, b, c))</line-46>
<line-47> ad(a, b)</line-47>
<line-48> ad(b, c)</line-48>
<line-49> ad(a, c)</line-49>
<line-50> q = []</line-50>
<line-51> ones = []</line-51>
<line-52> for i in range(n):</line-52>
<line-53> if len(cnt[i]) == 1:</line-53>
<line-54> ones.append(i)</line-54>
<line-55> ans = []</line-55>
<line-56> nans = []</line-56>
<line-57> for i in range(n - 2):</line-57>
<line-58> t = ones.pop()</line-58>
<line-59> ind = cnt[t].pop()</line-59>
<line-60> ans.append(ind + 1)</line-60>
<line-61> cnt[triangles[ind][0]].discard(ind)</line-61>
<line-62> cnt[triangles[ind][1]].discard(ind)</line-62>
<line-63> cnt[triangles[ind][2]].discard(ind)</line-63>
<line-64> if len(cnt[triangles[ind][0]]) == 1:</line-64>
<line-65> ones.append(triangles[ind][0])</line-65>
<line-66> if len(cnt[triangles[ind][1]]) == 1:</line-66>
<line-67> ones.append(triangles[ind][1])</line-67>
<line-68> if len(cnt[triangles[ind][2]]) == 1:</line-68>
<line-69> ones.append(triangles[ind][2])</line-69>
<line-70> dfs(0)</line-70>
<line-71> print(*nans)</line-71>
<line-72> print(*ans)</line-72>
<line-73></line-73>
<line-74></line-74>
<line-76>tt.start()</line-76>
|
{"code": "<line-2>from io import BytesIO</line-2>\n<line-75>tt = threading.Thread(target = main)</line-75>", "lines": [2, 75]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> if n < m:</line-3>
<line-4> n, m = m, n # n > m</line-4>
<line-5></line-5>
<line-6> if m == 1:</line-6>
<line-7> print("YES")</line-7>
<line-8> continue</line-8>
<line-9></line-9>
<line-10> if m == 2 and n == 2:</line-10>
<line-11> print("YES")</line-11>
<line-13></line-13>
<line-14> print("NO")</line-14>
|
{"code": "<line-2> n, m = list(map(int, input().split()))</line-2>\n<line-12> continue</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>tests = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> a = [int(i) for i in input().split()]</line-4>
<line-5> d = {}</line-5>
<line-6> for i in range(n):</line-6>
<line-7> s = 0</line-7>
<line-8> while a[i] % 2 == 0:</line-8>
<line-9> a[i] //= 2</line-9>
<line-10> s += 1</line-10>
<line-11> if a[i] in list(d.keys()):</line-11>
<line-12> d[a[i]] = max(s, d[a[i]])</line-12>
<line-13> else:</line-13>
<line-14> d[a[i]] = s</line-14>
<line-15> s = 0</line-15>
<line-16> for i in list(d.keys()):</line-16>
<line-18> print(s)</line-18>
|
{"code": "<line-2>for test in range(tests):</line-2>\n<line-17> s += d[i]</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>import sys</line-1>
<line-3>MOD = 10**9 + 7</line-3>
<line-4>I = lambda:list(map(int,input().split()))</line-4>
<line-5>from math import gcd</line-5>
<line-6>from math import ceil</line-6>
<line-7>from collections import defaultdict as dd, Counter</line-7>
<line-8>from bisect import bisect_left as bl, bisect_right as br</line-8>
<line-9></line-9>
<line-10></line-10>
<line-11>"""</line-11>
<line-12>Facts and Data representation</line-12>
<line-13>Constructive? Top bottom up down</line-13>
<line-14>"""</line-14>
<line-15>def check(s):</line-15>
<line-16> t = 'abacaba'</line-16>
<line-17> ans = 0</line-17>
<line-18> for i in range(len(s)):</line-18>
<line-19> if s[i: i + 7] == t:</line-19>
<line-20> ans += 1</line-20>
<line-21> return ans</line-21>
<line-22></line-22>
<line-23>def solve():</line-23>
<line-24> n, = I()</line-24>
<line-25> s = input()</line-25>
<line-26> t = 'abacaba'</line-26>
<line-27> cnt = check(s)</line-27>
<line-28> if cnt > 1:</line-28>
<line-29> print('No')</line-29>
<line-30> return</line-30>
<line-31> elif cnt == 1:</line-31>
<line-32> s = list(s)</line-32>
<line-33> for i in range(n):</line-33>
<line-34> if s[i] == '?':</line-34>
<line-35> s[i] = 'z'</line-35>
<line-36> print('Yes')</line-36>
<line-37> print(''.join(s))</line-37>
<line-38> else:</line-38>
<line-39> s = list(s)</line-39>
<line-40> ok = s[::]</line-40>
<line-41> for i in range(n - 6):</line-41>
<line-42> ok = s[::]</line-42>
<line-43> for j in range(7):</line-43>
<line-44> if s[i + j] == t[j]:</line-44>
<line-45> continue</line-45>
<line-46> elif s[i + j] == '?':</line-46>
<line-47> ok[i + j] = t[j]</line-47>
<line-48> else:</line-48>
<line-49> break</line-49>
<line-50> else:</line-50>
<line-51> for i in range(n):</line-51>
<line-52> if ok[i] == '?':</line-52>
<line-53> ok[i] = 'z'</line-53>
<line-54> ok = ''.join(ok)</line-54>
<line-55> if check(ok) != 1:</line-55>
<line-56> continue</line-56>
<line-57> print('Yes')</line-57>
<line-58> print(ok)</line-58>
<line-59> return</line-59>
<line-60> print('No')</line-60>
<line-61></line-61>
<line-62>t, = I()</line-62>
<line-63>while t:</line-63>
<line-65> solve()</line-65>
|
{"code": "<line-2>INF = 10**20</line-2>\n<line-64> t -= 1</line-64>", "lines": [2, 64]}
#### 0
|
<line-1>input=__import__('sys').stdin.readline</line-1>
<line-3> n=int(input())</line-3>
<line-4> s=list(map(int,input().split()))</line-4>
<line-5> g=[[-1]for _ in range(n+1)]</line-5>
<line-6> for i in range(n):</line-6>
<line-7> g[s[i]].append(i)</line-7>
<line-8> inf=10**10</line-8>
<line-9> ans=[-1]*n</line-9>
<line-10> lstunused=n</line-10>
<line-11> for i in range(1,n+1):</line-11>
<line-12> g[i].append(n)</line-12>
<line-13> mx=0</line-13>
<line-14> for j in range(1,len(g[i])):</line-14>
<line-15> mx=max(mx,g[i][j]-g[i][j-1]-1)</line-15>
<line-16> for j in range(mx,lstunused):</line-16>
<line-17> ans[j]=i</line-17>
<line-19> print(*ans)</line-19>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-18>\t\tlstunused=min(lstunused,mx)</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> s = input()</line-4>
<line-5> ans = 0</line-5>
<line-6> for y in range(1, n):</line-6>
<line-7> if s[y] == s[y-1]:</line-7>
<line-9> print((ans + ans % 2) // 2)</line-9>
<line-10> </line-10>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-8> ans += 1</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>DIR = {"N": (0, 1), "S": (0, -1), "W": (-1, 0), "E": (1, 0)}</line-1>
<line-2></line-2>
<line-4> path = input()</line-4>
<line-5> tracks = set()</line-5>
<line-6> x, y = 0, 0</line-6>
<line-7> time = 0</line-7>
<line-8> for char in path:</line-8>
<line-9> x1 = x + DIR[char][0]</line-9>
<line-10> y1 = y + DIR[char][1]</line-10>
<line-11> if (x, y, x1, y1) in tracks or (x1, y1, x, y) in tracks:</line-11>
<line-12> time += 1</line-12>
<line-13> else:</line-13>
<line-14> time += 5</line-14>
<line-15> tracks.add((x, y, x1, y1))</line-15>
<line-17> print(time)</line-17>
|
{"code": "<line-3>for t in range(int(input())):</line-3>\n<line-16> x, y = x1, y1</line-16>", "lines": [3, 16]}
#### 0
|
<line-1>from sys import stdin, stdout</line-1>
<line-3>input = stdin.readline</line-3>
<line-4>for _ in range(int(input())):</line-4>
<line-5> n = int(input())</line-5>
<line-6> chanek = 0</line-6>
<line-7> flag = 1</line-7>
<line-8> while n>0:</line-8>
<line-9> if n%4==0 and n!=4:</line-9>
<line-10> if flag:</line-10>
<line-11> chanek += 1</line-11>
<line-12> n-=1</line-12>
<line-13> flag = 0</line-13>
<line-14> else:</line-14>
<line-15> n-=1</line-15>
<line-16> flag = 1</line-16>
<line-17> elif n%2:</line-17>
<line-18> if flag:</line-18>
<line-19> chanek += 1</line-19>
<line-20> n-=1</line-20>
<line-21> flag = 0</line-21>
<line-22> else:</line-22>
<line-23> n-=1</line-23>
<line-24> flag = 1</line-24>
<line-25> else:</line-25>
<line-26> if flag:</line-26>
<line-27> chanek += n//2</line-27>
<line-28> n//=2</line-28>
<line-29> flag = 0</line-29>
<line-30> else:</line-30>
<line-31> n//=2</line-31>
<line-33> print(chanek)</line-33>
|
{"code": "<line-2>from collections import defaultdict</line-2>\n<line-32>\t\t\t\tflag = 1</line-32>", "lines": [2, 32]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n=int(input())</line-3>
<line-4> print(2)</line-4>
<line-5> print(n-1,n)</line-5>
<line-7> print(i,i+2)</line-7>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-6> for i in range(n-2,0,-1):</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> if(n%2):</line-3>
<line-4> print("7"+"1"*((n-3)//2))</line-4>
<line-6> print("1"*(n//2)) </line-6>
|
{"code": "<line-2>\tn = int(input())</line-2>\n<line-5>\telse:</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>for _ in range(int(input())):</line-5>
<line-6> N=int(input())</line-6>
<line-7> e=list(map(int,input().split()))</line-7>
<line-8> e.sort()</line-8>
<line-9> ans=0</line-9>
<line-10> val=0</line-10>
<line-11> g=0</line-11>
<line-12> for i in range(0,N):</line-12>
<line-13> g+=1</line-13>
<line-14> val=e[i]</line-14>
<line-15> if g>=val:</line-15>
<line-16> ans+=1</line-16>
<line-17> g=0</line-17>
<line-19> print(ans)</line-19>
|
{"code": "<line-3>input=sys.stdin.readline</line-3>\n<line-18> val=0</line-18>", "lines": [3, 18]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>k=[]</line-3>
<line-4>for i in range(n):</line-4>
<line-5> for j in range(a[i]):</line-5>
<line-6> k.append(i+1)</line-6>
<line-7>m=int(input())</line-7>
<line-8>b=list(map(int,input().split()))</line-8>
<line-10> print(k[i-1])</line-10>
|
{"code": "<line-2>a=list(map(int,input().split()))</line-2>\n<line-9>for i in b:</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>3</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>N = 55</line-5>
<line-6>c = [1]</line-6>
<line-7>for i in range(N):</line-7>
<line-8> c.append(fact(i))</line-8>
<line-9>dp = [0] * N</line-9>
<line-10>dp[0] = 1</line-10>
<line-11>for i in range(1, N):</line-11>
<line-12> for j in range(i):</line-12>
<line-13> dp[i] += dp[j] * c[i - j - 1]</line-13>
<line-14></line-14>
<line-15>def get_kth_cycle(n, k):</line-15>
<line-16> if n == 1:</line-16>
<line-17> return [1]</line-17>
<line-18> ans = [-1] * n</line-18>
<line-19> ans[0] = n - 1</line-19>
<line-20> fin = [i for i in range(n)]</line-20>
<line-21> fin[0] = n - 1</line-21>
<line-22> init = [i for i in range(n)]</line-22>
<line-23> init[n - 1] = 0</line-23>
<line-24> used = [False] * n</line-24>
<line-25> used[n - 1] = True</line-25>
<line-26> for i in range(1, n - 1):</line-26>
<line-27> j = 0</line-27>
<line-28> cur = fact(n - i - 2)</line-28>
<line-29> while True:</line-29>
<line-30> while used[j] or (i < n - 1 and j == init[i]):</line-30>
<line-31> j += 1</line-31>
<line-32> if k > cur:</line-32>
<line-33> k -= cur</line-33>
<line-34> j += 1</line-34>
<line-35> else:</line-35>
<line-36> fin[init[i]] = fin[j]</line-36>
<line-37> init[fin[j]] = init[i]</line-37>
<line-38> ans[i] = j</line-38>
<line-39> used[j] = True</line-39>
<line-40> break</line-40>
<line-41> ans[-1] = init[-1]</line-41>
<line-42> return [x + 1 for x in ans]</line-42>
<line-43></line-43>
<line-44>def f(n, k):</line-44>
<line-45> if n == 0:</line-45>
<line-46> assert k == 1</line-46>
<line-47> return []</line-47>
<line-48> cl = 1</line-48>
<line-49> while c[cl - 1] * dp[n - cl] < k:</line-49>
<line-50> k -= c[cl - 1] * dp[n - cl]</line-50>
<line-51> cl += 1</line-51>
<line-52> rest = f(n - cl, (k - 1) % dp[n - cl] + 1)</line-52>
<line-53> rest = [x + cl for x in rest]</line-53>
<line-54> k = (k - 1) // dp[n - cl] + 1</line-54>
<line-55> return get_kth_cycle(cl, k) + rest</line-55>
<line-56></line-56>
<line-57>def solve():</line-57>
<line-58> n, k = list(map(int, input().split()))</line-58>
<line-59> if k > dp[n]:</line-59>
<line-60> print(-1)</line-60>
<line-61> return</line-61>
<line-62> print(*f(n, k))</line-62>
<line-63></line-63>
<line-64>def main():</line-64>
<line-65> t = int(input())</line-65>
<line-66> while t > 0:</line-66>
<line-67> t -= 1</line-67>
<line-69></line-69>
<line-70>main()</line-70>
|
{"code": "<line-3>from math import factorial as fact</line-3>\n<line-68>\t\tsolve()</line-68>", "lines": [3, 68]}
#### 0
|
<line-1>q = int(input())</line-1>
<line-3> n, k1, k2 = map(int, input().split())</line-3>
<line-4> arr1 = list(map(int, input().split()))</line-4>
<line-5> arr2 = list(map(int, input().split()))</line-5>
<line-6> if max(arr1) > max(arr2):</line-6>
<line-7> print('YES')</line-7>
<line-9> print('NO')</line-9>
|
{"code": "<line-2>for z in range(q):</line-2>\n<line-8> else:</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-2></line-2>
<line-4> a,b,p=map(int,input().split())</line-4>
<line-5> s=input()</line-5>
<line-6> n=len(s)</line-6>
<line-7> cost = [0]*n</line-7>
<line-8> cost[-1] = 0</line-8>
<line-9> typ = ''</line-9>
<line-10> i=n-2</line-10>
<line-11> while i>=0:</line-11>
<line-12> if s[i]==typ:</line-12>
<line-13> cost[i] = cost[i+1]</line-13>
<line-14> else:</line-14>
<line-15> typ = s[i]</line-15>
<line-16> cost[i] = cost[i+1] + (a if typ=='A' else b)</line-16>
<line-17> i-=1</line-17>
<line-18> i=0</line-18>
<line-19> while cost[i] > p:</line-19>
<line-21> print(i+1)</line-21>
|
{"code": "<line-3>for tt in range(t):</line-3>\n<line-20> i+=1</line-20>", "lines": [3, 20]}
#### 0
|
<line-1>def main():</line-1>
<line-3> for _ in range(int(stdin.readline())):</line-3>
<line-4> n = int(stdin.readline())</line-4>
<line-5> inp1 = [-1] * (n + 1)</line-5>
<line-6> inp2 = [-1] * (n + 1)</line-6>
<line-7> for i, ai in enumerate(map(int, stdin.readline().split())):</line-7>
<line-8> if inp1[ai] < 0:</line-8>
<line-9> inp1[ai] = i</line-9>
<line-10> inp2[ai] = i</line-10>
<line-11> inp1 = tuple((inp1i for inp1i in inp1 if inp1i >= 0))</line-11>
<line-12> inp2 = tuple((inp2i for inp2i in inp2 if inp2i >= 0))</line-12>
<line-13> n = len(inp1)</line-13>
<line-14> ans = 0</line-14>
<line-15> cur = 0</line-15>
<line-16> for i in range(n):</line-16>
<line-17> if i and inp1[i] < inp2[i - 1]:</line-17>
<line-18> cur = 1</line-18>
<line-19> else:</line-19>
<line-20> cur += 1</line-20>
<line-21> ans = max(ans, cur)</line-21>
<line-23></line-23>
<line-24></line-24>
<line-25>main()</line-25>
|
{"code": "<line-2> from sys import stdin, stdout</line-2>\n<line-22> stdout.write(f'{n - ans}\\n')</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> n,k=list(map(int,input().split()))</line-3>
<line-4> s = input()</line-4>
<line-5> ans = []</line-5>
<line-6> if s[0] == ')':</line-6>
<line-7> for i in range(n):</line-7>
<line-8> if s[i] == '(':</line-8>
<line-9> ans.append([1,i+1])</line-9>
<line-10> s = s[i::-1] + s[i+1:]</line-10>
<line-11> break</line-11>
<line-12> for i in range(1,(k-1)*2):</line-12>
<line-13> if i%2==0:</line-13>
<line-14> if s[i]!='(':</line-14>
<line-15> for j in range(i+1,n):</line-15>
<line-16> if s[j] == '(':</line-16>
<line-17> ans.append([i+1,j+1])</line-17>
<line-18> s = s[:i] + s[j:i-1:-1] + s[j+1:]</line-18>
<line-19> break</line-19>
<line-20> else:</line-20>
<line-21> if s[i]!=')':</line-21>
<line-22> for j in range(i+1,n):</line-22>
<line-23> if s[j] == ')':</line-23>
<line-24> ans.append([i+1,j+1])</line-24>
<line-25> s = s[:i] + s[j:i-1:-1] + s[j+1:]</line-25>
<line-26> break</line-26>
<line-27> for i in range((k-1)*2,(n+(2*(k-1)))//2+1):</line-27>
<line-28> if s[i]!='(':</line-28>
<line-29> for j in range(i+1,n):</line-29>
<line-30> if s[j] == '(':</line-30>
<line-31> ans.append([i+1,j+1])</line-31>
<line-32> s = s[:i] + s[j:i-1:-1] + s[j+1:]</line-32>
<line-33> break</line-33>
<line-34> print(len(ans))</line-34>
<line-36> print(*i)</line-36>
<line-37> </line-37>
<line-38></line-38>
<line-39></line-39>
<line-40></line-40>
|
{"code": "<line-2>for tt in range(t):</line-2>\n<line-35> for i in ans:</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>LOG = 20</line-1>
<line-2></line-2>
<line-4> n = len(s)</line-4>
<line-5> res = 0</line-5>
<line-6> z = 0</line-6>
<line-7> for t in range(0, n):</line-7>
<line-8> if s[t] == '0':</line-8>
<line-9> z += 1</line-9>
<line-10> continue</line-10>
<line-11> for l in range(1, min(LOG, n - t + 1)):</line-11>
<line-12> x = int(s[t:t+l], 2)</line-12>
<line-13> # print(l, t, x, l + z)</line-13>
<line-14> if l + z >= x:</line-14>
<line-15> res += 1</line-15>
<line-16></line-16>
<line-17># print(t, l, x, res, z)</line-17>
<line-18> z = 0</line-18>
<line-19> return res</line-19>
<line-20></line-20>
<line-21></line-21>
<line-22>t = int(input())</line-22>
<line-23>while t > 0:</line-23>
<line-24> t -= 1</line-24>
<line-26> print(solve(s))</line-26>
|
{"code": "<line-3>def solve(s):</line-3>\n<line-25>\ts = input()</line-25>", "lines": [3, 25]}
#### 0
|
<line-1>def check(M):</line-1>
<line-3> for i in range(n):</line-3>
<line-4> if a[i] > M:</line-4>
<line-5> sm += b[i]</line-5>
<line-6> return sm <= M</line-6>
<line-7></line-7>
<line-8></line-8>
<line-9>gans = []</line-9>
<line-10>for _ in range(int(input())):</line-10>
<line-11> n = int(input())</line-11>
<line-12> a = list(map(int, input().split()))</line-12>
<line-13> b = list(map(int, input().split()))</line-13>
<line-14> L = 0</line-14>
<line-15> R = max(a)</line-15>
<line-16> while R - L > 1:</line-16>
<line-17> M = (L + R) // 2</line-17>
<line-18> if check(M):</line-18>
<line-19> R = M</line-19>
<line-20> else:</line-20>
<line-21> L = M</line-21>
<line-23>print(*gans, sep='\n')</line-23>
|
{"code": "<line-2> sm = 0</line-2>\n<line-22> gans.append(R)</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n=int(input())</line-3>
<line-4> for i in range(n):</line-4>
<line-6> print()</line-6>
|
{"code": "<line-2>for you in range(t):</line-2>\n<line-5> print(4*n-2*i,end=\" \")</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from fractions import Fraction</line-3>
<line-4>from math import *</line-4>
<line-5> </line-5>
<line-6>def input():</line-6>
<line-7> return sys.stdin.readline().strip()</line-7>
<line-8> </line-8>
<line-9>def iinput():</line-9>
<line-10> return int(input())</line-10>
<line-11></line-11>
<line-12>def finput():</line-12>
<line-13> return float(input())</line-13>
<line-14></line-14>
<line-15>def tinput():</line-15>
<line-16> return input().split()</line-16>
<line-17></line-17>
<line-18>def linput():</line-18>
<line-19> return list(input())</line-19>
<line-20> </line-20>
<line-21>def rinput():</line-21>
<line-22> return list(map(int, tinput()))</line-22>
<line-23></line-23>
<line-24>def fiinput():</line-24>
<line-25> return list(map(float, tinput()))</line-25>
<line-26> </line-26>
<line-27>def rlinput():</line-27>
<line-28> return list(map(int, input().split()))</line-28>
<line-29>def trinput():</line-29>
<line-30> return tuple(rinput())</line-30>
<line-31></line-31>
<line-32>def srlinput():</line-32>
<line-33> return sorted(list(map(int, input().split())))</line-33>
<line-34></line-34>
<line-35>def NOYES(fl):</line-35>
<line-36> if fl:</line-36>
<line-37> print("NO")</line-37>
<line-38> else:</line-38>
<line-39> print("YES")</line-39>
<line-40>def YESNO(fl):</line-40>
<line-41> if fl:</line-41>
<line-42> print("YES")</line-42>
<line-43> else:</line-43>
<line-44> print("NO")</line-44>
<line-45> </line-45>
<line-46>def main():</line-46>
<line-47> n = iinput()</line-47>
<line-48> #k = iinput() </line-48>
<line-49> #m = iinput() </line-49>
<line-50> #n = int(sys.stdin.readline().strip()) </line-50>
<line-51> #n, k = rinput()</line-51>
<line-52> #n, m = rinput()</line-52>
<line-53> #m, k = rinput()</line-53>
<line-54> #n, k, m = rinput()</line-54>
<line-55> #n, m, k = rinput()</line-55>
<line-56> #k, n, m = rinput()</line-56>
<line-57> #k, m, n = rinput() </line-57>
<line-58> #m, k, n = rinput()</line-58>
<line-59> #m, n, k = rinput()</line-59>
<line-60> #q = srlinput()</line-60>
<line-61> #q = linput()</line-61>
<line-62> s, t, res = 1, 1, 0</line-62>
<line-63> while s <= n:</line-63>
<line-64> res += 1</line-64>
<line-65> n -= s</line-65>
<line-66> t = 2 * t + 1</line-66>
<line-67> s = (t * (t + 1)) // 2</line-67>
<line-68> print(res)</line-68>
<line-69> </line-69>
<line-70> </line-70>
<line-71> </line-71>
<line-72> </line-72>
<line-73> </line-73>
<line-74> </line-74>
<line-75> </line-75>
<line-76> </line-76>
<line-77> </line-77>
<line-78> </line-78>
<line-79></line-79>
<line-81> main()</line-81>
|
{"code": "<line-2>import random</line-2>\n<line-80>for i in range(iinput()):</line-80>", "lines": [2, 80]}
#### 0
|
<line-1>#</line-1>
<line-3># ____ _ Generatered using</line-3>
<line-4># / ___| | |</line-4>
<line-5># | | __ _ __| | ___ _ __ ______ _</line-5>
<line-6># | | / _` |/ _` |/ _ \ '_ \|_ / _` |</line-6>
<line-7># | |__| (_| | (_| | __/ | | |/ / (_| |</line-7>
<line-8># \____\____|\____|\___|_| |_/___\____|</line-8>
<line-9>#</line-9>
<line-10># GNU Affero General Public License v3.0</line-10>
<line-11># ------------------------------------------------</line-11>
<line-12># Author : prophet</line-12>
<line-13># Created : 2020-07-12 11:19:01.523119</line-13>
<line-14># UUID : aXsU7xuXyjk3Ky2f</line-14>
<line-15># ------------------------------------------------</line-15>
<line-16>#</line-16>
<line-17>production = True</line-17>
<line-18></line-18>
<line-19>import sys, math, collections</line-19>
<line-20></line-20>
<line-21>def input(input_format = 0, multi = 0):</line-21>
<line-22></line-22>
<line-23> if multi > 0: return [input(input_format) for i in range(multi)]</line-23>
<line-24> else:</line-24>
<line-25> next_line = sys.stdin.readline()[:-1]</line-25>
<line-26></line-26>
<line-27> if input_format >= 10:</line-27>
<line-28> use_list = False</line-28>
<line-29> input_format = int(str(input_format)[-1])</line-29>
<line-30> else: use_list = True</line-30>
<line-31></line-31>
<line-32> if input_format == 0: formatted_input = [next_line]</line-32>
<line-33> elif input_format == 1: formatted_input = list(map(int, next_line.split()))</line-33>
<line-34> elif input_format == 2: formatted_input = list(map(float, next_line.split()))</line-34>
<line-35> elif input_format == 3: formatted_input = list(next_line)</line-35>
<line-36> elif input_format == 4: formatted_input = list(map(int, list(next_line)))</line-36>
<line-37> elif input_format == 5: formatted_input = next_line.split()</line-37>
<line-38> else: formatted_input = [next_line]</line-38>
<line-39></line-39>
<line-40> return formatted_input if use_list else formatted_input[0]</line-40>
<line-41></line-41>
<line-42>def out(output_line, output_format = 0, newline = True):</line-42>
<line-43></line-43>
<line-44> formatted_output = ""</line-44>
<line-45></line-45>
<line-46> if output_format == 0: formatted_output = str(output_line)</line-46>
<line-47> elif output_format == 1: formatted_output = " ".join(map(str, output_line))</line-47>
<line-48> elif output_format == 2: formatted_output = "\n".join(map(str, output_line))</line-48>
<line-49></line-49>
<line-50> print(formatted_output, end = "\n" if newline else "")</line-50>
<line-51></line-51>
<line-52>def log(*args):</line-52>
<line-53> if not production:</line-53>
<line-54> print("$$$", end = "")</line-54>
<line-55> print(*args)</line-55>
<line-56></line-56>
<line-57>enu = enumerate</line-57>
<line-58></line-58>
<line-59>ter = lambda a, b, c: b if a else c</line-59>
<line-60></line-60>
<line-61>ceil = lambda a, b: -(-a // b)</line-61>
<line-62></line-62>
<line-63>def mapl(iterable, format = 0):</line-63>
<line-64> </line-64>
<line-65> if format == 0: return list(map(int, iterable))</line-65>
<line-66> elif format == 1: return list(map(str, iterable))</line-66>
<line-67> elif format == 2: return list(map(list, iterable))</line-67>
<line-68>#</line-68>
<line-69># >>>>>>>>>>>>>>> START OF SOLUTION <<<<<<<<<<<<<<</line-69>
<line-70>#</line-70>
<line-71></line-71>
<line-72></line-72>
<line-73>def solve():</line-73>
<line-74></line-74>
<line-75> s = input(3)</line-75>
<line-76></line-76>
<line-77> u = [0] * 3</line-77>
<line-78></line-78>
<line-79> for i in s:</line-79>
<line-80> if i == "R":</line-80>
<line-81> u[0] += 1</line-81>
<line-82> elif i == "P":</line-82>
<line-83> u[1] += 1</line-83>
<line-84> elif i == "S":</line-84>
<line-85> u[2] += 1</line-85>
<line-86></line-86>
<line-87> log(u)</line-87>
<line-88> y = 0</line-88>
<line-89> p = 0</line-89>
<line-90></line-90>
<line-91> for i, j in enu(u):</line-91>
<line-92> if j > y:</line-92>
<line-93> y = j</line-93>
<line-94> p = i</line-94>
<line-95></line-95>
<line-96> if p == 0:</line-96>
<line-97> a = "P"</line-97>
<line-98> elif p == 1:</line-98>
<line-99> a = "S"</line-99>
<line-100> elif p == 2:</line-100>
<line-101> a = "R"</line-101>
<line-102></line-102>
<line-103> out(a * len(s))</line-103>
<line-104></line-104>
<line-105> return</line-105>
<line-106></line-106>
<line-107></line-107>
<line-108>for i in range(input(11)): solve()</line-108>
<line-109># solve()</line-109>
<line-110></line-110>
<line-111>#</line-111>
<line-113>#</line-113>
|
{"code": "<line-2># ------------------------------------------------</line-2>\n<line-112># >>>>>>>>>>>>>>>> END OF SOLUTION <<<<<<<<<<<<<<<</line-112>", "lines": [2, 112]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from bisect import bisect_right</line-3>
<line-4></line-4>
<line-5>bin_s = [1]</line-5>
<line-6>while bin_s[-1] <= 10 ** 9:</line-6>
<line-7> bin_s.append(bin_s[-1] * 2)</line-7>
<line-8></line-8>
<line-9></line-9>
<line-10>def main():</line-10>
<line-11> n, q = map(int, input().split())</line-11>
<line-12> alst = list(map(int, input().split()))</line-12>
<line-13> dp = [[-1, -1] for _ in range(n)]</line-13>
<line-14> dp[0] = [alst[0], 0]</line-14>
<line-15> for i, a in enumerate(alst[1:], start = 1):</line-15>
<line-16> dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + a)</line-16>
<line-17> dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - a)</line-17>
<line-18> print(max(dp[-1]))</line-18>
<line-19> </line-19>
<line-20></line-20>
<line-22> main()</line-22>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-21>for _ in range(int(input())):</line-21>", "lines": [2, 21]}
#### 0
|
<line-2> x,y,k = list(map(int,input().split()))</line-2>
<line-3> print(k + (y * k + k - 1 +x-2) // (x - 1))</line-3>
|
{"code": "<line-1>for haaghfj in range(int(input())):</line-1>", "lines": [1]}
#### 0
|
<line-1></line-1>
<line-2>import sys</line-2>
<line-4>input=sys.stdin.readline</line-4>
<line-5></line-5>
<line-6># this math tutorial is boring</line-6>
<line-7></line-7>
<line-8>classy=set()</line-8>
<line-9></line-9>
<line-10>for i in range(19):</line-10>
<line-11> for j in range(i):</line-11>
<line-12> for k in range(j):</line-12>
<line-13> for a in range(10): # a=0 for good measure</line-13>
<line-14> for b in range(10):</line-14>
<line-15> for c in range(10):</line-15>
<line-16> what=a*10**i+b*10**j+c*10**k</line-16>
<line-17> classy.add(what)</line-17>
<line-18></line-18>
<line-19>li=sorted(classy)</line-19>
<line-20></line-20>
<line-21>def counting(i):</line-21>
<line-22> # return len([x for x in li if x <= i])+C</line-22>
<line-23> lo=0</line-23>
<line-24> hi=len(li)-1</line-24>
<line-25> while lo<hi:</line-25>
<line-26> mid=(lo+hi+1)//2</line-26>
<line-27> if li[mid]<=i:</line-27>
<line-28> lo=mid</line-28>
<line-29> else:</line-29>
<line-30> hi=mid-1</line-30>
<line-31> return lo</line-31>
<line-32></line-32>
<line-33>for _ in range(int(input())):</line-33>
<line-35> print(counting(b)-counting(a-1))</line-35>
|
{"code": "<line-3>#sys.stdin=open(\"data.txt\")</line-3>\n<line-34> a,b=map(int,input().split())</line-34>", "lines": [3, 34]}
#### 0
|
<line-1>for tcase in range(int(input())):</line-1>
<line-3> ls = list(map(int, input().split()))</line-3>
<line-4> oneneed = 2*(n - ls.count(1))</line-4>
<line-5> ldct = {0:0}</line-5>
<line-6> ctr = 0</line-6>
<line-7> eaten = 0</line-7>
<line-8> for i in range(n-1,-1,-1):</line-8>
<line-9> eaten += 1</line-9>
<line-10> ctr += (1 if ls[i] == 2 else -1)</line-10>
<line-11> if ctr not in ldct:</line-11>
<line-12> ldct[ctr] = eaten</line-12>
<line-13></line-13>
<line-14> rdct = {0:0}</line-14>
<line-15> ctr = 0</line-15>
<line-16> eaten = 0</line-16>
<line-17> for i in range(n,2*n):</line-17>
<line-18> eaten += 1</line-18>
<line-19> ctr += (1 if ls[i] == 2 else -1)</line-19>
<line-20> if ctr not in rdct:</line-20>
<line-21> rdct[ctr] = eaten</line-21>
<line-22> #print(oneneed, ldct, rdct)</line-22>
<line-23></line-23>
<line-24> best=99**99</line-24>
<line-25> for k in list(rdct.keys()):</line-25>
<line-26> otk = oneneed - k</line-26>
<line-27> if otk in ldct:</line-27>
<line-29> print(best)</line-29>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-28> best = min(best, rdct[k]+ldct[otk])</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>def main():</line-1>
<line-3> for z in range(t):</line-3>
<line-4> n, k, d1, d2 = map(int, input().split())</line-4>
<line-5> if n % 3 != 0:</line-5>
<line-6> print('no')</line-6>
<line-7> continue</line-7>
<line-8> f = 0</line-8>
<line-9> for i in [-1, +1]:</line-9>
<line-10> for j in [-1, +1]:</line-10>
<line-11> w = (k - i * d1 - j * d2)</line-11>
<line-12> if f == 0 and (w % 3 == 0) and (n//3)>=(w//3)>=0 and (n//3)>=(w//3 + i * d1)>=0 and (n//3)>=(w//3 + j * d2)>=0:</line-12>
<line-13> print('yes')</line-13>
<line-14> f = 1</line-14>
<line-15> if f == 0:</line-15>
<line-17>main()</line-17>
|
{"code": "<line-2> t = int(input())</line-2>\n<line-16> print('no')</line-16>", "lines": [2, 16]}
#### 0
|
<line-2>a=sorted(int(input()) for _ in range(n))</line-2>
<line-3>print(sum(a[i]*a[-i-1] for i in range(n))%10007)</line-3>
|
{"code": "<line-1>n=int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>def compress(array):</line-5>
<line-6> array2 = sorted(set(array))</line-6>
<line-7> memo = {value : index for index, value in enumerate(array2)}</line-7>
<line-8> for i in range(len(array)):</line-8>
<line-9> array[i] = memo[array[i]] + 1</line-9>
<line-10> return array</line-10>
<line-11></line-11>
<line-12></line-12>
<line-13>t = int(input())</line-13>
<line-14>base = 10 ** 6</line-14>
<line-15>for _ in range(t):</line-15>
<line-16> n, b = list(map(str, input().split()))</line-16>
<line-17> n = int(n)</line-17>
<line-18> ans = [0] * n</line-18>
<line-19> </line-19>
<line-20> now = base</line-20>
<line-21> ans[0] = base</line-21>
<line-22> for i in range(n - 1):</line-22>
<line-23> if b[i] == ">":</line-23>
<line-24> now -= base</line-24>
<line-25> ans[i + 1] = now</line-25>
<line-26> else:</line-26>
<line-27> now += 1</line-27>
<line-28> ans[i + 1] = now</line-28>
<line-29> print(*compress(ans))</line-29>
<line-30></line-30>
<line-31> now = base</line-31>
<line-32> ans[0] = base</line-32>
<line-33> for i in range(n - 1):</line-33>
<line-34> if b[i] == ">":</line-34>
<line-35> now -= 1</line-35>
<line-36> ans[i + 1] = now</line-36>
<line-37> else:</line-37>
<line-38> now += base</line-38>
<line-40> print(*compress(ans))</line-40>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-39> ans[i + 1] = now</line-39>", "lines": [2, 39]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> s=list(map(int,input().split()))</line-3>
<line-4> a=0</line-4>
<line-5> for i in s:</line-5>
<line-6> if i<2049:a+=i</line-6>
<line-8> else:print("YES")</line-8>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-7> if a<2048:print(\"NO\")</line-7>", "lines": [2, 7]}
#### 0
|
<line-2> n = int(input())</line-2>
<line-3> print((n + 1) // 2)</line-3>
|
{"code": "<line-1>for __ in range(int(input())):</line-1>", "lines": [1]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> mat = [[0] * n for _ in range(n)]</line-3>
<line-4> for i in range(n):</line-4>
<line-5> b = False</line-5>
<line-6> for j in range(n):</line-6>
<line-7> if i*n+j == k:</line-7>
<line-8> b = True</line-8>
<line-9> break</line-9>
<line-10> mat[(i+j)%n][j] = 1</line-10>
<line-11> if b:</line-11>
<line-12> break</line-12>
<line-13> if k%n == 0:</line-13>
<line-14> print(0)</line-14>
<line-15> else:</line-15>
<line-16> print(2)</line-16>
<line-17> for i in range(n):</line-17>
<line-18> for j in range(n):</line-18>
<line-20> print()</line-20>
|
{"code": "<line-2> n, k = map(int, input().split())</line-2>\n<line-19> print(mat[i][j], end=\"\")</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> arr = list(map(int, input().split()))</line-4>
<line-5> if arr[-1] > arr[0]:</line-5>
<line-6> print("YES")</line-6>
<line-8> print("NO")</line-8>
|
{"code": "<line-2>for case in range(t):</line-2>\n<line-7> else:</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>mem = [[[0 for i in range(51)] for j in range(31)] for k in range(31)]</line-1>
<line-2></line-2>
<line-3></line-3>
<line-5> if mem[n][m][k]:</line-5>
<line-6> return mem[n][m][k]</line-6>
<line-7> if (n*m == k) or (k == 0):</line-7>
<line-8> return 0</line-8>
<line-9> cost = 10**9</line-9>
<line-10> for x in range(1, n//2 + 1):</line-10>
<line-11> for z in range(k+1):</line-11>
<line-12> cost = min(cost, m*m + f(n-x, m, k-z) + f(x, m, z))</line-12>
<line-13> for y in range(1, m//2 + 1):</line-13>
<line-14> for z in range(k+1):</line-14>
<line-15> cost = min(cost, n*n + f(n, m-y, k-z) + f(n, y, z))</line-15>
<line-16> mem[n][m][k] = cost</line-16>
<line-17> return cost</line-17>
<line-18></line-18>
<line-19></line-19>
<line-20>t = int(input())</line-20>
<line-21>for i in range(t):</line-21>
<line-23> print(f(n, m, k))</line-23>
<line-24></line-24>
|
{"code": "<line-4>def f(n, m, k):</line-4>\n<line-22> n, m, k = list(map(int, input().split()))</line-22>", "lines": [4, 22]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> a=list(map(int,input().split()))</line-3>
<line-4> ans,small,big=0,2*10**9,-1</line-4>
<line-5> for i in range(len(a)-1):</line-5>
<line-6> if a[i]==-1 and a[i+1]!=-1:</line-6>
<line-7> small=min(small, a[i+1])</line-7>
<line-8> big=max(big, a[i+1])</line-8>
<line-9> if a[i]!=-1 and a[i+1]==-1:</line-9>
<line-10> small = min(small, a[i])</line-10>
<line-11> big = max(big, a[i])</line-11>
<line-12> if a[i]!=-1 and a[i+1]!=-1:</line-12>
<line-13> ans=max(ans, abs(a[i]-a[i+1]))</line-13>
<line-14> if big==-1:print(ans, 0)</line-14>
<line-15> else:</line-15>
<line-16> x=(small+big)//2</line-16>
<line-17> ans=max(ans, abs(big-x))</line-17>
<line-19> print(ans, x)</line-19>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-18> ans=max(ans, abs(x-small))</line-18>", "lines": [2, 18]}
#### 0
|
<line-2>for _ in range(n):</line-2>
<line-3> a, b = list(map(int, input().split()))</line-3>
<line-4> print(a ^ b)</line-4>
|
{"code": "<line-1>n = int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>import sys</line-1>
<line-3>#from queue import *</line-3>
<line-4>import random</line-4>
<line-5>#sys.setrecursionlimit(int(1e6))</line-5>
<line-6>input = sys.stdin.readline</line-6>
<line-7> </line-7>
<line-8>############ ---- USER DEFINED INPUT FUNCTIONS ---- ############</line-8>
<line-9>def inp():</line-9>
<line-10> return(int(input()))</line-10>
<line-11>def inara():</line-11>
<line-12> return(list(map(int,input().split())))</line-12>
<line-13>def insr():</line-13>
<line-14> s = input()</line-14>
<line-15> return(list(s[:len(s) - 1]))</line-15>
<line-16>def invr():</line-16>
<line-17> return(list(map(int,input().split())))</line-17>
<line-18>################################################################</line-18>
<line-19>############ ---- THE ACTUAL CODE STARTS BELOW ---- ############</line-19>
<line-20></line-20>
<line-21>t=inp()</line-21>
<line-22></line-22>
<line-23>for _ in range(t):</line-23>
<line-24> n=inp()</line-24>
<line-25> ara=inara()</line-25>
<line-26> </line-26>
<line-27> ans=[]</line-27>
<line-28> </line-28>
<line-29> for i in range(1,n-1):</line-29>
<line-30> if ara[i]>ara[i-1] and ara[i]>ara[i+1]:</line-30>
<line-31> ans.append(i)</line-31>
<line-32> ans.append(i+1)</line-32>
<line-33> ans.append(i+2)</line-33>
<line-34> break</line-34>
<line-35> </line-35>
<line-36> if len(ans)==0:</line-36>
<line-37> print("NO")</line-37>
<line-38> else:</line-38>
<line-40> print(*ans)</line-40>
<line-41> </line-41>
<line-42> </line-42>
<line-43> </line-43>
|
{"code": "<line-2>import math</line-2>\n<line-39>\t\tprint(\"YES\")</line-39>", "lines": [2, 39]}
#### 0
|
<line-1>T = int(input())</line-1>
<line-2></line-2>
<line-3></line-3>
<line-4></line-4>
<line-6> res = [S[0]]</line-6>
<line-7> pos = 0 # think...</line-7>
<line-8> for s in S[1:]:</line-8>
<line-9> # can we change?</line-9>
<line-10> if 0 <= pos-1 < len(res) and res[pos-1] == s:</line-10>
<line-11> pos = pos-1</line-11>
<line-12> elif 0 <= pos+1 < len(res) and res[pos+1] == s:</line-12>
<line-13> pos = pos+1</line-13>
<line-14> elif pos == 0 and s not in res:</line-14>
<line-15> res.insert(0, s) # pos is still 0</line-15>
<line-16> elif pos == len(res)-1 and s not in res:</line-16>
<line-17> res.append(s)</line-17>
<line-18> pos += 1</line-18>
<line-19> else: return None</line-19>
<line-20> #print(''.join(res))</line-20>
<line-21> for x in range(ord('a'), ord('z')+1):</line-21>
<line-22> x = chr(x)</line-22>
<line-23> if x not in res:</line-23>
<line-24> res.append(x)</line-24>
<line-25> return ''.join(res)</line-25>
<line-26></line-26>
<line-27>for _ in range(T):</line-27>
<line-28> res = solve(input())</line-28>
<line-29> if res is None:</line-29>
<line-30> print('NO')</line-30>
<line-31> else:</line-31>
<line-33> print(res)</line-33>
|
{"code": "<line-5>def solve(S):</line-5>\n<line-32> print('YES')</line-32>", "lines": [5, 32]}
#### 0
|
<line-1>def solve():</line-1>
<line-3> lst1 = list(map(int,input().split()))</line-3>
<line-4> lst1.sort(reverse=True)</line-4>
<line-5> ind = 0</line-5>
<line-6> ans = 0</line-6>
<line-7> lst2 = list(map(int,input().split()))</line-7>
<line-8> lst2.sort()</line-8>
<line-9> for i in range(k):</line-9>
<line-10> lst2[i] -= 1</line-10>
<line-11> if lst2[i] == 0: ans += lst1[ind]</line-11>
<line-12> ans += lst1[ind]</line-12>
<line-13> ind += 1</line-13>
<line-14> lst2.sort()</line-14>
<line-15> for i in lst2:</line-15>
<line-16> if i != 0:</line-16>
<line-17> ind += i - 1</line-17>
<line-18> ans += lst1[ind]</line-18>
<line-19> ind += 1</line-19>
<line-20> print(ans)</line-20>
<line-22> solve()</line-22>
|
{"code": "<line-2> n, k = map(int,input().split())</line-2>\n<line-21>for i in range(int(input())):</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from fractions import Fraction</line-3>
<line-4>from math import *</line-4>
<line-5> </line-5>
<line-6>def input():</line-6>
<line-7> return sys.stdin.readline().strip()</line-7>
<line-8> </line-8>
<line-9>def iinput():</line-9>
<line-10> return int(input())</line-10>
<line-11></line-11>
<line-12>def finput():</line-12>
<line-13> return float(input())</line-13>
<line-14></line-14>
<line-15>def tinput():</line-15>
<line-16> return input().split()</line-16>
<line-17></line-17>
<line-18>def linput():</line-18>
<line-19> return list(input())</line-19>
<line-20> </line-20>
<line-21>def rinput():</line-21>
<line-22> return list(map(int, tinput()))</line-22>
<line-23></line-23>
<line-24>def fiinput():</line-24>
<line-25> return list(map(float, tinput()))</line-25>
<line-26> </line-26>
<line-27>def rlinput():</line-27>
<line-28> return list(map(int, input().split()))</line-28>
<line-29>def trinput():</line-29>
<line-30> return tuple(rinput())</line-30>
<line-31></line-31>
<line-32>def srlinput():</line-32>
<line-33> return sorted(list(map(int, input().split())))</line-33>
<line-34></line-34>
<line-35>def NOYES(fl):</line-35>
<line-36> if fl:</line-36>
<line-37> print("NO")</line-37>
<line-38> else:</line-38>
<line-39> print("YES")</line-39>
<line-40>def YESNO(fl):</line-40>
<line-41> if fl:</line-41>
<line-42> print("YES")</line-42>
<line-43> else:</line-43>
<line-44> print("NO")</line-44>
<line-45> </line-45>
<line-46>def main():</line-46>
<line-47> n, l = rinput()</line-47>
<line-48> #n = iinput()</line-48>
<line-49> #k = iinput() </line-49>
<line-50> #m = iinput() </line-50>
<line-51> #n = int(sys.stdin.readline().strip()) </line-51>
<line-52> #n, k = rinput()</line-52>
<line-53> #n, m = rinput()</line-53>
<line-54> #m, k = rinput()</line-54>
<line-55> #n, k, m = rinput()</line-55>
<line-56> #n, m, k = rinput()</line-56>
<line-57> #k, n, m = rinput()</line-57>
<line-58> #k, m, n = rinput() </line-58>
<line-59> #m, k, n = rinput()</line-59>
<line-60> #m, n, k = rinput()</line-60>
<line-61> q = rlinput()</line-61>
<line-62> #q = linput()</line-62>
<line-63> q = [0] + q + [l]</line-63>
<line-64> w, e = [0] * (n + 2), [0] * (n + 2)</line-64>
<line-65> </line-65>
<line-66> for i in range(1, n + 2):</line-66>
<line-67> e[n + 1 - i] = e[n + 2 - i] + ((q[-i] - q[-1 - i]) / i)</line-67>
<line-68> w[i] = w[i - 1] + ((q[i] - q[i - 1]) / i)</line-68>
<line-69> </line-69>
<line-70> left, right = 0, n + 2</line-70>
<line-71> while right > left + 1:</line-71>
<line-72> mid = (right + left) // 2</line-72>
<line-73> if w[mid] >= e[mid]:</line-73>
<line-74> right = mid</line-74>
<line-75> else:</line-75>
<line-76> left = mid</line-76>
<line-77> </line-77>
<line-78> print((q[right] - q[right - 1] - (max(0, w[right - 1] - e[right]) * (n - right + 2) + max(0, e[right] - w[right - 1]) * right)) / (n + 2) + max(w[right - 1], e[right]))</line-78>
<line-79> </line-79>
<line-80></line-80>
<line-81> </line-81>
<line-82> </line-82>
<line-83> </line-83>
<line-84> </line-84>
<line-85> </line-85>
<line-86> </line-86>
<line-87> </line-87>
<line-88> </line-88>
<line-89> </line-89>
<line-90> </line-90>
<line-91> </line-91>
<line-92></line-92>
<line-94> main()</line-94>
|
{"code": "<line-2>import random</line-2>\n<line-93>for i in range(iinput()):</line-93>", "lines": [2, 93]}
#### 0
|
<line-1>import math</line-1>
<line-3>from sys import stdin, stdout</line-3>
<line-4>from string import ascii_letters</line-4>
<line-5>import sys</line-5>
<line-6>letters = ascii_letters</line-6>
<line-7>input = stdin.readline</line-7>
<line-8>#print = stdout.write</line-8>
<line-9></line-9>
<line-10>for _ in range(int(input())):</line-10>
<line-11> n = int(input())</line-11>
<line-12> arr = list(map(int, input().split()))</line-12>
<line-13> ans = [999999999] * n</line-13>
<line-14> ans[0] = 1 if arr[0] == 1 else 0</line-14>
<line-15> if n > 1:</line-15>
<line-16> ans[1] = ans[0]</line-16>
<line-17> if n > 2:</line-17>
<line-18> ans[2] = ans[0]</line-18>
<line-19> for i in range(n):</line-19>
<line-20> if i + 1 >= n:</line-20>
<line-21> continue</line-21>
<line-22> if arr[i + 1] == 1:</line-22>
<line-23> ans[i + 1] = min(ans[i + 1], ans[i] + 1)</line-23>
<line-24> if i + 2 < n:</line-24>
<line-25> ans[i + 2] = min(ans[i + 2], ans[i] + 1)</line-25>
<line-26> if i + 3 < n: </line-26>
<line-27> ans[i + 3] = min(ans[i + 3], ans[i] + 1)</line-27>
<line-28> else:</line-28>
<line-29> ans[i + 1] = min(ans[i + 1], ans[i])</line-29>
<line-30> if i + 2 < n:</line-30>
<line-31> ans[i + 2] = min(ans[i + 2], ans[i])</line-31>
<line-32> if i + 3 < n:</line-32>
<line-34> print(ans[-1])</line-34>
|
{"code": "<line-2>from collections import deque</line-2>\n<line-33> ans[i + 3] = min(ans[i + 3], ans[i])</line-33>", "lines": [2, 33]}
#### 0
|
<line-1>#list(map(int,input().split()))</line-1>
<line-3>for _ in range(t):</line-3>
<line-4> n=int(input())</line-4>
<line-5> aa=list(map(int,input().split()))</line-5>
<line-6> bb=list(map(int,input().split()))</line-6>
<line-7> aa.sort()</line-7>
<line-8> bb.sort()</line-8>
<line-10> print(*bb)</line-10>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-9> print(*aa)</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> s = input()</line-3>
<line-4> t = input()</line-4>
<line-5></line-5>
<line-6> d = {}</line-6>
<line-7> for i in range(ord('a'), ord('z') + 1):</line-7>
<line-8> d[chr(i)] = 0</line-8>
<line-9></line-9>
<line-10> for cs in s:</line-10>
<line-11> d[cs] += 1</line-11>
<line-12> for ct in t:</line-12>
<line-13> d[ct] += 1</line-13>
<line-14></line-14>
<line-15> ok = True</line-15>
<line-16> for e in d:</line-16>
<line-17> if d[e] % 2 == 1:</line-17>
<line-18> ok = False</line-18>
<line-19></line-19>
<line-20> if not ok:</line-20>
<line-21> print("No")</line-21>
<line-22> else:</line-22>
<line-23> print("Yes")</line-23>
<line-24></line-24>
<line-25> changes = []</line-25>
<line-26></line-26>
<line-27> s, t = list(s), list(t)</line-27>
<line-28> for i in range(n-1):</line-28>
<line-29> if s[i] != t[i]:</line-29>
<line-30> r = (0, -1)</line-30>
<line-31> for j in range(i+1, n):</line-31>
<line-32> if s[j] == t[i]:</line-32>
<line-33> r = (j, 0)</line-33>
<line-34></line-34>
<line-35> for j in range(i+1, n):</line-35>
<line-36> if t[j] == t[i]:</line-36>
<line-37> r = (j, 1)</line-37>
<line-38></line-38>
<line-39> if r[1] == 0:</line-39>
<line-40> changes += [(r[0], i+1), (i, i+1)]</line-40>
<line-41> s[r[0]], t[i+1] = t[i+1], s[r[0]]</line-41>
<line-42> s[i], t[i+1] = t[i+1], s[i]</line-42>
<line-43> elif r[1] == 1:</line-43>
<line-44> changes += [(i, r[0])]</line-44>
<line-45> s[i], t[r[0]] = t[r[0]], s[i]</line-45>
<line-46></line-46>
<line-47> print(len(changes))</line-47>
<line-48> for change in changes:</line-48>
<line-50> print(x+1, y+1)</line-50>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-49> x, y = change</line-49>", "lines": [2, 49]}
#### 0
|
<line-1>from itertools import groupby</line-1>
<line-3> N = int(input())</line-3>
<line-4> S = input()</line-4>
<line-5> </line-5>
<line-6> C = [len(list(x[1])) for x in groupby(S)]</line-6>
<line-7> M = len(C)</line-7>
<line-8> dup_idx = []</line-8>
<line-9> for i, c in enumerate(C):</line-9>
<line-10> if c > 1:</line-10>
<line-11> dup_idx.append(i)</line-11>
<line-12> </line-12>
<line-13> dup_idx.reverse()</line-13>
<line-14></line-14>
<line-15> curr = 0</line-15>
<line-16> while dup_idx:</line-16>
<line-17> i = dup_idx[-1]</line-17>
<line-18></line-18>
<line-19> if i < curr:</line-19>
<line-20> dup_idx.pop()</line-20>
<line-21> continue</line-21>
<line-22></line-22>
<line-23> C[i] -= 1</line-23>
<line-24> if C[i] == 1:</line-24>
<line-25> dup_idx.pop()</line-25>
<line-26></line-26>
<line-27> curr += 1</line-27>
<line-28></line-28>
<line-29> ans = curr + (M-curr+1)//2</line-29>
<line-30> </line-30>
<line-31> print(ans)</line-31>
<line-32></line-32>
<line-33>def __starting_point():</line-33>
<line-34> for __ in [0]*int(input()):</line-34>
<line-36></line-36>
<line-37>__starting_point()</line-37>
|
{"code": "<line-2>def main():</line-2>\n<line-35> main()</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> a, b = list(map(int, input().split()))</line-4>
<line-5> s = input()</line-5>
<line-6></line-6>
<line-7> z = 10000</line-7>
<line-8> total = 0</line-8>
<line-9> act = False</line-9>
<line-10></line-10>
<line-11> for i in range(len(s)):</line-11>
<line-12> cur = s[i]</line-12>
<line-13> if cur == '0':</line-13>
<line-14> z += 1</line-14>
<line-15> act = False</line-15>
<line-16> else:</line-16>
<line-17> if not act:</line-17>
<line-18> act = True</line-18>
<line-19> total += min(a, b * z)</line-19>
<line-21></line-21>
<line-22> print(total)</line-22>
|
{"code": "<line-3>for case in range(t):</line-3>\n<line-20> z = 0</line-20>", "lines": [3, 20]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from collections import defaultdict</line-3>
<line-4></line-4>
<line-5>class Unionfind:</line-5>
<line-6> def __init__(self, n):</line-6>
<line-7> self.par = [-1]*n</line-7>
<line-8> self.rank = [1]*n</line-8>
<line-9> </line-9>
<line-10> def root(self, x):</line-10>
<line-11> r = x</line-11>
<line-12> </line-12>
<line-13> while not self.par[r]<0:</line-13>
<line-14> r = self.par[r]</line-14>
<line-15> </line-15>
<line-16> t = x</line-16>
<line-17> </line-17>
<line-18> while t!=r:</line-18>
<line-19> tmp = t</line-19>
<line-20> t = self.par[t]</line-20>
<line-21> self.par[tmp] = r</line-21>
<line-22> </line-22>
<line-23> return r</line-23>
<line-24> </line-24>
<line-25> def unite(self, x, y):</line-25>
<line-26> rx = self.root(x)</line-26>
<line-27> ry = self.root(y)</line-27>
<line-28> </line-28>
<line-29> if rx==ry:</line-29>
<line-30> return</line-30>
<line-31> </line-31>
<line-32> if self.rank[rx]<=self.rank[ry]:</line-32>
<line-33> self.par[ry] += self.par[rx]</line-33>
<line-34> self.par[rx] = ry</line-34>
<line-35> </line-35>
<line-36> if self.rank[rx]==self.rank[ry]:</line-36>
<line-37> self.rank[ry] += 1</line-37>
<line-38> else:</line-38>
<line-39> self.par[rx] += self.par[ry]</line-39>
<line-40> self.par[ry] = rx</line-40>
<line-41> </line-41>
<line-42> def is_same(self, x, y):</line-42>
<line-43> return self.root(x)==self.root(y)</line-43>
<line-44> </line-44>
<line-45> def count(self, x):</line-45>
<line-46> return -self.par[self.root(x)]</line-46>
<line-47></line-47>
<line-48>t = int(input())</line-48>
<line-49></line-49>
<line-50>for _ in range(t):</line-50>
<line-51> n, k = map(int, input().split())</line-51>
<line-52> s = input()[:-1]</line-52>
<line-53> uf = Unionfind(n)</line-53>
<line-54> </line-54>
<line-55> for i in range(n//2):</line-55>
<line-56> uf.unite(i, n-1-i)</line-56>
<line-57> </line-57>
<line-58> for i in range(n-k):</line-58>
<line-59> uf.unite(i, i+k)</line-59>
<line-60> </line-60>
<line-61> d = defaultdict(dict)</line-61>
<line-62> </line-62>
<line-63> for i in range(n):</line-63>
<line-64> if s[i] not in d[uf.root(i)]:</line-64>
<line-65> d[uf.root(i)][s[i]] = 1</line-65>
<line-66> else:</line-66>
<line-67> d[uf.root(i)][s[i]] += 1</line-67>
<line-68> </line-68>
<line-69> rs = set(uf.root(i) for i in range(n))</line-69>
<line-70> ans = 0</line-70>
<line-71> </line-71>
<line-72> for r in rs:</line-72>
<line-74> </line-74>
<line-75> print(ans)</line-75>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-73> ans += uf.count(r)-max(list(d[r].values()))</line-73>", "lines": [2, 73]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n=int(input())</line-3>
<line-4> a=list(map(int,input().split()))</line-4>
<line-5> an=0</line-5>
<line-6> s=0</line-6>
<line-7> for i in a :</line-7>
<line-8> if s+i>=0 :</line-8>
<line-9> s+=i </line-9>
<line-10> else :</line-10>
<line-11> s+=i</line-11>
<line-12> an-=s </line-12>
<line-13> s=0</line-13>
<line-15> t-=1 </line-15>
|
{"code": "<line-2>while t>0 :</line-2>\n<line-14> print(an)</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> n, k = [int(x) for x in input().split()]</line-4>
<line-5> a = [int(x) for x in input().split()]</line-5>
<line-6> if len(set(a)) > k:</line-6>
<line-7> print(-1)</line-7>
<line-8> continue</line-8>
<line-9> l = list(set(a))</line-9>
<line-10> l.extend([1]*(k - len(l)))</line-10>
<line-11></line-11>
<line-12> print(n*k)</line-12>
<line-13> for _ in range(n):</line-13>
<line-15> print()</line-15>
|
{"code": "<line-3>for _ in range(t):</line-3>\n<line-14> print(*l, end=\" \")</line-14>", "lines": [3, 14]}
#### 0
|
<line-1>def solve():</line-1>
<line-3> a = list(map(int, input().split()))</line-3>
<line-4> c = [0] * (n + 1)</line-4>
<line-5> def inc():</line-5>
<line-6> for i in range(n - 1):</line-6>
<line-7> if a[i] > a[i + 1]:</line-7>
<line-8> return False</line-8>
<line-9> return True</line-9>
<line-10> def calc():</line-10>
<line-11> for i in range(n + 1):</line-11>
<line-12> c[i] = 0</line-12>
<line-13> for i in a:</line-13>
<line-14> c[i] += 1</line-14>
<line-15> for i in range(n + 1):</line-15>
<line-16> if not c[i]:</line-16>
<line-17> return i</line-17>
<line-18> return n + 1</line-18>
<line-19> ans = []</line-19>
<line-20> while not inc():</line-20>
<line-21> x = calc()</line-21>
<line-22> if x >= n:</line-22>
<line-23> y = 0</line-23>
<line-24> while y < n and a[y] == y:</line-24>
<line-25> y += 1</line-25>
<line-26> a[y] = x</line-26>
<line-27> ans.append(y)</line-27>
<line-28> else:</line-28>
<line-29> a[x] = x</line-29>
<line-30> ans.append(x)</line-30>
<line-31> print(len(ans))</line-31>
<line-32> print(*map(lambda x: x + 1, ans))</line-32>
<line-33></line-33>
<line-34>t = int(input())</line-34>
<line-36> solve()</line-36>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-35>for _ in range(t):</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>def read_int():</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>def read_ints():</line-5>
<line-6> return list(map(int, input().split(' ')))</line-6>
<line-7></line-7>
<line-8></line-8>
<line-9>t = read_int()</line-9>
<line-10>for case_num in range(t):</line-10>
<line-11> n, k = read_ints()</line-11>
<line-12> p = []</line-12>
<line-13> for i in range(n):</line-13>
<line-14> ai, bi = read_ints()</line-14>
<line-15> p.append((bi, ai, i + 1))</line-15>
<line-16> p.sort()</line-16>
<line-17> dp = [[0 for j in range(k + 1)] for i in range(n + 1)]</line-17>
<line-18> use = [[False for j in range(k + 1)] for i in range(n + 1)]</line-18>
<line-19> for i in range(1, n + 1):</line-19>
<line-20> for j in range(min(i, k) + 1):</line-20>
<line-21> if i - 1 >= j:</line-21>
<line-22> dp[i][j] = dp[i - 1][j] + (k - 1) * p[i - 1][0]</line-22>
<line-23> if j > 0:</line-23>
<line-24> x = dp[i - 1][j - 1] + (j - 1) * p[i - 1][0] + p[i - 1][1]</line-24>
<line-25> if x > dp[i][j]:</line-25>
<line-26> dp[i][j] = x</line-26>
<line-27> use[i][j] = True</line-27>
<line-28> used = []</line-28>
<line-29> curr = k</line-29>
<line-30> for i in range(n, 0, -1):</line-30>
<line-31> if use[i][curr]:</line-31>
<line-32> used.append(p[i - 1][2])</line-32>
<line-33> curr -= 1</line-33>
<line-34> used.reverse()</line-34>
<line-35> seq = used[:-1]</line-35>
<line-36> st = set(used)</line-36>
<line-37> for i in range(1, n + 1):</line-37>
<line-38> if not i in st:</line-38>
<line-39> seq.append(i)</line-39>
<line-40> seq.append(-i)</line-40>
<line-41> seq.append(used[-1])</line-41>
<line-43> print(' '.join(map(str, seq)))</line-43>
|
{"code": "<line-2> return int(input())</line-2>\n<line-42> print(len(seq))</line-42>", "lines": [2, 42]}
#### 0
|
<line-1>import math</line-1>
<line-2></line-2>
<line-4>for _ in range(T):</line-4>
<line-5> n = int(input())</line-5>
<line-7> print(diags * math.cos(math.pi/4/n))</line-7>
|
{"code": "<line-3>T = int(input())</line-3>\n<line-6> diags = 1/math.sin(math.pi/2/n)</line-6>", "lines": [3, 6]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> n = int(input())</line-4>
<line-5> if n%4 == 0:</line-5>
<line-6> print("YES")</line-6>
<line-8> print("NO")</line-8>
|
{"code": "<line-3>for _ in range(t):</line-3>\n<line-7> else:</line-7>", "lines": [3, 7]}
#### 0
|
<line-1>3</line-1>
<line-2></line-2>
<line-4>import os</line-4>
<line-5>import sys</line-5>
<line-6></line-6>
<line-7></line-7>
<line-8>DEBUG = 'DEBUG' in os.environ</line-8>
<line-9></line-9>
<line-10></line-10>
<line-11>def inp():</line-11>
<line-12> return sys.stdin.readline().rstrip()</line-12>
<line-13></line-13>
<line-14></line-14>
<line-15>def dprint(*value, sep=' ', end='\n'):</line-15>
<line-16> if DEBUG:</line-16>
<line-17> print(*value, sep=sep, end=end)</line-17>
<line-18></line-18>
<line-19></line-19>
<line-20>INF = 10 ** 20</line-20>
<line-21></line-21>
<line-22></line-22>
<line-23>def solve(N, A, B):</line-23>
<line-24> dp = {A[0]: 0, A[0] + 1: B[0], A[0] + 2: B[0] * 2}</line-24>
<line-25> for i in range(1, N):</line-25>
<line-26> ndp = {}</line-26>
<line-27></line-27>
<line-28> h = A[i]</line-28>
<line-29> for ph, c in dp.items():</line-29>
<line-30> for inc in range(3):</line-30>
<line-31> nh = h + inc</line-31>
<line-32> if ph == nh:</line-32>
<line-33> continue</line-33>
<line-34> if nh not in ndp:</line-34>
<line-35> ndp[nh] = INF</line-35>
<line-36> ndp[nh] = min(ndp[nh], c + B[i] * inc)</line-36>
<line-37></line-37>
<line-38> dp = ndp</line-38>
<line-39></line-39>
<line-40> return min(dp.values())</line-40>
<line-41></line-41>
<line-42></line-42>
<line-43>def main():</line-43>
<line-44> Q = int(inp())</line-44>
<line-45> for _ in range(Q):</line-45>
<line-46> N = int(inp())</line-46>
<line-47> A = []</line-47>
<line-48> B = []</line-48>
<line-49> for _ in range(N):</line-49>
<line-50> a, b = [int(e) for e in inp().split()]</line-50>
<line-51> A.append(a)</line-51>
<line-52> B.append(b)</line-52>
<line-53> print(solve(N, A, B))</line-53>
<line-54></line-54>
<line-55></line-55>
<line-56>def __starting_point():</line-56>
<line-58></line-58>
<line-59>__starting_point()</line-59>
|
{"code": "<line-3>import math</line-3>\n<line-57> main()</line-57>", "lines": [3, 57]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>for t in range(0, q):</line-4>
<line-5> n, m = list(map(int, sys.stdin.readline().strip().split()))</line-5>
<line-6> L = []</line-6>
<line-7> R = [0] * n</line-7>
<line-8> C = [0] * m</line-8>
<line-9> for i in range (0, n):</line-9>
<line-10> L.append(sys.stdin.readline().strip())</line-10>
<line-11> for j in range (0, m):</line-11>
<line-12> if L[i][j] != "*":</line-12>
<line-13> R[i] = R[i] + 1</line-13>
<line-14> C[j] = C[j] + 1</line-14>
<line-15> ans = n + m - 1</line-15>
<line-16> for i in range (0, n):</line-16>
<line-17> for j in range (0, m):</line-17>
<line-18> x = 0</line-18>
<line-19> if L[i][j] != "*":</line-19>
<line-20> x = -1</line-20>
<line-22> print(ans)</line-22>
|
{"code": "<line-3>q = int(sys.stdin.readline().strip())</line-3>\n<line-21> ans = min([ans, R[i]+C[j]+x])</line-21>", "lines": [3, 21]}
#### 0
|
<line-1>from math import ceil</line-1>
<line-2></line-2>
<line-4>for _ in range(t):</line-4>
<line-5> n = int(input())</line-5>
<line-6> pf = []</line-6>
<line-7> for i in range(2, ceil(n**0.5)+1):</line-7>
<line-8> while n % i == 0:</line-8>
<line-9> pf.append(i)</line-9>
<line-10> n //= i</line-10>
<line-11> if n > 1:</line-11>
<line-12> pf.append(n)</line-12>
<line-13> if len(pf) == 2 and pf[0] != pf[1]:</line-13>
<line-14> print(pf[0], pf[1], pf[0]*pf[1])</line-14>
<line-15> print(1)</line-15>
<line-16> else:</line-16>
<line-17> pg = []</line-17>
<line-18> fac = []</line-18>
<line-19> nfac = []</line-19>
<line-20> while len(pf) > 0:</line-20>
<line-21> p = pf[-1]</line-21>
<line-22> mul = 0</line-22>
<line-23> while len(pf) > 0 and pf[-1] == p:</line-23>
<line-24> pf.pop()</line-24>
<line-25> mul += 1</line-25>
<line-26> pg.append([mul, p])</line-26>
<line-27> pg.sort()</line-27>
<line-28> pg = pg[::-1]</line-28>
<line-29> # print(pg)</line-29>
<line-30> cur = 0</line-30>
<line-31> if pg[0][0] == 1:</line-31>
<line-32> a = pg[0][1]</line-32>
<line-33> b = pg[1][1]</line-33>
<line-34> c = pg[2][1]</line-34>
<line-35> fac = [a, a*b*c, a*b, b, b*c, c, a*c]</line-35>
<line-36> cur = 3</line-36>
<line-37> else:</line-37>
<line-38> fac = [pg[0][1]**i for i in range(1, pg[0][0]+1)]</line-38>
<line-39> cur = 1</line-39>
<line-40> while cur < len(pg):</line-40>
<line-41> mul = pg[cur][0]</line-41>
<line-42> p = pg[cur][1]</line-42>
<line-43> nfac = []</line-43>
<line-44> for i in range(len(fac)):</line-44>
<line-45> if i == 0:</line-45>
<line-46> nfac += [fac[i]*(p**j) for j in range(mul, -1, -1)]</line-46>
<line-47> else:</line-47>
<line-48> nfac += [fac[i]*(p**j) for j in range(mul+1)]</line-48>
<line-49> nfac += [p**i for i in range(1, mul+1)]</line-49>
<line-50> fac = nfac</line-50>
<line-51> cur += 1</line-51>
<line-53> print(0)</line-53>
|
{"code": "<line-3>t = int(input())</line-3>\n<line-52> print(\" \".join([str(i) for i in fac]))</line-52>", "lines": [3, 52]}
#### 0
|
<line-1>def solve(L, R):</line-1>
<line-3> for i in range(32):</line-3>
<line-4> for j in range(32):</line-4>
<line-5> l = (L >> i) << i</line-5>
<line-6> r = (R >> j) << j</line-6>
<line-7> #print(l, r)</line-7>
<line-8> if l>>i&1==0 or r>>j&1==0:</line-8>
<line-9> continue</line-9>
<line-10> l -= 1<<i</line-10>
<line-11> r -= 1<<j</line-11>
<line-12> if l & r:</line-12>
<line-13> continue</line-13>
<line-14> lr = l ^ r</line-14>
<line-15> ma = max(i, j)</line-15>
<line-16> mi = min(i, j)</line-16>
<line-17> mask = (1<<ma)-1</line-17>
<line-18> p = bin(lr&mask).count("1")</line-18>
<line-19> ip = ma - mi - p</line-19>
<line-20> res += 3**mi * 2**ip</line-20>
<line-21> #print(l, r, mi, ip, 3**mi * 2**ip)</line-21>
<line-22> return res</line-22>
<line-23></line-23>
<line-24>T = int(input())</line-24>
<line-25>for _ in range(T):</line-25>
<line-27> print(solve(r+1, r+1) + solve(l, l) - solve(l, r+1) * 2)</line-27>
|
{"code": "<line-2> res = 0</line-2>\n<line-26> l, r = list(map(int, input().split()))</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> n = len(a)</line-3>
<line-4></line-4>
<line-5> ok = True</line-5>
<line-6> for i in range(n):</line-6>
<line-7> if c[i] not in [a[i], b[i]]:</line-7>
<line-9></line-9>
<line-10> print('YES' if ok else 'NO')</line-10>
|
{"code": "<line-2>\ta, b, c = input(), input(), input()</line-2>\n<line-8>\t\t\tok = False</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>for __ in range(int(input())):</line-1>
<line-3> ar = list(map(int, input().split()))</line-3>
<line-5> print(*ar)</line-5>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-4> ar.reverse()</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>def one():</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>def two():</line-5>
<line-6> return list(map(int, input().split()))</line-6>
<line-7></line-7>
<line-8></line-8>
<line-9>def lis():</line-9>
<line-10> return list(map(int, input().split()))</line-10>
<line-11></line-11>
<line-12></line-12>
<line-13>def st():</line-13>
<line-14> return input()</line-14>
<line-15></line-15>
<line-16></line-16>
<line-17>for _ in range(one()):</line-17>
<line-18> x, y, a, b = list(map(int, input().split()))</line-18>
<line-19> d = y - x</line-19>
<line-20> if d%(a+b)==0:</line-20>
<line-21> print(d//(a+b))</line-21>
<line-23> print(-1)</line-23>
|
{"code": "<line-2> return int(input())</line-2>\n<line-22> else:</line-22>", "lines": [2, 22]}
#### 0
|
<line-1># encoding: utf-8</line-1>
<line-3></line-3>
<line-4>def solve(a):</line-4>
<line-5></line-5>
<line-6> # root node of tries denotes empty stack</line-6>
<line-7> stack = [None]</line-7>
<line-8> node_stack = [[1, {}]]</line-8>
<line-9> trie = node_stack[-1]</line-9>
<line-10></line-10>
<line-11> counter = 0</line-11>
<line-12> for i in range(len(a)):</line-12>
<line-13> el = a[i]</line-13>
<line-14></line-14>
<line-15> if len(stack) == 0 or stack[-1] != el:</line-15>
<line-16></line-16>
<line-17> current_node = node_stack[-1]</line-17>
<line-18> stack.append(el)</line-18>
<line-19> if el not in current_node[1]:</line-19>
<line-20> current_node[1][el] = [0, {}]</line-20>
<line-21></line-21>
<line-22> next_node = current_node[1][el]</line-22>
<line-23> next_node[0] += 1</line-23>
<line-24> node_stack.append(next_node)</line-24>
<line-25></line-25>
<line-26> else:</line-26>
<line-27> # just go up in trie</line-27>
<line-28> stack.pop()</line-28>
<line-29> node_stack.pop()</line-29>
<line-30> node_stack[-1][0] += 1</line-30>
<line-31></line-31>
<line-32> value = node_stack[-1][0]</line-32>
<line-33> counter -= (((value - 1) * (value - 2)) // 2)</line-33>
<line-34> counter += (((value) * (value - 1)) // 2)</line-34>
<line-35></line-35>
<line-36> return counter</line-36>
<line-37></line-37>
<line-38></line-38>
<line-39>q = int(stdin.readline().strip())</line-39>
<line-40>for _ in range(q):</line-40>
<line-41> n = int(stdin.readline().strip())</line-41>
<line-43> print(solve(a))</line-43>
|
{"code": "<line-2>from sys import stdin</line-2>\n<line-42> a = [int(i) for i in stdin.readline().strip().split()]</line-42>", "lines": [2, 42]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>for _ in range(int(input())):</line-5>
<line-6> s=input().rstrip()</line-6>
<line-7> x=int(input())</line-7>
<line-8> n=len(s)</line-8>
<line-9> ans=["1" for i in range(n)]</line-9>
<line-10> for i in range(n):</line-10>
<line-11> if s[i]=="0":</line-11>
<line-12> if i-x>=0:</line-12>
<line-13> ans[i-x]="0"</line-13>
<line-14> if i+x<n:</line-14>
<line-15> ans[i+x]="0"</line-15>
<line-16> for i in range(n):</line-16>
<line-17> if s[i]=="1":</line-17>
<line-18> check=False</line-18>
<line-19> if i-x>=0:</line-19>
<line-20> check|=(ans[i-x]=="1")</line-20>
<line-21> if i+x<n:</line-21>
<line-22> check|=(ans[i+x]=="1")</line-22>
<line-23> if not check:</line-23>
<line-24> print(-1)</line-24>
<line-25> break</line-25>
<line-27> print("".join(ans))</line-27>
|
{"code": "<line-3>input=sys.stdin.readline</line-3>\n<line-26> else:</line-26>", "lines": [3, 26]}
#### 0
|
<line-1>def solve():</line-1>
<line-3> lst = list(map(int,input().split()))</line-3>
<line-4> if sum(lst) <= n // 2:</line-4>
<line-5> print(n//2)</line-5>
<line-6> print("0 " * (n // 2))</line-6>
<line-7> else:</line-7>
<line-8> print(n//2 + (n // 2) % 2)</line-8>
<line-9> print("1 " * (n//2 + (n // 2) % 2))</line-9>
<line-11> solve()</line-11>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-10>for i in range(int(input())):</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>readlines = sys.stdin.readlines</line-4>
<line-5>ns = lambda: readline().rstrip()</line-5>
<line-6>ni = lambda: int(readline().rstrip())</line-6>
<line-7>nm = lambda: map(int, readline().split())</line-7>
<line-8>nl = lambda: list(map(int, readline().split()))</line-8>
<line-9>prn = lambda x: print(*x, sep='\n')</line-9>
<line-10></line-10>
<line-11>def gcd(a, b):</line-11>
<line-12> while b:</line-12>
<line-13> a, b = b, a%b</line-13>
<line-14> return a</line-14>
<line-15></line-15>
<line-16>def solve():</line-16>
<line-17> m, d, w = nm()</line-17>
<line-18> g = w // gcd(d-1, w)</line-18>
<line-19> c = min(m, d)</line-19>
<line-20> v = c // g</line-20>
<line-21> ans = v * (v - 1) // 2 * g</line-21>
<line-22> ans += (c - g * v) * v</line-22>
<line-23> print(ans)</line-23>
<line-24> return</line-24>
<line-25></line-25>
<line-26></line-26>
<line-27># solve()</line-27>
<line-28></line-28>
<line-29>T = ni()</line-29>
<line-31> solve()</line-31>
|
{"code": "<line-3>readline = sys.stdin.readline</line-3>\n<line-30>for _ in range(T):</line-30>", "lines": [3, 30]}
#### 0
|
<line-1>n = input()</line-1>
<line-3>for i in a:</line-3>
<line-4> if i % 7 == 0 or (i // 7) % 2 == 1 or i <= 14:</line-4>
<line-5> print('NO')</line-5>
<line-7> print('YES')</line-7>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-6>\telse:</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>for loop in range(tt):</line-5>
<line-6></line-6>
<line-7> n = int(stdin.readline())</line-7>
<line-8> a = list(map(int,stdin.readline().split()))</line-8>
<line-9></line-9>
<line-10> lis = [ [1] ]</line-10>
<line-11></line-11>
<line-12> now = []</line-12>
<line-13> tmp = 0</line-13>
<line-14></line-14>
<line-15> for i in range(1,n):</line-15>
<line-16> if len(now) == 0:</line-16>
<line-17> now.append(a[i])</line-17>
<line-18> tmp = 1</line-18>
<line-19> elif now[-1] > a[i]:</line-19>
<line-20> if tmp == len(lis[-1]):</line-20>
<line-21> lis.append(now)</line-21>
<line-22> now = [a[i]]</line-22>
<line-23> tmp = 1</line-23>
<line-24> else:</line-24>
<line-25> tmp += 1</line-25>
<line-26> now.append(a[i])</line-26>
<line-27> else:</line-27>
<line-28> now.append(a[i])</line-28>
<line-29></line-29>
<line-30> if len(now) > 0:</line-30>
<line-31> lis.append(now)</line-31>
<line-32></line-32>
<line-34> print (len(lis)-1)</line-34>
|
{"code": "<line-3>tt = int(stdin.readline())</line-3>\n<line-33> #print (lis)</line-33>", "lines": [3, 33]}
#### 0
|
<line-1>import math</line-1>
<line-3>from sys import stdin, stdout</line-3>
<line-4>from string import ascii_letters</line-4>
<line-5>import sys</line-5>
<line-6>letters = ascii_letters</line-6>
<line-7>input = stdin.readline</line-7>
<line-8>#print = stdout.write</line-8>
<line-9></line-9>
<line-10>for _ in range(int(input())):</line-10>
<line-11> n = int(input())</line-11>
<line-12> arr = list(map(int, input().split()))</line-12>
<line-13> can = list(map(int, input().split()))</line-13>
<line-14> vals = sorted([i for i in range(n) if not can[i]], key=lambda x: -arr[x])</line-14>
<line-15> res = [0] * n</line-15>
<line-16> last = 0</line-16>
<line-17> for i in range(n):</line-17>
<line-18> if can[i]:</line-18>
<line-19> res[i] = arr[i]</line-19>
<line-20> else:</line-20>
<line-21> res[i] = arr[vals[last]]</line-21>
<line-23> print(*res)</line-23>
|
{"code": "<line-2>from collections import deque</line-2>\n<line-22> last += 1</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> a = [0] + list(map(int,input().split()))</line-4>
<line-5> nun = []</line-5>
<line-6> ans = []</line-6>
<line-7> f = True</line-7>
<line-8> for i in range(1, n + 1):</line-8>
<line-9> if a[i] == a[i-1]:</line-9>
<line-10> if len(nun) == 0:</line-10>
<line-11> f = False</line-11>
<line-12> break</line-12>
<line-13> else:</line-13>
<line-14> ans.append(nun.pop())</line-14>
<line-15> else:</line-15>
<line-16> ans.append(a[i])</line-16>
<line-17> for i in range(a[i - 1] + 1, a[i]):</line-17>
<line-18> nun.append(i)</line-18>
<line-19> if f:</line-19>
<line-20> print(*ans)</line-20>
<line-22> print(-1)</line-22>
|
{"code": "<line-2>for faw in range(t):</line-2>\n<line-21> else:</line-21>", "lines": [2, 21]}
#### 0
|
<line-2> print("YES" if set(input()).intersection(input()) else "NO")</line-2>
|
{"code": "<line-1>for _ in range(int(input())):</line-1>", "lines": [1]}
#### 0
|
<line-1>for tc in range(int(input())):</line-1>
<line-3> al = list(map(int, input().split()))</line-3>
<line-4> bl = list(map(int, input().split()))</line-4>
<line-5> aidx = {}</line-5>
<line-6> for i,e in enumerate(al):</line-6>
<line-7> aidx[e]=i</line-7>
<line-8> midx = -1</line-8>
<line-9> res = 0</line-9>
<line-10> for i,e in enumerate(bl):</line-10>
<line-11> idx = aidx[e]</line-11>
<line-12> if idx <= midx:</line-12>
<line-13> res += 1</line-13>
<line-14> else:</line-14>
<line-15> res += 2*(idx-i)+1</line-15>
<line-17> print(res)</line-17>
|
{"code": "<line-2> n,m = list(map(int, input().split()))</line-2>\n<line-16> midx = max(midx, idx)</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>T = int(input())</line-1>
<line-3> n,t = list(map(int,input().split()))</line-3>
<line-4> a = list(map(int,input().split()))</line-4>
<line-5> res = []</line-5>
<line-6> j=0</line-6>
<line-7> for i in a:</line-7>
<line-8> if(i*2<t):</line-8>
<line-9> res+=["0"]</line-9>
<line-10> elif(i*2>t):</line-10>
<line-11> res+=["1"]</line-11>
<line-12> else:</line-12>
<line-13> res.append(["0","1"][j])</line-13>
<line-15> print(" ".join(res))</line-15>
|
{"code": "<line-2>for test in range(T):</line-2>\n<line-14> j = 1-j</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>#JMD</line-1>
<line-3></line-3>
<line-4> </line-4>
<line-5>import sys</line-5>
<line-6>import math</line-6>
<line-7></line-7>
<line-8>#import fractions</line-8>
<line-9>#import numpy</line-9>
<line-10> </line-10>
<line-11>###File Operations###</line-11>
<line-12>fileoperation=0</line-12>
<line-13>if(fileoperation):</line-13>
<line-14> orig_stdout = sys.stdout</line-14>
<line-15> orig_stdin = sys.stdin</line-15>
<line-16> inputfile = open('W:/Competitive Programming/input.txt', 'r')</line-16>
<line-17> outputfile = open('W:/Competitive Programming/output.txt', 'w')</line-17>
<line-18> sys.stdin = inputfile</line-18>
<line-19> sys.stdout = outputfile</line-19>
<line-20></line-20>
<line-21>###Defines...###</line-21>
<line-22>mod=1000000007</line-22>
<line-23> </line-23>
<line-24>###FUF's...###</line-24>
<line-25>def nospace(l):</line-25>
<line-26> ans=''.join(str(i) for i in l)</line-26>
<line-27> return ans</line-27>
<line-28> </line-28>
<line-29> </line-29>
<line-30> </line-30>
<line-31>##### Main ####</line-31>
<line-32>t=int(input())</line-32>
<line-33>for tt in range(t):</line-33>
<line-34> n=int(input())</line-34>
<line-35></line-35>
<line-36> if n==1:</line-36>
<line-37> print(-1)</line-37>
<line-38> else:</line-38>
<line-39> s="2"</line-39>
<line-40> for i in range(n-1):</line-40>
<line-41> s+='3'</line-41>
<line-42> print(s)</line-42>
<line-43> #n,k,s= map(int, sys.stdin.readline().split(' '))</line-43>
<line-44> #a=list(map(int,sys.stdin.readline().split(' ')))</line-44>
<line-45> </line-45>
<line-46> </line-46>
<line-47>#####File Operations#####</line-47>
<line-48>if(fileoperation):</line-48>
<line-49> sys.stdout = orig_stdout</line-49>
<line-50> sys.stdin = orig_stdin</line-50>
<line-52> outputfile.close()</line-52>
|
{"code": "<line-2>#Nagendra Jha-4096</line-2>\n<line-51> inputfile.close()</line-51>", "lines": [2, 51]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>def count(a, b, num_a, num_b, cur_time):</line-4>
<line-5> current_result = 0</line-5>
<line-6> #print('count time = ', cur_time, "num_a =", num_a, 'num_b = ', num_b)</line-6>
<line-7> if num_a * a + num_b * b <= cur_time and cur_time >= 0:</line-7>
<line-8> cur_time -= num_a * a + num_b * b</line-8>
<line-9> current_result = num_a + num_b</line-9>
<line-10> if num_a < total_a:</line-10>
<line-11> if (total_a - num_a) * a <= cur_time:</line-11>
<line-12> current_result += total_a - num_a</line-12>
<line-13> cur_time -= (total_a - num_a) * a</line-13>
<line-14> #print(1)</line-14>
<line-15> else:</line-15>
<line-16> current_result += cur_time // a</line-16>
<line-17> cur_time -= a *(cur_time // a)</line-17>
<line-18> #print(2)</line-18>
<line-19> if num_b < total_b:</line-19>
<line-20> if (total_b - num_b) * b <= cur_time:</line-20>
<line-21> current_result += total_b - num_b</line-21>
<line-22> #print(3)</line-22>
<line-23> else:</line-23>
<line-24> #print(4)</line-24>
<line-25> current_result += cur_time // b</line-25>
<line-26> #print('current_result = ', current_result)</line-26>
<line-27> return current_result</line-27>
<line-28></line-28>
<line-29></line-29>
<line-30>def solve(n, T, a, b, tasks, total_a, total_b): </line-30>
<line-31> tasks = sorted(tasks)</line-31>
<line-32> #print(tasks)</line-32>
<line-33> result = 0</line-33>
<line-34> num_a = 0</line-34>
<line-35> num_b = 0</line-35>
<line-36></line-36>
<line-37> for i in range(len(tasks)):</line-37>
<line-38> time, t = tasks[i] </line-38>
<line-39> #print(tasks[i])</line-39>
<line-40> cur_time = time - 1</line-40>
<line-41> #print('cur time = ', cur_time)</line-41>
<line-42> current_result = count(a, b, num_a, num_b, cur_time)</line-42>
<line-43> result = max(current_result, result)</line-43>
<line-44></line-44>
<line-45> if t == 0:</line-45>
<line-46> num_a += 1</line-46>
<line-47> else:</line-47>
<line-48> num_b += 1</line-48>
<line-49></line-49>
<line-50> if i == len(tasks) - 1 or tasks[i + 1][1] != tasks[i][1]:</line-50>
<line-51> result = max(result, count(a, b, num_a, num_b, cur_time))</line-51>
<line-52></line-52>
<line-53> #print("i =", i, "result = ", result)</line-53>
<line-54></line-54>
<line-55> result = max(result, count(a, b, total_a, total_b, T))</line-55>
<line-56> return result</line-56>
<line-57></line-57>
<line-58></line-58>
<line-59>q = int(input())</line-59>
<line-60></line-60>
<line-61>for i in range(q):</line-61>
<line-62> n, T, a, b = list(map(int, input().split()))</line-62>
<line-63> types = list(map(int, input().split()))</line-63>
<line-64> total_a, total_b = 0, 0</line-64>
<line-65> for t in types:</line-65>
<line-66> if t == 0:</line-66>
<line-67> total_a += 1</line-67>
<line-68> else:</line-68>
<line-69> total_b += 1</line-69>
<line-70> t = list(map(int, input().split()))</line-70>
<line-71> #print(t)</line-71>
<line-72> #print(types)</line-72>
<line-74> print(solve(n, T, a, b, tasks, total_a, total_b)) </line-74>
|
{"code": "<line-2>from operator import itemgetter</line-2>\n<line-73>\ttasks = list(zip(t, types))</line-73>", "lines": [2, 73]}
#### 0
|
<line-1>import sys</line-1>
<line-3>input = reader.__next__</line-3>
<line-4></line-4>
<line-5>def solve():</line-5>
<line-6> s,c = input().split()</line-6>
<line-7> # i,jでjが複数あるとき</line-7>
<line-8> n = len(s)</line-8>
<line-9> for i in range(n-1):</line-9>
<line-10> prev = s[i]</line-10>
<line-11> pos = i</line-11>
<line-12> for j in range(i+1, n):</line-12>
<line-13> if s[j]<prev:</line-13>
<line-14> prev = s[j]</line-14>
<line-15> pos = j</line-15>
<line-16> elif s[j] == prev:</line-16>
<line-17> pos = j</line-17>
<line-18> if prev == s[i]:</line-18>
<line-19> continue</line-19>
<line-20> t = list(s)</line-20>
<line-21> t[i], t[pos] = prev, s[i]</line-21>
<line-22> s = "".join(t)</line-22>
<line-23> break</line-23>
<line-24> if s<c:</line-24>
<line-25> print(s)</line-25>
<line-26> else:</line-26>
<line-27> print("---")</line-27>
<line-28></line-28>
<line-29>t = int(input())</line-29>
<line-31> solve()</line-31>
|
{"code": "<line-2>reader = (s.rstrip() for s in sys.stdin)</line-2>\n<line-30>for i in range(t):</line-30>", "lines": [2, 30]}
#### 0
|
<line-2>for _ in range(q):</line-2>
<line-3> c, m, x = list(map(int, input().split()))</line-3>
<line-4> print(min([c, m, (c + m + x) // 3]))</line-4>
|
{"code": "<line-1>q = int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> n = int(input())</line-3>
<line-4> # arr = list(map(int, input().split()))</line-4>
<line-5> s = input()</line-5>
<line-6> l = 0</line-6>
<line-7> r = n - 1</line-7>
<line-8> if s.count('0') == n:</line-8>
<line-9> print(s)</line-9>
<line-10> continue</line-10>
<line-11> if s.count('1') == n:</line-11>
<line-12> print(s)</line-12>
<line-13> continue</line-13>
<line-14> while s[l] == '0':</line-14>
<line-15> l += 1</line-15>
<line-16> while s[r] == '1':</line-16>
<line-17> r -= 1</line-17>
<line-18> if r <= l:</line-18>
<line-19> print(s)</line-19>
<line-21> print(l * '0' + '0' + (n - r - 1) * '1')</line-21>
|
{"code": "<line-2> # a, b = map(int, input().split())</line-2>\n<line-20> continue</line-20>", "lines": [2, 20]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.