question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1>def main():</line-1>
<line-3> input = sys.stdin.readline</line-3>
<line-4></line-4>
<line-5> import heapq</line-5>
<line-6> def dijkstra_heap(s,g,edge):</line-6>
<line-7> #始点sから各頂点への最短距離</line-7>
<line-8> d = [10**20] * (n+2)</line-8>
<line-9> used = [True] * (n+2) #True:未確定</line-9>
<line-10> d[s] = 0</line-10>
<line-11> used[s] = False</line-11>
<line-12> edgelist = []</line-12>
<line-13> sx,sy,sr=edge[s][0],edge[s][1],edge[s][2]</line-13>
<line-14> for i in range(n+2):</line-14>
<line-15> x,y,r=edge[i][0],edge[i][1],edge[i][2]</line-15>
<line-16> dist=((x-sx)**2+(y-sy)**2)**(1/2)</line-16>
<line-17> heapq.heappush(edgelist,(max(dist-r-sr,0),i))</line-17>
<line-18> while len(edgelist):</line-18>
<line-19> minedge = heapq.heappop(edgelist)</line-19>
<line-20> #まだ使われてない頂点の中から最小の距離のものを探す</line-20>
<line-21> v = minedge[1]</line-21>
<line-22> if not used[v]:</line-22>
<line-23> continue</line-23>
<line-24> d[v] = minedge[0]</line-24>
<line-25> used[v] = False</line-25>
<line-26> bx,by,br=edge[v][0],edge[v][1],edge[v][2]</line-26>
<line-27> for i in range(n+2):</line-27>
<line-28> x,y,r=edge[i][0],edge[i][1],edge[i][2]</line-28>
<line-29> dist=((x-bx)**2+(y-by)**2)**(1/2)</line-29>
<line-30> if used[i]:</line-30>
<line-31> heapq.heappush(edgelist,(max(dist-r-br,0)+d[v],i))</line-31>
<line-32> if not used[g]:</line-32>
<line-33> break</line-33>
<line-34> return d[g]</line-34>
<line-35></line-35>
<line-36> sx,sy,gx,gy = map(int,input().split()) #n:頂点数 w:辺の数</line-36>
<line-37> n=int(input())</line-37>
<line-38> edge=[(sx,sy,0),(gx,gy,0)]</line-38>
<line-39> for i in range(2,n+2):</line-39>
<line-40> x,y,r=map(int,input().split())</line-40>
<line-41> edge.append((x,y,r))</line-41>
<line-42> print(dijkstra_heap(0,1,edge))</line-42>
<line-43></line-43>
<line-44>def __starting_point():</line-44>
<line-46>__starting_point()</line-46>
|
{"code": "<line-2> import sys</line-2>\n<line-45> main()</line-45>", "lines": [2, 45]}
#### 0
|
<line-1>N,K,M=map(int,input().split());R=range;T=[[1]]</line-1>
<line-3> q=K*i</line-3>
<line-4> if i>~i+N:T+=[y:=T[-1][:len(T[~i+N])]]</line-4>
<line-5> else:T+=[y:=T[-1][:]+[0]*q]</line-5>
<line-6> p=len(y)-i</line-6>
<line-7> for j in R(p):y[j+i]+=y[j]%M</line-7>
<line-9>for i in R(N):print(sum(T[i][j]*T[~i+N][j]for j in R(len(T[i])))*-~K%M-1)</line-9>
|
{"code": "<line-2>for i in R(1,N):</line-2>\n<line-8>\tfor j in R(p-q):y[~j]-=y[~j-i-q]%M</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>from collections import defaultdict as dd</line-1>
<line-3>import bisect</line-3>
<line-4>import heapq</line-4>
<line-5></line-5>
<line-6>def ri():</line-6>
<line-7> return int(input())</line-7>
<line-8></line-8>
<line-9>def rl():</line-9>
<line-10> return list(map(int, input().split()))</line-10>
<line-11></line-11>
<line-12></line-12>
<line-13>def solve():</line-13>
<line-14> n = ri()</line-14>
<line-15> output = [0] * (n)</line-15>
<line-16></line-16>
<line-17> Q = [(-n, 0 ,n - 1)]</line-17>
<line-18> for i in range(1, n + 1):</line-18>
<line-19> prev = heapq.heappop(Q)</line-19>
<line-20> lo, hi = prev[1], prev[2]</line-20>
<line-21> mid = (lo + hi) // 2</line-21>
<line-22> output[mid] = i</line-22>
<line-23> if mid > lo:</line-23>
<line-24> heapq.heappush(Q, (-(mid - 1 - lo), lo, mid - 1))</line-24>
<line-25> if hi > mid:</line-25>
<line-26> heapq.heappush(Q, (-(hi - 1 - mid), mid + 1, hi))</line-26>
<line-27> print(*output)</line-27>
<line-28></line-28>
<line-29></line-29>
<line-30></line-30>
<line-31></line-31>
<line-32></line-32>
<line-33>mode = 'T'</line-33>
<line-34></line-34>
<line-35>if mode == 'T':</line-35>
<line-36> t = ri()</line-36>
<line-37> for i in range(t):</line-37>
<line-38> solve()</line-38>
<line-40> solve()</line-40>
|
{"code": "<line-2>from collections import deque</line-2>\n<line-39>else:</line-39>", "lines": [2, 39]}
#### 0
|
<line-1>def main():</line-1>
<line-3> input = sys.stdin.readline</line-3>
<line-4> </line-4>
<line-5> def solve():</line-5>
<line-6> n = int(input())</line-6>
<line-7> maxx = 10**5</line-7>
<line-8> minx = -10**5</line-8>
<line-9> maxy = 10**5</line-9>
<line-10> miny = -10**5</line-10>
<line-11> </line-11>
<line-12> for _ in range(n):</line-12>
<line-13> x, y, f1, f2, f3, f4 = map(int, input().split())</line-13>
<line-14> if not f1:</line-14>
<line-15> minx = max(minx, x)</line-15>
<line-16> if not f2:</line-16>
<line-17> maxy = min(maxy, y)</line-17>
<line-18> if not f3:</line-18>
<line-19> maxx = min(maxx, x)</line-19>
<line-20> if not f4:</line-20>
<line-21> miny = max(miny, y)</line-21>
<line-22> </line-22>
<line-23> if minx > maxx or miny > maxy:</line-23>
<line-24> print(0)</line-24>
<line-25> else:</line-25>
<line-26> print(1, minx, miny)</line-26>
<line-27> </line-27>
<line-28> </line-28>
<line-29> for _ in range(int(input())):</line-29>
<line-30> solve()</line-30>
<line-31> </line-31>
<line-33></line-33>
<line-34>main()</line-34>
|
{"code": "<line-2> import sys</line-2>\n<line-32> return 0</line-32>", "lines": [2, 32]}
#### 0
|
<line-1></line-1>
<line-2>T = int(input())</line-2>
<line-3></line-3>
<line-5> a = int(input())</line-5>
<line-6> hh = sorted(map(int, input().split()))</line-6>
<line-7> ans = 10**10</line-7>
<line-8> for h1, h2 in zip(hh[:-1], hh[1:]):</line-8>
<line-10></line-10>
<line-11> print(ans)</line-11>
|
{"code": "<line-4>for _ in range(T):</line-4>\n<line-9> ans = min(ans, h2 - h1)</line-9>", "lines": [4, 9]}
#### 0
|
<line-1>import sys</line-1>
<line-3>input = sys.stdin.readline</line-3>
<line-4></line-4>
<line-5>t = int(input())</line-5>
<line-6>for _ in range(t):</line-6>
<line-7> n, m, a, b, c = list(map(int,input().split()))</line-7>
<line-8> p = list(map(int, input().split()))</line-8>
<line-9> p.sort()</line-9>
<line-10> </line-10>
<line-11> pref = [0]</line-11>
<line-12> curr = 0</line-12>
<line-13> for i in range(m):</line-13>
<line-14> curr += p[i]</line-14>
<line-15> pref.append(curr)</line-15>
<line-16></line-16>
<line-17> adj = [[] for i in range(n)]</line-17>
<line-18> for _ in range(m):</line-18>
<line-19> u, v = list(map(int,input().split()))</line-19>
<line-20> adj[u - 1].append(v - 1)</line-20>
<line-21> adj[v - 1].append(u - 1)</line-21>
<line-22></line-22>
<line-23> </line-23>
<line-24> aD = [-1] * n</line-24>
<line-25> bD = [-1] * n</line-25>
<line-26> cD = [-1] * n</line-26>
<line-27></line-27>
<line-28> for i in range(3):</line-28>
<line-29> q = deque()</line-29>
<line-30> q.append(([a,b,c][i]-1,0))</line-30>
<line-31> l = [aD,bD,cD][i]</line-31>
<line-32> l[q[0][0]] = 0</line-32>
<line-33> while q:</line-33>
<line-34> v, d = q.popleft()</line-34>
<line-35> for nex in adj[v]:</line-35>
<line-36> if l[nex] == -1:</line-36>
<line-37> l[nex] = d + 1</line-37>
<line-38> q.append((nex,d+1))</line-38>
<line-39> poss = []</line-39>
<line-40> for i in range(n):</line-40>
<line-41> if aD[i] + bD[i] + cD[i] <= m:</line-41>
<line-43> print(min(poss))</line-43>
<line-44> </line-44>
|
{"code": "<line-2>from collections import deque</line-2>\n<line-42> poss.append(pref[aD[i] + bD[i] + cD[i]] + pref[bD[i]])</line-42>", "lines": [2, 42]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>def dfs(x,S):</line-4>
<line-5> #print(x,S)</line-5>
<line-6> for i in range(len(S)):</line-6>
<line-7> if x in S[i]:</line-7>
<line-8> S[i].remove(x)</line-8>
<line-9></line-9>
<line-10> #print(x,S)</line-10>
<line-11> </line-11>
<line-12> LEN1=0</line-12>
<line-13> for s in S:</line-13>
<line-14> if len(s)==1:</line-14>
<line-15> LEN1+=1</line-15>
<line-16> ne=list(s)[0]</line-16>
<line-17> if LEN1==2:</line-17>
<line-18> return [-1]</line-18>
<line-19> if LEN1==1:</line-19>
<line-20> return [ne]+dfs(ne,S)</line-20>
<line-21> else:</line-21>
<line-22> return [-1]</line-22>
<line-23> </line-23>
<line-24> </line-24>
<line-25>import copy </line-25>
<line-26></line-26>
<line-27>t=int(input())</line-27>
<line-28>for tests in range(t):</line-28>
<line-29> n=int(input())</line-29>
<line-30> A=tuple(set(list(map(int,input().split()))[1:]) for i in range(n-1))</line-30>
<line-31></line-31>
<line-32> for i in range(1,n+1):</line-32>
<line-33> ANS=[i]+dfs(i,copy.deepcopy(A))</line-33>
<line-34> #print(i,ANS)</line-34>
<line-35> if -1 in ANS[:n]:</line-35>
<line-36> continue</line-36>
<line-37> else:</line-37>
<line-38> #print(ANS[:n])</line-38>
<line-39> USE=[0]*(n-1)</line-39>
<line-40></line-40>
<line-41> flag=1</line-41>
<line-42></line-42>
<line-43> for i in range(n-1,0,-1):</line-43>
<line-44> SET=set()</line-44>
<line-45> for j in range(i,-1,-1):</line-45>
<line-46> SET.add(ANS[j])</line-46>
<line-47> if SET in A:</line-47>
<line-48> break</line-48>
<line-49> else:</line-49>
<line-50> flag=0</line-50>
<line-51> break</line-51>
<line-52></line-52>
<line-53> if flag:</line-53>
<line-55> break</line-55>
<line-56> </line-56>
<line-57></line-57>
<line-58> </line-58>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-54> print(*ANS[:n])</line-54>", "lines": [2, 54]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> A = list(map(int, input().split()))</line-3>
<line-4> m = 10 ** 9</line-4>
<line-5> c = 0</line-5>
<line-6> for i in range(n - 1, -1, -1):</line-6>
<line-7> if A[i] <= m:</line-7>
<line-8> m = A[i]</line-8>
<line-9> else:</line-9>
<line-11> print(c)</line-11>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-10> c += 1</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>q = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> s = input()</line-4>
<line-5> t = input()</line-5>
<line-6></line-6>
<line-7> x = set(s)</line-7>
<line-8> y = set(t)</line-8>
<line-9></line-9>
<line-10> if x != y :</line-10>
<line-11> print("NO")</line-11>
<line-12> continue</line-12>
<line-13></line-13>
<line-14> if len(x) == n :</line-14>
<line-15> a = [0] * n</line-15>
<line-16> for i, c in enumerate(t) :</line-16>
<line-17> a[i] = s.find(c)</line-17>
<line-18></line-18>
<line-19> yeet = 0</line-19>
<line-20> vis = [False] * n</line-20>
<line-21> for i in range(n) :</line-21>
<line-22> if vis[i] :</line-22>
<line-23> continue</line-23>
<line-24> j = i</line-24>
<line-25> cyc = 0</line-25>
<line-26> while not vis[j] :</line-26>
<line-27> cyc += 1</line-27>
<line-28> vis[j] = True</line-28>
<line-29> j = a[j]</line-29>
<line-30> # print('>> ', i, cyc)</line-30>
<line-31> yeet += (cyc - 1) % 2</line-31>
<line-32> yeet %= 2</line-32>
<line-33></line-33>
<line-34> if yeet == 0 :</line-34>
<line-35> print("YES")</line-35>
<line-36> else :</line-36>
<line-37> print("NO")</line-37>
<line-39></line-39>
<line-40> print("YES")</line-40>
|
{"code": "<line-2>for _ in range(q) :</line-2>\n<line-38> continue</line-38>", "lines": [2, 38]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> n = int(input())</line-4>
<line-5> </line-5>
<line-6> a = list(map(int, input().split()))</line-6>
<line-7> b = list(map(int, input().split()))</line-7>
<line-8> ma = min(a)</line-8>
<line-9> mb = min(b)</line-9>
<line-10> </line-10>
<line-11> ops = 0</line-11>
<line-12> for xa, xb in zip(a, b):</line-12>
<line-13> da = xa - ma</line-13>
<line-14> db = xb - mb</line-14>
<line-16> </line-16>
<line-17> print(ops)</line-17>
|
{"code": "<line-3>for _ in range(t):</line-3>\n<line-15> ops += max(da, db)</line-15>", "lines": [3, 15]}
#### 0
|
<line-1># @author </line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>class GCandyBoxHardVersion:</line-5>
<line-6> def solve(self):</line-6>
<line-7> q = int(input())</line-7>
<line-8> for _ in range(q):</line-8>
<line-9> n = int(input())</line-9>
<line-10> a = [0] * n</line-10>
<line-11> f = [0] * n</line-11>
<line-12> for i in range(n):</line-12>
<line-13> a[i], f[i] = [int(_) for _ in input().split()]</line-13>
<line-14></line-14>
<line-15> d = {key: [0, 0] for key in a}</line-15>
<line-16> for i in range(n):</line-16>
<line-17> d[a[i]][f[i]] += 1</line-17>
<line-18> rev_d = {sum(key): [] for key in list(d.values())}</line-18>
<line-19> for x in d:</line-19>
<line-20> rev_d[d[x][0] + d[x][1]] += [d[x]]</line-20>
<line-21></line-21>
<line-22> for x in rev_d:</line-22>
<line-23> rev_d[x].sort(key=lambda item:item[1])</line-23>
<line-24></line-24>
<line-25> # print(rev_d)</line-25>
<line-26></line-26>
<line-27> cur = max(rev_d)</line-27>
<line-28> cnt = max(rev_d)</line-28>
<line-29> nb_candies = 0</line-29>
<line-30> given_away = 0</line-30>
<line-31> while 1:</line-31>
<line-32> if cnt == 0 or cur == 0:</line-32>
<line-33> break</line-33>
<line-34> if cur > cnt:</line-34>
<line-35> cur -= 1</line-35>
<line-36> continue</line-36>
<line-37></line-37>
<line-38> if cnt not in rev_d or not rev_d[cnt]:</line-38>
<line-39> cnt -= 1</line-39>
<line-40> continue</line-40>
<line-41></line-41>
<line-42> mx_f = -1</line-42>
<line-43> v = -1</line-43>
<line-44> for max_cnt in range(cur, cnt + 1):</line-44>
<line-45> if max_cnt in rev_d and rev_d[max_cnt] and rev_d[max_cnt][-1][1] > mx_f:</line-45>
<line-46> v = max_cnt</line-46>
<line-47> mx_f = rev_d[max_cnt][-1][1]</line-47>
<line-48> to_take = rev_d[v].pop()</line-48>
<line-49> # rev_d[cnt] -= 1</line-49>
<line-50> nb_candies += cur</line-50>
<line-51> given_away += min(to_take[1], cur)</line-51>
<line-52> cur -= 1</line-52>
<line-53> # rev_d[cnt - cur] += 1</line-53>
<line-54> print(nb_candies, given_away)</line-54>
<line-55></line-55>
<line-56>solver = GCandyBoxHardVersion()</line-56>
<line-58></line-58>
<line-59>solver.solve()</line-59>
|
{"code": "<line-3>import sys</line-3>\n<line-57>input = sys.stdin.readline</line-57>", "lines": [3, 57]}
#### 0
|
<line-1>#!usr/bin/env python3</line-1>
<line-3>from heapq import heappush, heappop</line-3>
<line-4>from itertools import permutations, accumulate</line-4>
<line-5>import sys</line-5>
<line-6>import math</line-6>
<line-7>import bisect</line-7>
<line-8>def LI(): return [int(x) for x in sys.stdin.readline().split()]</line-8>
<line-9>def I(): return int(sys.stdin.readline())</line-9>
<line-10>def LS():return [list(x) for x in sys.stdin.readline().split()]</line-10>
<line-11>def S():</line-11>
<line-12> res = list(sys.stdin.readline())</line-12>
<line-13> if res[-1] == "\n":</line-13>
<line-14> return res[:-1]</line-14>
<line-15> return res</line-15>
<line-16>def IR(n):</line-16>
<line-17> return [I() for i in range(n)]</line-17>
<line-18>def LIR(n):</line-18>
<line-19> return [LI() for i in range(n)]</line-19>
<line-20>def SR(n):</line-20>
<line-21> return [S() for i in range(n)]</line-21>
<line-22>def LSR(n):</line-22>
<line-23> return [LS() for i in range(n)]</line-23>
<line-24></line-24>
<line-25>sys.setrecursionlimit(1000000)</line-25>
<line-26>mod = 1000000007</line-26>
<line-27></line-27>
<line-28>def solve():</line-28>
<line-29> def f(a,b):</line-29>
<line-30> if a == b:</line-30>
<line-31> return len(d[a])</line-31>
<line-32> da = d[a]</line-32>
<line-33> db = d[b]</line-33>
<line-34> res = 0</line-34>
<line-35> for x in range(len(da) >> 1):</line-35>
<line-36> l = da[x]</line-36>
<line-37> r = da[-1-x]</line-37>
<line-38> i = bisect.bisect_left(db,l)</line-38>
<line-39> j = bisect.bisect_left(db,r)</line-39>
<line-40> y = max(0,j-i)</line-40>
<line-41> s = 2*(x+1)+y</line-41>
<line-42> if res < s:</line-42>
<line-43> res = s</line-43>
<line-44> return res</line-44>
<line-45></line-45>
<line-46> t = I()</line-46>
<line-47> for _ in range(t):</line-47>
<line-48> n = I()</line-48>
<line-49> a = LI()</line-49>
<line-50> m = max(a)</line-50>
<line-51> d = [[] for i in range(m)]</line-51>
<line-52> for i in range(n):</line-52>
<line-53> ai = a[i]-1</line-53>
<line-54> d[ai].append(i)</line-54>
<line-55> ans = 1</line-55>
<line-56> for a in range(m):</line-56>
<line-57> if not d[a]:</line-57>
<line-58> continue</line-58>
<line-59> for b in range(m):</line-59>
<line-60> if not d[b]:</line-60>
<line-61> continue</line-61>
<line-62> res = f(a,b)</line-62>
<line-63> if ans < res:</line-63>
<line-64> ans = res</line-64>
<line-65> print(ans)</line-65>
<line-66> return</line-66>
<line-67></line-67>
<line-68>#Solve</line-68>
<line-69>def __starting_point():</line-69>
<line-71></line-71>
<line-72>__starting_point()</line-72>
|
{"code": "<line-2>from collections import defaultdict, deque</line-2>\n<line-70> solve()</line-70>", "lines": [2, 70]}
#### 0
|
<line-1>for __ in range(int(input())):</line-1>
<line-3> ar = list(map(int, input().split()))</line-3>
<line-4> ar.reverse()</line-4>
<line-5> ans = n - 1</line-5>
<line-6> flag = False</line-6>
<line-7> for i in range(1, n):</line-7>
<line-8> if ar[i] < ar[i - 1]:</line-8>
<line-9> flag = True</line-9>
<line-10> if flag:</line-10>
<line-11> if ar[i] > ar[i - 1]:</line-11>
<line-12> break</line-12>
<line-14> print(ans)</line-14>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-13> ans -= 1</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>import math</line-1>
<line-3> n=int(input())</line-3>
<line-4> if n==1:</line-4>
<line-5> print(0)</line-5>
<line-6> else:</line-6>
<line-7> k=int(n**(0.5))</line-7>
<line-8> if k*k<n:</line-8>
<line-9> k+=1</line-9>
<line-10> # print(n,k) </line-10>
<line-11> ans=k-1</line-11>
<line-12> if k*(k-1)>=n:</line-12>
<line-13> ans+=(k-2)</line-13>
<line-14> else:</line-14>
<line-16> print(ans) </line-16>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-15> ans+=(k-1)</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>import sys</line-1>
<line-3> return sys.stdin.readline()[:-1]</line-3>
<line-4></line-4>
<line-5>t = int(input())</line-5>
<line-6>for _ in range(t):</line-6>
<line-7> n, k = map(int, input().split())</line-7>
<line-8> a = list(map(int, input().split()))</line-8>
<line-9> cum = [0 for _ in range(2*k+2)]</line-9>
<line-10> for i in range(n//2):</line-10>
<line-11> x, y = a[i], a[n-i-1]</line-11>
<line-12> cum[2] += 2</line-12>
<line-13> cum[min(x, y)+1] -= 1</line-13>
<line-14> cum[x+y] -= 1</line-14>
<line-15> cum[x+y+1] += 1</line-15>
<line-16> cum[max(x, y)+k+1] += 1</line-16>
<line-17> cum[2*k+1] -= 2</line-17>
<line-18> ans = n</line-18>
<line-19> for i in range(2, 2*k+1):</line-19>
<line-20> cum[i] += cum[i-1]</line-20>
<line-22> print(ans)</line-22>
|
{"code": "<line-2>def input():</line-2>\n<line-21>\t\tans = min(ans, cum[i])</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>ans = []</line-1>
<line-3> n = int(input())</line-3>
<line-4> s = list(input())</line-4>
<line-5> t = list(input())</line-5>
<line-6> lvl = 0</line-6>
<line-7> X = [s, t]</line-7>
<line-8> f = 1</line-8>
<line-9> for i in range(n):</line-9>
<line-10> if s[i] in '3456' and t[i] in '3456':</line-10>
<line-11> lvl = 1 - lvl</line-11>
<line-12> elif X[lvl][i] in '3456':</line-12>
<line-13> f = 0</line-13>
<line-14> ans.append('NO')</line-14>
<line-15> break</line-15>
<line-16> if f and lvl == 1:</line-16>
<line-17> ans.append('YES')</line-17>
<line-18> elif f:</line-18>
<line-20>print('\n'.join(ans))</line-20>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-19> ans.append('NO')</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>from operator import itemgetter</line-1>
<line-3>input = sys.stdin.readline</line-3>
<line-4></line-4>
<line-5>MAX_A = 200</line-5>
<line-6>t = int(input())</line-6>
<line-7></line-7>
<line-8>for _ in range(t):</line-8>
<line-9> n = int(input())</line-9>
<line-10> a = list(map(int, input().split()))</line-10>
<line-11> </line-11>
<line-12> ruiseki = [[0] * MAX_A for i in range(n + 1)]</line-12>
<line-13> for i in range(n):</line-13>
<line-14> for j in range(MAX_A):</line-14>
<line-15> ruiseki[i + 1][j] = ruiseki[i][j]</line-15>
<line-16> if a[i] - 1 == j:</line-16>
<line-17> ruiseki[i + 1][j] += 1</line-17>
<line-18></line-18>
<line-19> ans = 0</line-19>
<line-20> for num in set(a):</line-20>
<line-21> l = 0</line-21>
<line-22> r = n - 1</line-22>
<line-23> cnt = 0</line-23>
<line-24> while True:</line-24>
<line-25> while True:</line-25>
<line-26> if a[l] != num:</line-26>
<line-27> l += 1</line-27>
<line-28> else:</line-28>
<line-29> break</line-29>
<line-30> while True:</line-30>
<line-31> if a[r] != num:</line-31>
<line-32> r -= 1</line-32>
<line-33> else:</line-33>
<line-34> break</line-34>
<line-35> if l == r:</line-35>
<line-36> ans = max(ans, cnt + 1)</line-36>
<line-37> break</line-37>
<line-38> elif l > r:</line-38>
<line-39> break</line-39>
<line-40> cnt += 1</line-40>
<line-41> tmp_max = 0</line-41>
<line-42> for j in range(MAX_A):</line-42>
<line-43> tmp_max = max(tmp_max, ruiseki[r][j] - ruiseki[l + 1][j])</line-43>
<line-44> ans = max(ans, cnt * 2 + tmp_max)</line-44>
<line-45> l += 1</line-45>
<line-47> print(ans)</line-47>
|
{"code": "<line-2>import sys</line-2>\n<line-46> r -= 1</line-46>", "lines": [2, 46]}
#### 0
|
<line-1>from bisect import bisect_left as bl</line-1>
<line-3>from heapq import heappush,heappop,heapify</line-3>
<line-4>import math</line-4>
<line-5>from collections import *</line-5>
<line-6>from functools import reduce,cmp_to_key</line-6>
<line-7>import sys</line-7>
<line-8>input = sys.stdin.readline</line-8>
<line-9>M = mod = 998244353</line-9>
<line-10>def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))</line-10>
<line-11>def inv_mod(n):return pow(n, mod - 2, mod)</line-11>
<line-12> </line-12>
<line-13>def li():return [int(i) for i in input().rstrip('\n').split()]</line-13>
<line-14>def st():return input().rstrip('\n')</line-14>
<line-15>def val():return int(input().rstrip('\n'))</line-15>
<line-16>def li2():return [i for i in input().rstrip('\n')]</line-16>
<line-17>def li3():return [int(i) for i in input().rstrip('\n')]</line-17>
<line-18></line-18>
<line-19>for _ in range(val()):</line-19>
<line-20> n, k = li()</line-20>
<line-21> d = defaultdict(set)</line-21>
<line-22> for i in range(n-1):</line-22>
<line-23> a, b = li()</line-23>
<line-24> d[a].add(b)</line-24>
<line-25> d[b].add(a)</line-25>
<line-26> thistime = 1</line-26>
<line-27> he = deque()</line-27>
<line-28> visited = {}</line-28>
<line-29> for i in d:</line-29>
<line-30> if len(d[i]) == 1:</line-30>
<line-31> visited[i] = 1</line-31>
<line-32> he.append(i)</line-32>
<line-33> ans = 0</line-33>
<line-34> counts = defaultdict(int)</line-34>
<line-35> # print(he)</line-35>
<line-36></line-36>
<line-37> while he:</line-37>
<line-38> i = he.popleft()</line-38>
<line-39> for j in list(d[i]):</line-39>
<line-40> counts[j] += 1</line-40>
<line-41> d[i].remove(j)</line-41>
<line-42> d[j].remove(i)</line-42>
<line-43> if counts[j] == k:</line-43>
<line-44> thistime = 1</line-44>
<line-45> ans += 1</line-45>
<line-46> counts[j] = 0</line-46>
<line-47> if len(d[j]) == 1:</line-47>
<line-48> if j not in visited:he.append(j)</line-48>
<line-49> visited[j] = 1</line-49>
<line-51> print(ans)</line-51>
|
{"code": "<line-2>from bisect import bisect_right as br</line-2>\n<line-50> # print(j, he)</line-50>", "lines": [2, 50]}
#### 0
|
<line-1>import sys</line-1>
<line-3>import bisect</line-3>
<line-4></line-4>
<line-5>t=int(input())</line-5>
<line-6>for tests in range(t):</line-6>
<line-7> n=int(input())</line-7>
<line-8> A=list(map(int,input().split()))</line-8>
<line-9></line-9>
<line-10> compression_dict={a: ind for ind, a in enumerate(sorted(set(A)))}</line-10>
<line-11> A=[compression_dict[a] for a in A]</line-11>
<line-12></line-12>
<line-13> Q=[0]*n</line-13>
<line-14> </line-14>
<line-15> for i in range(n):</line-15>
<line-16> Q[A[i]]=i</line-16>
<line-17> </line-17>
<line-18> count=1</line-18>
<line-19> Ans=0</line-19>
<line-20> #print(A,Q)</line-20>
<line-21> for i in range(1,n):</line-21>
<line-22> if Q[i]>Q[i-1]:</line-22>
<line-23> count+=1</line-23>
<line-24> else:</line-24>
<line-25> Ans=max(count,Ans)</line-25>
<line-26> count=1</line-26>
<line-27></line-27>
<line-29> </line-29>
<line-30> print(n-Ans)</line-30>
<line-31></line-31>
<line-32> </line-32>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-28> Ans=max(count,Ans)</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3> s = input()</line-3>
<line-4> l,r,u,d = [s.count(i) for i in 'LRUD']</line-4>
<line-5> lr = min(l, r)</line-5>
<line-6> ud = min(u, d)</line-6>
<line-7> res = ""</line-7>
<line-8> if lr == 0 and ud == 0:</line-8>
<line-9> res = ""</line-9>
<line-10> elif lr == 0:</line-10>
<line-11> res = "UD"</line-11>
<line-12> elif ud == 0:</line-12>
<line-13> res = 'LR'</line-13>
<line-14> else:</line-14>
<line-15> res = 'R' * lr + 'U' * ud + 'L' * lr + 'D' * ud</line-15>
<line-17> print(res)</line-17>
|
{"code": "<line-2>for _ in range(n):</line-2>\n<line-16> print(len(res))</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>#t=1</line-5>
<line-6>t=int(input())</line-6>
<line-7>for _ in range(t):</line-7>
<line-8> n=int(input())</line-8>
<line-9> s=input().rstrip()</line-9>
<line-10> s=[s[-i-1] for i in range(n)]</line-10>
<line-11> ans=[]</line-11>
<line-12> zero=[]</line-12>
<line-13> one=[]</line-13>
<line-14> res=[-1]*n</line-14>
<line-15> pos=0</line-15>
<line-16> while s:</line-16>
<line-17> b=s.pop()</line-17>
<line-18> if b=="0":</line-18>
<line-19> if not one:</line-19>
<line-20> new=1</line-20>
<line-21> ans.append(new)</line-21>
<line-22> res[pos]=len(ans)</line-22>
<line-23> zero.append(len(ans)-1)</line-23>
<line-24> else:</line-24>
<line-25> id=one.pop()</line-25>
<line-26> ans[id]+=1</line-26>
<line-27> res[pos]=id+1</line-27>
<line-28> zero.append(id)</line-28>
<line-29> else:</line-29>
<line-30> if not zero:</line-30>
<line-31> new=1</line-31>
<line-32> ans.append(new)</line-32>
<line-33> res[pos]=len(ans)</line-33>
<line-34> one.append(len(ans)-1)</line-34>
<line-35> else:</line-35>
<line-36> id=zero.pop()</line-36>
<line-37> ans[id]+=1</line-37>
<line-38> res[pos]=id+1</line-38>
<line-39> one.append(id)</line-39>
<line-40> pos+=1</line-40>
<line-42> print(*res)</line-42>
|
{"code": "<line-3>input=sys.stdin.readline</line-3>\n<line-41> print(len(ans))</line-41>", "lines": [3, 41]}
#### 0
|
<line-1>import sys</line-1>
<line-3>rInt = lambda: int(input())</line-3>
<line-4>mInt = lambda: map(int, input().split())</line-4>
<line-5>rLis = lambda: list(map(int, input().split()))</line-5>
<line-6></line-6>
<line-7>outs = []</line-7>
<line-8></line-8>
<line-9>t = rInt()</line-9>
<line-10>for _ in range(t):</line-10>
<line-11> n, k = mInt()</line-11>
<line-12> s = input()</line-12>
<line-13></line-13>
<line-14> pref = [0]</line-14>
<line-15> for c in s:</line-15>
<line-16> if c == '1':</line-16>
<line-17> pref.append(pref[-1] + 1)</line-17>
<line-18> else:</line-18>
<line-19> pref.append(pref[-1])</line-19>
<line-20></line-20>
<line-21> best = pref[-1]</line-21>
<line-22></line-22>
<line-23> dp = []</line-23>
<line-24> for i in range(n):</line-24>
<line-25> cost = pref[i]</line-25>
<line-26> if i >= k:</line-26>
<line-27> case2 = dp[i - k] + pref[i] - pref[i - k + 1]</line-27>
<line-28> if case2 < cost:</line-28>
<line-29> cost = case2</line-29>
<line-30> if s[i] == '0':</line-30>
<line-31> cost += 1</line-31>
<line-32></line-32>
<line-33> dp.append(cost)</line-33>
<line-34> actual = cost + pref[-1] - pref[i + 1]</line-34>
<line-35> if actual < best:</line-35>
<line-36> best = actual</line-36>
<line-37></line-37>
<line-39></line-39>
<line-40></line-40>
<line-41>print(*outs, sep = '\n')</line-41>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-38> outs.append(best)</line-38>", "lines": [2, 38]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> prev=0</line-3>
<line-4> ma=-1</line-4>
<line-5> for i in range(1,len(s)):</line-5>
<line-6> if s[i]=='R':</line-6>
<line-7> ma=max(ma,i-prev)</line-7>
<line-9> print(ma) </line-9>
<line-10> </line-10>
|
{"code": "<line-2> s='R' + input() + 'R'</line-2>\n<line-8> prev=i</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>def isvalid(s):</line-1>
<line-3> for i in l:</line-3>
<line-4> count=0</line-4>
<line-5> for j in range(len(i)):</line-5>
<line-6> if(s[j]!=i[j]):</line-6>
<line-7> count+=1</line-7>
<line-8> if(count>1):</line-8>
<line-9> return 0</line-9>
<line-10> return 1</line-10>
<line-11>t=int(input())</line-11>
<line-12>for you in range(t):</line-12>
<line-13> l=input().split()</line-13>
<line-14> n=int(l[0])</line-14>
<line-15> m=int(l[1])</line-15>
<line-16> l=[]</line-16>
<line-17> for i in range(n):</line-17>
<line-18> s=input()</line-18>
<line-19> l.append(s)</line-19>
<line-20> poss=0</line-20>
<line-21> ans=0</line-21>
<line-22> for i in range(m):</line-22>
<line-23> copy=[x for x in l[0]]</line-23>
<line-24> for j in range(26):</line-24>
<line-25> copy[i]=chr(97+j)</line-25>
<line-26> if(isvalid(copy)):</line-26>
<line-27> poss=1</line-27>
<line-28> ans=copy</line-28>
<line-29> break</line-29>
<line-30> if(poss==1):</line-30>
<line-31> break</line-31>
<line-32> if(poss):</line-32>
<line-33> for i in ans:</line-33>
<line-34> print(i,end="")</line-34>
<line-35> print()</line-35>
<line-37> print(-1)</line-37>
|
{"code": "<line-2> nonlocal l</line-2>\n<line-36> else:</line-36>", "lines": [2, 36]}
#### 0
|
<line-1></line-1>
<line-3></line-3>
<line-4>for _ in range(T):</line-4>
<line-5> a, b = list(map(int, input().split()))</line-5>
<line-6> print(max(max(a, b), min(a, b) * 2)**2)</line-6>
|
{"code": "<line-2>T = int(input())</line-2>", "lines": [2]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-3> n = int(input())</line-3>
<line-4> l = list(map(int,input().split()))</line-4>
<line-5> id = list(zip(l,list(range(n))))</line-5>
<line-6> id.sort()</line-6>
<line-7> val, pos = zip(*id)</line-7>
<line-8> blok = []</line-8>
<line-9> cur = [pos[0]]</line-9>
<line-10> for i in range(1,n):</line-10>
<line-11> if val[i] == val[i-1]:</line-11>
<line-12> cur.append(pos[i])</line-12>
<line-13> else:</line-13>
<line-14> cur.sort()</line-14>
<line-15> blok.append(cur)</line-15>
<line-16> cur = [pos[i]]</line-16>
<line-17> cur.sort()</line-17>
<line-18> blok.append(cur)</line-18>
<line-19> best = 0</line-19>
<line-20> m = len(blok)</line-20>
<line-21> for j in range(m):</line-21>
<line-22> best = max(len(blok[j]), best)</line-22>
<line-23> i = 0</line-23>
<line-24> while True:</line-24>
<line-25> if i >= m-2:</line-25>
<line-26> break</line-26>
<line-27> cyk = min(blok[i+1])</line-27>
<line-28> j = -1</line-28>
<line-29> while j+1 < len(blok[i]) and blok[i][j+1] < cyk:</line-29>
<line-30> j += 1</line-30>
<line-31> su = (j+1)</line-31>
<line-32> ii = i+2</line-32>
<line-33> while ii < m:</line-33>
<line-34> if min(blok[ii]) > max(blok[ii-1]):</line-34>
<line-35> su += len(blok[ii-1])</line-35>
<line-36> ii += 1</line-36>
<line-37> else:</line-37>
<line-38> break</line-38>
<line-39> if ii == m:</line-39>
<line-40> su += len(blok[-1])</line-40>
<line-41> best = max(best, su)</line-41>
<line-42> else:</line-42>
<line-43> xxx = max(blok[ii-1])</line-43>
<line-44> su += len(blok[ii-1])</line-44>
<line-45> inde = len(blok[ii])-1</line-45>
<line-46> while inde >= 0 and blok[ii][inde] >= xxx:</line-46>
<line-47> su += 1</line-47>
<line-48> inde -= 1</line-48>
<line-49> best = max(best,su)</line-49>
<line-50> i = max(i+1, ii-1)</line-50>
<line-51> for i in range(1,m):</line-51>
<line-52> b1 = blok[i];b0 = blok[i-1];l0,l1,i1 = len(b0),len(b1),0</line-52>
<line-53> for ind in range(l0):</line-53>
<line-54> while True:</line-54>
<line-55> if i1 < l1 and b1[i1] <= b0[ind]:i1 += 1</line-55>
<line-56> else:break</line-56>
<line-57> if l1 == i1:break</line-57>
<line-59> print(n-best)</line-59>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-58> best = max(best, (ind+1)+(l1-i1))</line-58>", "lines": [2, 58]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>def search(i,j):</line-4>
<line-5> L=[]</line-5>
<line-6></line-6>
<line-7> c=0</line-7>
<line-8></line-8>
<line-9> while CHECK[i][j]==1<<30:</line-9>
<line-10> L.append((i,j))</line-10>
<line-11> </line-11>
<line-12> CHECK[i][j]=c</line-12>
<line-13></line-13>
<line-14> if MAP2[i][j]=="U":</line-14>
<line-15> i-=1</line-15>
<line-16> elif MAP2[i][j]=="D":</line-16>
<line-17> i+=1</line-17>
<line-18> elif MAP2[i][j]=="R":</line-18>
<line-19> j+=1</line-19>
<line-20> else:</line-20>
<line-21> j-=1</line-21>
<line-22></line-22>
<line-23> c+=1</line-23>
<line-24></line-24>
<line-25> if (i,j) in L:</line-25>
<line-26> x=CHECK[i][j]</line-26>
<line-27> y=CHECK[L[-1][0]][L[-1][1]]</line-27>
<line-28> loop=abs(x-y)+1</line-28>
<line-29></line-29>
<line-30> for x,y in L:</line-30>
<line-31> CHECK[x][y]%=loop</line-31>
<line-32> LOOP[x][y]=loop</line-32>
<line-33></line-33>
<line-34> else:</line-34>
<line-35> loop=LOOP[i][j]</line-35>
<line-36> c=CHECK[i][j]</line-36>
<line-37></line-37>
<line-38> for x,y in L[::-1]:</line-38>
<line-39> c=(c-1)%loop</line-39>
<line-40> CHECK[x][y]=c</line-40>
<line-41> LOOP[x][y]=loop</line-41>
<line-42></line-42>
<line-43>def search2(i,j):</line-43>
<line-44> Q=[(i,j)]</line-44>
<line-45> ANS=[0]*LOOP[i][j]</line-45>
<line-46></line-46>
<line-47> while Q:</line-47>
<line-48> x,y=Q.pop()</line-48>
<line-49></line-49>
<line-50> if USE[x][y]==1:</line-50>
<line-51> continue</line-51>
<line-52> </line-52>
<line-53> USE[x][y]=1</line-53>
<line-54> if MAP[x][y]=="0":</line-54>
<line-55> ANS[CHECK[x][y]]=1</line-55>
<line-56></line-56>
<line-57> if MAP2[x][y]=="U":</line-57>
<line-58> Q.append((x-1,y))</line-58>
<line-59> elif MAP2[x][y]=="D":</line-59>
<line-60> Q.append((x+1,y))</line-60>
<line-61> elif MAP2[x][y]=="R":</line-61>
<line-62> Q.append((x,y+1))</line-62>
<line-63> else:</line-63>
<line-64> Q.append((x,y-1))</line-64>
<line-65></line-65>
<line-66></line-66>
<line-67> if 0<=x+1<n and 0<=y<m and MAP2[x+1][y]=="U":</line-67>
<line-68> Q.append((x+1,y))</line-68>
<line-69> </line-69>
<line-70> if 0<=x-1<n and 0<=y<m and MAP2[x-1][y]=="D":</line-70>
<line-71> Q.append((x-1,y))</line-71>
<line-72> </line-72>
<line-73> if 0<=x<n and 0<=y+1<m and MAP2[x][y+1]=="L":</line-73>
<line-74> Q.append((x,y+1))</line-74>
<line-75> </line-75>
<line-76> if 0<=x<n and 0<=y-1<m and MAP2[x][y-1]=="R":</line-76>
<line-77> Q.append((x,y-1))</line-77>
<line-78></line-78>
<line-79> return LOOP[i][j],sum(ANS)</line-79>
<line-80></line-80>
<line-81></line-81>
<line-82>t=int(input())</line-82>
<line-83>for tests in range(t):</line-83>
<line-84> n,m=list(map(int,input().split()))</line-84>
<line-85> MAP=[input().strip() for i in range(n)]</line-85>
<line-86> MAP2=[input().strip() for i in range(n)]</line-86>
<line-87></line-87>
<line-88> CHECK=[[1<<30]*m for i in range(n)]</line-88>
<line-89> LOOP=[[1<<30]*m for i in range(n)]</line-89>
<line-90></line-90>
<line-91> for i in range(n):</line-91>
<line-92> for j in range(m):</line-92>
<line-93> if CHECK[i][j]==1<<30:</line-93>
<line-94> search(i,j)</line-94>
<line-95></line-95>
<line-96> #print(i,j)</line-96>
<line-97></line-97>
<line-98> #print(CHECK)</line-98>
<line-99> #print(LOOP)</line-99>
<line-100></line-100>
<line-101> USE=[[0]*m for i in range(n)]</line-101>
<line-102></line-102>
<line-103> ANSM=0</line-103>
<line-104> ANSC=0</line-104>
<line-105></line-105>
<line-106> for i in range(n):</line-106>
<line-107> for j in range(m):</line-107>
<line-108> if USE[i][j]==0:</line-108>
<line-109> x,y=search2(i,j)</line-109>
<line-110> ANSM+=x</line-110>
<line-112> print(ANSM,ANSC)</line-112>
<line-113> </line-113>
<line-114> </line-114>
<line-115> </line-115>
<line-116> </line-116>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-111> ANSC+=y</line-111>", "lines": [2, 111]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> n = int(input())</line-4>
<line-6> print(*set(a))</line-6>
|
{"code": "<line-3>for _ in range(t):</line-3>\n<line-5> a = list(map(int, input().split()))</line-5>", "lines": [3, 5]}
#### 0
|
<line-1>import math</line-1>
<line-3>import heapq</line-3>
<line-4>import copy</line-4>
<line-5>import heapq</line-5>
<line-6>from collections import deque</line-6>
<line-7>def na():</line-7>
<line-8> n = int(input())</line-8>
<line-9> b = [int(x) for x in input().split()]</line-9>
<line-10> return n,b</line-10>
<line-11> </line-11>
<line-12> </line-12>
<line-13>def nab():</line-13>
<line-14> n = int(input())</line-14>
<line-15> b = [int(x) for x in input().split()]</line-15>
<line-16> c = [int(x) for x in input().split()]</line-16>
<line-17> return n,b,c</line-17>
<line-18> </line-18>
<line-19> </line-19>
<line-20>def dv():</line-20>
<line-21> n, m = list(map(int, input().split()))</line-21>
<line-22> return n,m</line-22>
<line-23> </line-23>
<line-24> </line-24>
<line-25>def da():</line-25>
<line-26> n, m = list(map(int, input().split()))</line-26>
<line-27> a = list(map(int, input().split()))</line-27>
<line-28> return n,m, a </line-28>
<line-29> </line-29>
<line-30> </line-30>
<line-31>def dva():</line-31>
<line-32> </line-32>
<line-33> n, m = list(map(int, input().split()))</line-33>
<line-34> a = [int(x) for x in input().split()]</line-34>
<line-35> b = [int(x) for x in input().split()]</line-35>
<line-36> return n,m,b</line-36>
<line-37> </line-37>
<line-38> </line-38>
<line-39>def eratosthenes(n): </line-39>
<line-40> sieve = list(range(n + 1))</line-40>
<line-41> for i in sieve:</line-41>
<line-42> if i > 1:</line-42>
<line-43> for j in range(i + i, len(sieve), i):</line-43>
<line-44> sieve[j] = 0</line-44>
<line-45> return sorted(set(sieve))</line-45>
<line-46> </line-46>
<line-47> </line-47>
<line-48>def lol(lst,k):</line-48>
<line-49> k=k%len(lst)</line-49>
<line-50> ret=[0]*len(lst)</line-50>
<line-51> for i in range(len(lst)):</line-51>
<line-52> if i+k<len(lst) and i+k>=0:</line-52>
<line-53> ret[i]=lst[i+k]</line-53>
<line-54> if i+k>=len(lst):</line-54>
<line-55> ret[i]=lst[i+k-len(lst)]</line-55>
<line-56> if i+k<0:</line-56>
<line-57> ret[i]=lst[i+k+len(lst)]</line-57>
<line-58> return(ret)</line-58>
<line-59>def nm():</line-59>
<line-60> n = int(input())</line-60>
<line-61> b = [int(x) for x in input().split()]</line-61>
<line-62> m = int(input())</line-62>
<line-63> c = [int(x) for x in input().split()]</line-63>
<line-64> return n,b,m,c</line-64>
<line-65> </line-65>
<line-66> </line-66>
<line-67>def dvs():</line-67>
<line-68> n = int(input())</line-68>
<line-69> m = int(input())</line-69>
<line-70> return n, m </line-70>
<line-71> </line-71>
<line-72></line-72>
<line-73>def fact(n):</line-73>
<line-74> tc = []</line-74>
<line-75> ans = {}</line-75>
<line-76> d = 2</line-76>
<line-77> while d * d <= n:</line-77>
<line-78> if n % d == 0:</line-78>
<line-79> tc.append(d)</line-79>
<line-80> n //= d</line-80>
<line-81> else:</line-81>
<line-82> d += 1</line-82>
<line-83> if n > 1:</line-83>
<line-84> tc.append(n)</line-84>
<line-85> for i in tc:</line-85>
<line-86> ans[i] = ans.get(i, 0) + 1</line-86>
<line-87> return ans</line-87>
<line-88></line-88>
<line-89></line-89>
<line-90>for i in range(int(input())):</line-90>
<line-91> s = int(input())</line-91>
<line-92> ans = 0</line-92>
<line-93> while s >= 10:</line-93>
<line-94> d = s // 10</line-94>
<line-95> ans += d * 10</line-95>
<line-96> s += d</line-96>
<line-97> s -= d * 10</line-97>
<line-99> print(ans)</line-99>
|
{"code": "<line-2>from decimal import Decimal</line-2>\n<line-98>\tans += s</line-98>", "lines": [2, 98]}
#### 0
|
<line-1>import sys</line-1>
<line-3>T = int(input())</line-3>
<line-4>for _ in range(T):</line-4>
<line-5> N, M = list(map(int, input().split()))</line-5>
<line-6> E = [[] for aa in range(N)]</line-6>
<line-7> for __ in range(M):</line-7>
<line-8> a, b = list(map(int, input().split()))</line-8>
<line-9> E[a-1].append(b-1)</line-9>
<line-10> E[b-1].append(a-1)</line-10>
<line-11> </line-11>
<line-12> D = [-1] * N</line-12>
<line-13> D[0] = 0</line-13>
<line-14> d = 0</line-14>
<line-15> post = [0]</line-15>
<line-16> EVEN = [1]</line-16>
<line-17> ODD = []</line-17>
<line-18> while post:</line-18>
<line-19> d += 1</line-19>
<line-20> pre = post</line-20>
<line-21> post = []</line-21>
<line-22> for i in pre:</line-22>
<line-23> for e in E[i]:</line-23>
<line-24> if D[e] < 0:</line-24>
<line-25> D[e] = d</line-25>
<line-26> post.append(e)</line-26>
<line-27> if d % 2:</line-27>
<line-28> ODD.append(e+1)</line-28>
<line-29> else:</line-29>
<line-30> EVEN.append(e+1)</line-30>
<line-31> if len(ODD) < len(EVEN):</line-31>
<line-32> print(len(ODD))</line-32>
<line-33> print(*ODD)</line-33>
<line-34> else:</line-34>
<line-36> print(*EVEN)</line-36>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-35> print(len(EVEN))</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-3></line-3>
<line-4>rgb = 'RGB'</line-4>
<line-5></line-5>
<line-6>for query in range(int(stdin.readline())):</line-6>
<line-7> n, k = list(map(int, stdin.readline().split()))</line-7>
<line-8> s = stdin.readline()</line-8>
<line-9></line-9>
<line-10> ans = math.inf</line-10>
<line-11> for start in range(3):</line-11>
<line-12> dp = [0 for i in range(n + 1)] </line-12>
<line-13> for i in range(n):</line-13>
<line-14> cur = rgb[(start + i) % len(rgb)]</line-14>
<line-15> dp[i + 1] = dp[i] + int(s[i] != cur)</line-15>
<line-16> for i in range(n - k + 1):</line-16>
<line-18> print(ans)</line-18>
<line-19></line-19>
<line-20></line-20>
|
{"code": "<line-2>import math</line-2>\n<line-17> ans = min(ans, dp[i + k] - dp[i])</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>Q = int(input())</line-4>
<line-5>for _ in range(Q):</line-5>
<line-6> N = int(input())</line-6>
<line-7> A = [int(a) for a in input().split()]</line-7>
<line-8> X = {}</line-8>
<line-9> for a in A:</line-9>
<line-10> if a in X:</line-10>
<line-11> X[a] += 1</line-11>
<line-12> else:</line-12>
<line-13> X[a] = 1</line-13>
<line-14> Y = []</line-14>
<line-15> for x in X:</line-15>
<line-16> Y.append(X[x])</line-16>
<line-17> Y = sorted(Y)[::-1]</line-17>
<line-18> prev = Y[0] + 1</line-18>
<line-19> su = 0</line-19>
<line-20> for i in range(len(Y)):</line-20>
<line-21> ne = min(prev-1, Y[i])</line-21>
<line-22> if ne <= 0:</line-22>
<line-23> break</line-23>
<line-24> su += ne</line-24>
<line-26> print(su)</line-26>
<line-27></line-27>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-25> prev = ne</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> l = list([int(x)- 1 for x in input().split()])</line-4>
<line-5> out = []</line-5>
<line-6></line-6>
<line-7> ll = [(l[i], i) for i in range(n)]</line-7>
<line-8> ll.sort()</line-8>
<line-9></line-9>
<line-10> swap = (-1,-1)</line-10>
<line-11> for i in range(n - 1):</line-11>
<line-12> if ll[i][0] == ll[i + 1][0]:</line-12>
<line-13> swap = (ll[i][1],ll[i+1][1])</line-13>
<line-14></line-14>
<line-15> newl = [0]*n</line-15>
<line-16> for i in range(n):</line-16>
<line-17> newl[ll[i][1]] = i</line-17>
<line-18></line-18>
<line-19> l = newl</line-19>
<line-20></line-20>
<line-21> swapN = 0</line-21>
<line-22> for i in range(n):</line-22>
<line-23> for j in range(i + 1, n):</line-23>
<line-24> if l[i] > l[j]:</line-24>
<line-25> swapN += 1</line-25>
<line-26></line-26>
<line-27> #print(l)</line-27>
<line-28> if swapN & 1:</line-28>
<line-29> l[swap[0]],l[swap[1]] = l[swap[1]],l[swap[0]]</line-29>
<line-30> #print(l)</line-30>
<line-31></line-31>
<line-32> def shift(i):</line-32>
<line-33> out.append(i + 1)</line-33>
<line-34> l[i],l[i+1],l[i+2] = l[i+2],l[i],l[i+1]</line-34>
<line-35></line-35>
<line-36> works = True</line-36>
<line-37> done = False</line-37>
<line-38></line-38>
<line-39> while not done:</line-39>
<line-40> </line-40>
<line-41> for i in range(n):</line-41>
<line-42> if l[i] != i:</line-42>
<line-43> break</line-43>
<line-44> else:</line-44>
<line-45> done = True</line-45>
<line-46></line-46>
<line-47> if done:</line-47>
<line-48> break</line-48>
<line-49></line-49>
<line-50> for find in range(i + 1, n):</line-50>
<line-51> if l[find] == i:</line-51>
<line-52> break</line-52>
<line-53></line-53>
<line-54> while find - i >= 2:</line-54>
<line-55> find -= 2</line-55>
<line-56> shift(find)</line-56>
<line-57></line-57>
<line-58> if find - i == 1:</line-58>
<line-59> if find <= n - 2:</line-59>
<line-60> shift(find - 1)</line-60>
<line-61> shift(find - 1)</line-61>
<line-62> else:</line-62>
<line-63> works = False</line-63>
<line-64> break</line-64>
<line-65></line-65>
<line-66> #print(l)</line-66>
<line-67> if works:</line-67>
<line-68> print(len(out))</line-68>
<line-69> print(' '.join(map(str,out)))</line-69>
<line-70> else:</line-70>
<line-72> #print('---')</line-72>
<line-73> </line-73>
<line-74> </line-74>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-71> print(-1)</line-71>", "lines": [2, 71]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> A = []</line-3>
<line-4> x = 1</line-4>
<line-5> while True:</line-5>
<line-6> if (m * x) % 10 not in A:</line-6>
<line-7> A.append((m * x) % 10)</line-7>
<line-8> else:</line-8>
<line-9> break</line-9>
<line-10> x += 1</line-10>
<line-11> s = sum(A)</line-11>
<line-13> print(s * (n // len(A)) + sum(A[:n % len(A)]))</line-13>
|
{"code": "<line-2> n, m = list(map(int, input().split()))</line-2>\n<line-12> n //= m</line-12>", "lines": [2, 12]}
#### 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 = read_int()</line-11>
<line-12> mat = []</line-12>
<line-13> for i in range(n):</line-13>
<line-14> mat.append(input())</line-14>
<line-15> ok = True</line-15>
<line-16> for i in range(n):</line-16>
<line-17> for j in range(n):</line-17>
<line-18> if mat[i][j] == '0':</line-18>
<line-19> continue</line-19>
<line-20> cok = j == n - 1 or i == n - 1</line-20>
<line-21> if not cok:</line-21>
<line-22> cok = mat[i][j + 1] == '1' or mat[i + 1][j] == '1'</line-22>
<line-23> if not cok:</line-23>
<line-24> ok = False</line-24>
<line-25> break</line-25>
<line-26> if not ok:</line-26>
<line-28> print('YES' if ok else 'NO')</line-28>
|
{"code": "<line-2> return int(input())</line-2>\n<line-27> break</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> s = input()</line-3>
<line-4> st = 0</line-4>
<line-5> fans = 0</line-5>
<line-6> for x in s:</line-6>
<line-7> if x == ')':</line-7>
<line-8> st -= 1</line-8>
<line-9> else:</line-9>
<line-10> st += 1</line-10>
<line-11> if st < 0:</line-11>
<line-12> fans += 1</line-12>
<line-14> print(fans)</line-14>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-13> st = 0</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> s=input()</line-3>
<line-4> a=""</line-4>
<line-5> b=""</line-5>
<line-6> flag=1</line-6>
<line-7> for i in s:</line-7>
<line-8> if flag:</line-8>
<line-9> if i=="2":</line-9>
<line-10> a+="1"</line-10>
<line-11> b+="1"</line-11>
<line-12> elif i=="1":</line-12>
<line-13> a+="1"</line-13>
<line-14> b+="0"</line-14>
<line-15> flag=0</line-15>
<line-16> else:</line-16>
<line-17> a+="0"</line-17>
<line-18> b+="0"</line-18>
<line-19> else:</line-19>
<line-20> if i=="2":</line-20>
<line-21> a+="0"</line-21>
<line-22> b+="2"</line-22>
<line-23> elif i=="1":</line-23>
<line-24> a+="0"</line-24>
<line-25> b+="1"</line-25>
<line-26> flag=0</line-26>
<line-27> else:</line-27>
<line-28> a+="0"</line-28>
<line-29> b+="0"</line-29>
<line-31> print(b)</line-31>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-30> print(a)</line-30>", "lines": [2, 30]}
#### 0
|
<line-1># coding: utf-8</line-1>
<line-3></line-3>
<line-4>def solve(s, c):</line-4>
<line-5> if(len(s)==1):</line-5>
<line-6> if s[0]==c:</line-6>
<line-7> return 0</line-7>
<line-8> else:</line-8>
<line-9> return 1</line-9>
<line-10> ans1 = sum([i!=c for i in s[:len(s)//2]]) + solve(s[len(s)//2:],chr(ord(c)+1))</line-10>
<line-11> ans2 = sum([i!=c for i in s[len(s)//2:]]) + solve(s[:len(s)//2],chr(ord(c)+1))</line-11>
<line-12> return min(ans1, ans2)</line-12>
<line-13> </line-13>
<line-14> </line-14>
<line-15>for _ in range(int(input())):</line-15>
<line-17> print(solve(input(),'a'))</line-17>
|
{"code": "<line-2># Your code here!</line-2>\n<line-16> input()</line-16>", "lines": [2, 16]}
#### 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, m = read_ints()</line-11>
<line-12> a = []</line-12>
<line-13> for i in range(n):</line-13>
<line-14> a.append(int(input(), 2))</line-14>
<line-15> a.sort()</line-15>
<line-16> k = 2 ** m - n</line-16>
<line-17> ans = (k - 1) // 2</line-17>
<line-18> for ai in a:</line-18>
<line-19> if ai <= ans:</line-19>
<line-20> ans += 1</line-20>
<line-22> print(binary.rjust(m, '0'))</line-22>
|
{"code": "<line-2> return int(input())</line-2>\n<line-21> binary = '{:b}'.format(ans)</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>int1 = lambda x: int(x) - 1</line-4>
<line-5>p2D = lambda x: print(*x, sep="\n")</line-5>
<line-6>def II(): return int(sys.stdin.readline())</line-6>
<line-7>def MI(): return map(int, sys.stdin.readline().split())</line-7>
<line-8>def LI(): return list(map(int, sys.stdin.readline().split()))</line-8>
<line-9>def LLI(rows_number): return [LI() for _ in range(rows_number)]</line-9>
<line-10>def SI(): return sys.stdin.readline()[:-1]</line-10>
<line-11></line-11>
<line-12>def maketo():</line-12>
<line-13> atoi=[[] for _ in range(n)]</line-13>
<line-14> for i,a in enumerate(aa):</line-14>
<line-15> if a<1 or a>n:return True</line-15>
<line-16> atoi[a-1].append(i)</line-16>
<line-17> if len(atoi[a-1])>2:return True</line-17>
<line-18> for a in range(n):</line-18>
<line-19> u,v=atoi[a]</line-19>
<line-20> if u+n==v:continue</line-20>
<line-21> to[u].append((v+n)%(n*2))</line-21>
<line-22> to[v].append((u+n)%(n*2))</line-22>
<line-23> return False</line-23>
<line-24></line-24>
<line-25>def dfs(u):</line-25>
<line-26> flap[u%n]=(u>=n)*1</line-26>
<line-27> cur[u>=n].append(u%n+1)</line-27>
<line-28> stack=[u]</line-28>
<line-29> while stack:</line-29>
<line-30> u=stack.pop()</line-30>
<line-31> for v in to[u]:</line-31>
<line-32> if flap[v%n]==-1:</line-32>
<line-33> flap[v % n]=(v>=n)*1</line-33>
<line-34> cur[v >= n].append(v % n+1)</line-34>
<line-35> stack.append(v)</line-35>
<line-36> elif flap[v % n]!=(v>=n)*1:return True</line-36>
<line-37> return False</line-37>
<line-38></line-38>
<line-39>for _ in range(II()):</line-39>
<line-40> n=II()</line-40>
<line-41> aa=LI()+LI()</line-41>
<line-42> to=[[] for _ in range(n*2)]</line-42>
<line-43></line-43>
<line-44> if maketo():</line-44>
<line-45> print(-1)</line-45>
<line-46> continue</line-46>
<line-47> #print(to)</line-47>
<line-48></line-48>
<line-49> ans = []</line-49>
<line-50> flap=[-1]*n</line-50>
<line-51> ng=False</line-51>
<line-52> for u in range(n):</line-52>
<line-53> #u+=n</line-53>
<line-54> if flap[u%n]!=-1:continue</line-54>
<line-55> cur=[[],[]]</line-55>
<line-56> ng=dfs(u)</line-56>
<line-57> if len(cur[0])<len(cur[1]):ans+=cur[0]</line-57>
<line-58> else:ans+=cur[1]</line-58>
<line-59> #print(u,flap,cur,ans)</line-59>
<line-60> if ng:break</line-60>
<line-61></line-61>
<line-62> if ng:print(-1)</line-62>
<line-63> else:</line-63>
<line-65> print(*ans)</line-65>
|
{"code": "<line-3>sys.setrecursionlimit(10 ** 5)</line-3>\n<line-64> print(len(ans))</line-64>", "lines": [3, 64]}
#### 0
|
<line-1>from sys import stdin, stdout</line-1>
<line-3>import sys,os,math</line-3>
<line-4></line-4>
<line-5>#sys.setrecursionlimit(10**6)</line-5>
<line-6></line-6>
<line-7>T = int(input())</line-7>
<line-8>for _ in range(T):</line-8>
<line-9> N, M = list(map(int, input().split()))</line-9>
<line-10> DS = [0] * (N + 1)</line-10>
<line-11> ES = []</line-11>
<line-12> g = [[] for _ in range(N + 1)]</line-12>
<line-13> for _ in range(M):</line-13>
<line-14> t, u, v = list(map(int, input().split()))</line-14>
<line-15> ES.append([t ,u ,v])</line-15>
<line-16> if t == 1:</line-16>
<line-17> DS[u] += 1</line-17>
<line-18> g[u].append(len(ES) - 1)</line-18>
<line-19> g[v].append(len(ES) - 1)</line-19>
<line-20></line-20>
<line-21> q = []</line-21>
<line-22> for u in range(1, N+1):</line-22>
<line-23> if DS[u] == 0:</line-23>
<line-24> q.append(u)</line-24>
<line-25></line-25>
<line-26> while len(q) > 0:</line-26>
<line-27> u = q.pop()</line-27>
<line-28> if DS[u] > 0:</line-28>
<line-29> continue</line-29>
<line-30></line-30>
<line-31> for e in g[u]:</line-31>
<line-32> t, u0, v0 = ES[e]</line-32>
<line-33> if t == 1:</line-33>
<line-34> if v0 == u:</line-34>
<line-35> DS[u0] -= 1</line-35>
<line-36> if DS[u0] == 0:</line-36>
<line-37> q.append(u0)</line-37>
<line-38> elif t == 0:</line-38>
<line-39> v = v0 if u0 == u else u0</line-39>
<line-40> ES[e] = [1, v, u]</line-40>
<line-41> </line-41>
<line-42> md = max(DS)</line-42>
<line-43> if md > 0:</line-43>
<line-44> print("NO")</line-44>
<line-45> else:</line-45>
<line-46> print("YES")</line-46>
<line-48> print(e[1], e[2])</line-48>
<line-49></line-49>
<line-50> </line-50>
<line-51></line-51>
|
{"code": "<line-2>import functools</line-2>\n<line-47> for e in ES:</line-47>", "lines": [2, 47]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>T = int(input())</line-4>
<line-5>for _ in range(T):</line-5>
<line-6> N = int(input())</line-6>
<line-7> A = [int(a) for a in input().split()]</line-7>
<line-8> </line-8>
<line-9> if max(A) == min(A):</line-9>
<line-10> print(1)</line-10>
<line-11> print(*([1] * N))</line-11>
<line-12> elif N % 2 == 0:</line-12>
<line-13> print(2)</line-13>
<line-14> print(*([1, 2] * (N // 2)))</line-14>
<line-15> else:</line-15>
<line-16> for i in range(N):</line-16>
<line-17> if A[i-1] == A[i]:</line-17>
<line-18> print(2)</line-18>
<line-19> print(*(([1, 2] * N)[:i][::-1] + ([1, 2] * N)[:N-i]))</line-19>
<line-20> break</line-20>
<line-21> else:</line-21>
<line-23> print(*([3] + [1, 2] * (N // 2)))</line-23>
<line-24></line-24>
|
{"code": "<line-2>input = lambda: sys.stdin.readline().rstrip()</line-2>\n<line-22> print(3)</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>n,l = map(int,input().split())</line-1>
<line-3>for i in range(n):</line-3>
<line-4> a.append(input())</line-4>
<line-5> </line-5>
<line-7>print("".join(str(i) for i in a))</line-7>
|
{"code": "<line-2>a = []</line-2>\n<line-6>a.sort()</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> if a * n != b * m:</line-3>
<line-4> print('NO')</line-4>
<line-5> else:</line-5>
<line-6> ar = []</line-6>
<line-7> for i in range(n):</line-7>
<line-8> ar.append([0] * m)</line-8>
<line-9> x, y = 0, a</line-9>
<line-10> for i in range(n):</line-10>
<line-11> if x < y:</line-11>
<line-12> for j in range(x, y):</line-12>
<line-13> ar[i][j] = 1</line-13>
<line-14> else:</line-14>
<line-15> for j in range(x, m):</line-15>
<line-16> ar[i][j] = 1</line-16>
<line-17> for j in range(y):</line-17>
<line-18> ar[i][j] = 1</line-18>
<line-19> x += a</line-19>
<line-20> y += a</line-20>
<line-21> x %= m</line-21>
<line-22> y %= m</line-22>
<line-23> print('YES')</line-23>
<line-25> print(''.join(map(str, ar[i])))</line-25>
|
{"code": "<line-2> n, m, a, b = list(map(int, input().split()))</line-2>\n<line-24> for i in range(n):</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>s = input()</line-1>
<line-3>ind = -1</line-3>
<line-4>f = False</line-4>
<line-5>for i in range(n):</line-5>
<line-6> if s[i] == '[':</line-6>
<line-7> f = True</line-7>
<line-8> elif s[i] == ':':</line-8>
<line-9> if f:</line-9>
<line-10> ind = i</line-10>
<line-11> break</line-11>
<line-12>bind = -1</line-12>
<line-13>f = False</line-13>
<line-14>for i in range(n-1,-1,-1):</line-14>
<line-15> if s[i] == ']':</line-15>
<line-16> f = True</line-16>
<line-17> elif s[i] == ':':</line-17>
<line-18> if f:</line-18>
<line-19> bind = i</line-19>
<line-20> break</line-20>
<line-21># print(ind,bind)</line-21>
<line-22>if ind == -1 or bind == -1:</line-22>
<line-23> print(-1)</line-23>
<line-24>elif ind >= bind:</line-24>
<line-25> print(-1)</line-25>
<line-26>else:</line-26>
<line-27> ans = 4</line-27>
<line-28> for i in range(ind+1,bind):</line-28>
<line-29> if s[i] == '|':</line-29>
<line-31> print(ans)</line-31>
|
{"code": "<line-2>n = len(s)</line-2>\n<line-30> ans += 1</line-30>", "lines": [2, 30]}
#### 0
|
<line-1>num = list(map(int, input()))</line-1>
<line-3>for i in range(-1, -len(num) - 1, -1):</line-3>
<line-4> if num[i] == 0:</line-4>
<line-5> continue</line-5>
<line-6> num[i] -= 1</line-6>
<line-7> for j in range(i + 1, 0):</line-7>
<line-8> num[j] = 9</line-8>
<line-9> if sum(num) > sum(best):</line-9>
<line-10> best = num[:]</line-10>
<line-12>print(s)</line-12>
|
{"code": "<line-2>best = num[:]</line-2>\n<line-11>s = ''.join(map(str, best)).lstrip('0')</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>def main():</line-1>
<line-3> n = len(s)</line-3>
<line-4> t = int(str(int(s[0]) + 1) + '0' * (n - 1))</line-4>
<line-5></line-5>
<line-7></line-7>
<line-8>main()</line-8>
|
{"code": "<line-2> s = input()</line-2>\n<line-6> print(t - int(s))</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>from collections import defaultdict as dd</line-1>
<line-3>def nn():</line-3>
<line-4> return int(input())</line-4>
<line-5></line-5>
<line-6>def li():</line-6>
<line-7> return list(input())</line-7>
<line-8></line-8>
<line-9>def mi():</line-9>
<line-10> return list(map(int, input().split()))</line-10>
<line-11></line-11>
<line-12>def lm():</line-12>
<line-13> return list(map(int, input().split()))</line-13>
<line-14></line-14>
<line-15></line-15>
<line-16>n, q=mi()</line-16>
<line-17></line-17>
<line-18>ints=[]</line-18>
<line-19></line-19>
<line-20></line-20>
<line-21>for _ in range(q):</line-21>
<line-22> st, end=mi()</line-22>
<line-23> ints.append((st,end))</line-23>
<line-24></line-24>
<line-25></line-25>
<line-26>coverage=[10]+[0]*n</line-26>
<line-27></line-27>
<line-28>for st, end in ints:</line-28>
<line-29> for i in range(st,end+1):</line-29>
<line-30> coverage[i]+=1</line-30>
<line-31></line-31>
<line-32>total=-1</line-32>
<line-33></line-33>
<line-34>for val in coverage:</line-34>
<line-35> if not val==0:</line-35>
<line-36> total+=1</line-36>
<line-37></line-37>
<line-38>singlecount=0</line-38>
<line-39>doublecount=0</line-39>
<line-40></line-40>
<line-41>singles=[0]*(n+1)</line-41>
<line-42>#print(total)</line-42>
<line-43>doubles=[0]*(n+1)</line-43>
<line-44>for i in range(len(coverage)):</line-44>
<line-45> #print(i,singles)</line-45>
<line-46> if coverage[i]==1:</line-46>
<line-47> singlecount+=1</line-47>
<line-48> if coverage[i]==2:</line-48>
<line-49> doublecount+=1</line-49>
<line-50> singles[i]=singlecount</line-50>
<line-51> doubles[i]=doublecount</line-51>
<line-52>maxtotal=0</line-52>
<line-53>for i in range(len(ints)):</line-53>
<line-54> for j in range(i+1, len(ints)):</line-54>
<line-55> st1=min(ints[i][0],ints[j][0])</line-55>
<line-56> end1=min(ints[i][1],ints[j][1])</line-56>
<line-57> st2, end2=max(ints[i][0],ints[j][0]), max(ints[i][1],ints[j][1])</line-57>
<line-58> #assume st1<=st2</line-58>
<line-59> if end1<st2:</line-59>
<line-60> curtotal=total-(singles[end1]-singles[st1-1])-(singles[end2]-singles[st2-1])</line-60>
<line-61> elif end1<end2:</line-61>
<line-62> curtotal=total-(singles[st2-1]-singles[st1-1])-(doubles[end1]-doubles[st2-1])-(singles[end2]-singles[end1])</line-62>
<line-63> else:</line-63>
<line-64> curtotal=total-(singles[st2-1]-singles[st1-1])-(doubles[end2]-doubles[st2-1])-(singles[end1]-singles[end2])</line-64>
<line-66></line-66>
<line-67>print(maxtotal)</line-67>
<line-68> </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>
|
{"code": "<line-2>import math</line-2>\n<line-65>\t\tmaxtotal=max(maxtotal,curtotal)</line-65>", "lines": [2, 65]}
#### 0
|
<line-1>x=int(input())</line-1>
<line-3>def ok(mm):</line-3>
<line-4> while mm<0: mm+=1440</line-4>
<line-5> hh=mm//60</line-5>
<line-6> mm=mm%60</line-6>
<line-7> return hh%10==7 or hh//10==7 or mm%10==7 or mm//10==7</line-7>
<line-8>for y in range(999):</line-8>
<line-9> if ok(h*60+m-y*x):</line-9>
<line-11> return</line-11>
|
{"code": "<line-2>h,m=list(map(int,input().split()))</line-2>\n<line-10> print(y)</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>n, pos, l, r = map(int, input().split())</line-1>
<line-2></line-2>
<line-4> if l <= pos and pos <= r:</line-4>
<line-5> if pos - l < r - pos:</line-5>
<line-6> print(pos - l + 1 + r - l + 1)</line-6>
<line-7> else:</line-7>
<line-8> print(r - pos + 1 + r - l + 1)</line-8>
<line-9> elif pos > r:</line-9>
<line-10> print(pos - r + 1 + r - l + 1)</line-10>
<line-11> else:</line-11>
<line-12> print(l - pos + 1 + r - l + 1)</line-12>
<line-13>elif l == 1 and r < n:</line-13>
<line-14> print(int(abs(pos - r)) + 1)</line-14>
<line-15>elif l > 1 and r == n:</line-15>
<line-16> print(int(abs(pos - l)) + 1)</line-16>
<line-18> print(0)</line-18>
|
{"code": "<line-3>if l > 1 and r < n:</line-3>\n<line-17>else:</line-17>", "lines": [3, 17]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> A = []</line-3>
<line-4> for _1 in range(n):</line-4>
<line-5> d, h = list(map(int, input().split()))</line-5>
<line-6> A.append([d, h])</line-6>
<line-7> A.sort(reverse=True)</line-7>
<line-8> if A[0][0] >= x:</line-8>
<line-9> print(1)</line-9>
<line-10> else:</line-10>
<line-11> x -= A[0][0]</line-11>
<line-12> mz = 0</line-12>
<line-13> for d, h in A:</line-13>
<line-14> mz = max(mz, d - h)</line-14>
<line-15> if mz:</line-15>
<line-16> print((x + mz - 1) // mz + 1)</line-16>
<line-18> print(-1)</line-18>
|
{"code": "<line-2> n, x = list(map(int, input().split()))</line-2>\n<line-17> else:</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>n, m = map(int, input().split())</line-1>
<line-3>else:</line-3>
<line-4> c = n - m</line-4>
<line-5> l = 0</line-5>
<line-6> r = 10 ** 18</line-6>
<line-7> while r - l > 1:</line-7>
<line-8> md = (r + l) // 2</line-8>
<line-9> if (1 + md) * md // 2 < c:</line-9>
<line-10> l = md</line-10>
<line-11> else:</line-11>
<line-13> print(r + m)</line-13>
|
{"code": "<line-2>if (m >= n): print(n)</line-2>\n<line-12> r = md</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>cards=list(input().split())</line-1>
<line-3>lp=[0]*9</line-3>
<line-4>ls=[0]*9</line-4>
<line-5>for item in cards:</line-5>
<line-6> if item[1]=='m':</line-6>
<line-7> lm[int(item[0])-1]+=1</line-7>
<line-8> elif item[1]=='p':</line-8>
<line-9> lp[int(item[0])-1]+=1</line-9>
<line-10> else :</line-10>
<line-11> ls[int(item[0])-1]+=1</line-11>
<line-12>if max(lm)==3 or max(lp)==3 or max(ls)==3:</line-12>
<line-13> print(0)</line-13>
<line-14>else :</line-14>
<line-15> flag=0</line-15>
<line-16> def seq_checker(li):</line-16>
<line-17> flag=0</line-17>
<line-18> for i in range(9):</line-18>
<line-19> if flag==0:</line-19>
<line-20> if lm[i]==1:</line-20>
<line-21> flag=1</line-21>
<line-22> else :</line-22>
<line-23> if lm[i]==1:</line-23>
<line-24> flag+=1</line-24>
<line-25> else :</line-25>
<line-26> break</line-26>
<line-27> return flag</line-27>
<line-28> if seq_checker(lm)==3 or seq_checker(lp)==3 or seq_checker(ls)==3:</line-28>
<line-29> print(0)</line-29>
<line-30> elif max(lm)==2 or max(lp)==2 or max(ls)==2:</line-30>
<line-31> print(1)</line-31>
<line-32> else :</line-32>
<line-33> m=0</line-33>
<line-34> for i in range(0,7):</line-34>
<line-36> print(3-m)</line-36>
|
{"code": "<line-2>lm=[0]*9</line-2>\n<line-35> m=max(sum(lm[i:i+3]),sum(lp[i:i+3]),sum(ls[i:i+3]),m)</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>from sys import stdin, stdout</line-1>
<line-2></line-2>
<line-4>n, m = map(int, stdin.readline().split())</line-4>
<line-5>left, right, down, up = [], [], [], []</line-5>
<line-6>coordinates = []</line-6>
<line-7></line-7>
<line-8>for i in range(k):</line-8>
<line-9> x1, y1, x2, y2 = map(int, stdin.readline().split())</line-9>
<line-10> </line-10>
<line-11> if x1 == x2:</line-11>
<line-12> if y1 < y2:</line-12>
<line-13> coordinates.append((x1, y1, x2, y2, i))</line-13>
<line-14> else:</line-14>
<line-15> coordinates.append((x2, y2, x1, y1, i))</line-15>
<line-16> else:</line-16>
<line-17> if x1 < x2:</line-17>
<line-18> coordinates.append((x1, y1, x2, y2, i))</line-18>
<line-19> else:</line-19>
<line-20> coordinates.append((x2, y2, x1, y1, i))</line-20>
<line-21> </line-21>
<line-22> left.append(coordinates[-1])</line-22>
<line-23> right.append(coordinates[-1])</line-23>
<line-24> up.append(coordinates[-1])</line-24>
<line-25> down.append(coordinates[-1])</line-25>
<line-26></line-26>
<line-27>left.sort(key = lambda x: (x[0], x[2]))</line-27>
<line-28>down.sort(key = lambda x: (x[1], x[3]))</line-28>
<line-29></line-29>
<line-30>challengers = [[], [], [], []]</line-30>
<line-31>cntl, cntr, cntd, cntu = map(int, stdin.readline().split())</line-31>
<line-32>label = 1</line-32>
<line-33></line-33>
<line-34>if cntl or not cntl:</line-34>
<line-35> for i in range(cntl, -1, -1):</line-35>
<line-36> if (left[i][0], left[i][2]) == (left[cntl][0], left[cntl][2]):</line-36>
<line-37> challengers[0].append(left[i][-1]) </line-37>
<line-38> else:</line-38>
<line-39> break</line-39>
<line-40> </line-40>
<line-41> for i in range(cntl + 1, k):</line-41>
<line-42> if (left[i][0], left[i][2]) == (left[cntl][0], left[cntl][2]) and left[i][2] > left[i][0]:</line-42>
<line-43> label = 0</line-43>
<line-44> </line-44>
<line-45> if (left[i][0], left[i][2]) == (left[cntl][0], left[cntl][2]):</line-45>
<line-46> challengers[0].append(left[i][-1]) </line-46>
<line-47> else:</line-47>
<line-48> break</line-48>
<line-49></line-49>
<line-50>if cntr or not cntr:</line-50>
<line-51> for i in range(k - 1 - cntr, k):</line-51>
<line-52> if (left[i][0], left[i][2]) == (left[k - 1 - cntr][0], left[k - 1 - cntr][2]):</line-52>
<line-53> challengers[1].append(left[i][-1])</line-53>
<line-54> else:</line-54>
<line-55> break</line-55>
<line-56> </line-56>
<line-57> for i in range(k - 2 - cntr, -1, -1):</line-57>
<line-58> if (left[i][0], left[i][2]) == (left[k - 1 - cntr][0], left[k - 1 - cntr][2]) and left[i][2] > left[i][0]:</line-58>
<line-59> label = 0</line-59>
<line-60> </line-60>
<line-61> if (left[i][0], left[i][2]) == (left[k - 1 - cntr][0], left[k - 1 - cntr][2]):</line-61>
<line-62> challengers[1].append(left[i][-1])</line-62>
<line-63> else:</line-63>
<line-64> break</line-64>
<line-65></line-65>
<line-66>#!!!!!!!!!!!</line-66>
<line-67></line-67>
<line-68>if cntd or not cntd:</line-68>
<line-69> for i in range(cntd, -1, -1):</line-69>
<line-70> if (down[i][1], down[i][3]) == (down[cntd][1], down[cntd][3]):</line-70>
<line-71> challengers[2].append(down[i][-1])</line-71>
<line-72> else:</line-72>
<line-73> break</line-73>
<line-74> </line-74>
<line-75> for i in range(cntd + 1, k):</line-75>
<line-76> if (down[i][1], down[i][3]) == (down[cntd][1], down[cntd][3]) and down[i][3] > down[i][1]:</line-76>
<line-77> label = 0</line-77>
<line-78> </line-78>
<line-79> if (down[i][1], down[i][3]) == (down[cntd][1], down[cntd][3]):</line-79>
<line-80> challengers[2].append(down[i][-1]) </line-80>
<line-81> else:</line-81>
<line-82> break</line-82>
<line-83> </line-83>
<line-84>if cntu or not cntu:</line-84>
<line-85> for i in range(k - 1 - cntu, k):</line-85>
<line-86> if (down[i][1], down[i][3]) == (down[k - 1 - cntu][1], down[k - 1 - cntu][3]):</line-86>
<line-87> challengers[3].append(down[i][-1])</line-87>
<line-88> else:</line-88>
<line-89> break</line-89>
<line-90> </line-90>
<line-91> for i in range(k - 2 - cntu, -1, -1):</line-91>
<line-92> if (down[i][1], down[i][3]) == (down[k - 1 - cntu][1], down[k - 1 - cntu][3]) and down[i][3] > down[i][1]:</line-92>
<line-93> label = 0</line-93>
<line-94> </line-94>
<line-95> if (down[i][1], down[i][3]) == (down[k - 1 - cntu][1], down[k - 1 - cntu][3]):</line-95>
<line-96> challengers[3].append(down[i][-1])</line-96>
<line-97> else:</line-97>
<line-98> break</line-98>
<line-99></line-99>
<line-100>ans = set(challengers[0]) & set(challengers[1]) & set(challengers[2]) & set(challengers[3])</line-100>
<line-101></line-101>
<line-102>if not len(ans) or not label:</line-102>
<line-103> stdout.write('-1')</line-103>
<line-105> stdout.write(str(list(ans)[0] + 1))</line-105>
|
{"code": "<line-3>k = int(stdin.readline())</line-3>\n<line-104>else:</line-104>", "lines": [3, 104]}
#### 0
|
<line-2>r=n%7</line-2>
<line-3>d=n//7</line-3>
<line-4>print(2*d+max(0,r-5),2*d+min(r,2))</line-4>
|
{"code": "<line-1>n=int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>from fractions import gcd</line-1>
<line-3> return a*b//gcd(a, b)</line-3>
<line-4>n, a, b, p, q = list(map(int, input().split(' ')))</line-4>
<line-5>red = n//a</line-5>
<line-6>blue = n//b</line-6>
<line-7>if (p<q):</line-7>
<line-8> red -= n//lcm(a, b)</line-8>
<line-9>else:</line-9>
<line-11></line-11>
<line-12>print(p*red+q*blue)</line-12>
|
{"code": "<line-2>def lcm(a, b):</line-2>\n<line-10> blue -= n//lcm(a, b)</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>x = A.count('G')</line-3>
<line-4>num_1 = 0</line-4>
<line-5>num_2 = 0</line-5>
<line-6>max_num = 0</line-6>
<line-7>flag = 0</line-7>
<line-8>for i in range(n):</line-8>
<line-9> if A[i] == 'G' and flag == 0:</line-9>
<line-10> num_1 += 1</line-10>
<line-11> elif A[i] == 'G' and flag == 1:</line-11>
<line-12> num_2 += 1</line-12>
<line-13> elif A[i] == 'S' and flag == 0:</line-13>
<line-14> flag = 1</line-14>
<line-15> else:</line-15>
<line-16> if num_1 + num_2 + 1 <= x:</line-16>
<line-17> if num_1 + num_2 + 1 > max_num:</line-17>
<line-18> max_num = num_1 + num_2 + 1</line-18>
<line-19> num_1 = num_2</line-19>
<line-20> num_2 = 0</line-20>
<line-21> flag = 1</line-21>
<line-22> else:</line-22>
<line-23> if num_2 + num_1 > max_num:</line-23>
<line-24> max_num = num_1 + num_2</line-24>
<line-25> num_1 = num_2</line-25>
<line-26> num_2 = 0</line-26>
<line-27> flag = 1</line-27>
<line-28>if num_1 + num_2 + 1 <= x:</line-28>
<line-29> if num_1 + num_2 + 1 > max_num:</line-29>
<line-30> max_num = num_1 + num_2 + 1</line-30>
<line-31>else:</line-31>
<line-32> if num_2 + num_1 > max_num:</line-32>
<line-34>print(max_num)</line-34>
|
{"code": "<line-2>A = input()</line-2>\n<line-33> max_num = num_1 + num_2</line-33>", "lines": [2, 33]}
#### 0
|
<line-1>#This code is dedicated to Vlada S.</line-1>
<line-2></line-2>
<line-4> def __init__(self, reqs, number):</line-4>
<line-5> self.reqs = list(map(int, reqs.split()[1:]))</line-5>
<line-6> self.available = False</line-6>
<line-7> self.in_stack = False</line-7>
<line-8> self.number = number</line-8>
<line-9></line-9>
<line-10>n, k = list(map(int, input().split()))</line-10>
<line-11>requirements = list(map(int, input().split()))</line-11>
<line-12>courses = {}</line-12>
<line-13></line-13>
<line-14>answer = ""</line-14>
<line-15></line-15>
<line-16>for i in range(n):</line-16>
<line-17> courses[i + 1]= Course(input(), i + 1)</line-17>
<line-18></line-18>
<line-19>for i in range(len(requirements)):</line-19>
<line-20> requirements[i] = courses[requirements[i]]</line-20>
<line-21></line-21>
<line-22>while requirements:</line-22>
<line-23> data = {}</line-23>
<line-24></line-24>
<line-25> course = requirements.pop()</line-25>
<line-26></line-26>
<line-27> if not course.available:</line-27>
<line-28> requirements.append(course)</line-28>
<line-29></line-29>
<line-30> done = True</line-30>
<line-31></line-31>
<line-32> for c in course.reqs:</line-32>
<line-33> c = courses[c]</line-33>
<line-34></line-34>
<line-35> if not c.available:</line-35>
<line-36> requirements.append(c)</line-36>
<line-37> done = False</line-37>
<line-38></line-38>
<line-39> if done:</line-39>
<line-40> answer += " " + str(course.number)</line-40>
<line-41> course.available = True</line-41>
<line-42> else:</line-42>
<line-43> if course.in_stack:</line-43>
<line-44> print(-1)</line-44>
<line-45> break</line-45>
<line-46></line-46>
<line-47> course.in_stack = True</line-47>
<line-48>else:</line-48>
<line-50> print(answer[1:])</line-50>
|
{"code": "<line-3>class Course:</line-3>\n<line-49>\tprint(answer.count(\" \"))</line-49>", "lines": [3, 49]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>f = sys.stdin</line-4>
<line-5>n,k = list(map(int, f.readline().split()))</line-5>
<line-6>a = list(map(int, f.readline().split()))</line-6>
<line-7>aset = set(a)</line-7>
<line-8>st = []</line-8>
<line-9>failed = False</line-9>
<line-10>ai = 0</line-10>
<line-11>app = []</line-11>
<line-12>for p in range(1, n+1):</line-12>
<line-13> if p in aset:</line-13>
<line-14> while ai < k and (len(st)==0 or st[-1]!=p):</line-14>
<line-15> st.append(a[ai])</line-15>
<line-16> ai += 1</line-16>
<line-17> if len(st) == 0 or st[-1] != p:</line-17>
<line-18> failed = True</line-18>
<line-19> break</line-19>
<line-20> st.pop(-1)</line-20>
<line-21> a += app[::-1]</line-21>
<line-22> app = []</line-22>
<line-23> else:</line-23>
<line-24> if ai != k:</line-24>
<line-25> st += a[ai:k]</line-25>
<line-26> ai = k</line-26>
<line-27> app.append(p)</line-27>
<line-28></line-28>
<line-29>if failed:</line-29>
<line-30> print(-1)</line-30>
<line-32> print(' '.join(map(str, a + app[::-1])))</line-32>
|
{"code": "<line-3>#f = open('input', 'r')</line-3>\n<line-31>else:</line-31>", "lines": [3, 31]}
#### 0
|
<line-1>import sys</line-1>
<line-3>if c==0:</line-3>
<line-4> if a==b:</line-4>
<line-5> print('YES')</line-5>
<line-6> else:</line-6>
<line-7> print('NO')</line-7>
<line-8> return</line-8>
<line-9>if (b-a)%c==0 and (b-a)//c>=0:</line-9>
<line-10> print('YES')</line-10>
<line-12> print('NO')</line-12>
|
{"code": "<line-2>a,b,c=map(int,input().split())</line-2>\n<line-11>else:</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>cnt1 = int(input())</line-1>
<line-3>cnt3 = int(input())</line-3>
<line-4>cnt4 = int(input())</line-4>
<line-5>if cnt1 != cnt4:</line-5>
<line-6> print(0)</line-6>
<line-7> return</line-7>
<line-8></line-8>
<line-9>if (cnt3 != 0 and cnt1 == 0):</line-9>
<line-10> print(0)</line-10>
<line-12></line-12>
<line-13>print(1)</line-13>
|
{"code": "<line-2>cnt2 = int(input())</line-2>\n<line-11>\treturn</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>def read_ints():</line-1>
<line-3></line-3>
<line-4>n, k, t = read_ints()</line-4>
<line-5>if t <= k:</line-5>
<line-6> print(t)</line-6>
<line-7>elif t > n:</line-7>
<line-8> print(k + n - t)</line-8>
<line-10> print(k)</line-10>
|
{"code": "<line-2>\treturn [int(i) for i in input().split()]</line-2>\n<line-9>else:</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>from collections import deque</line-1>
<line-3>mn = [ 300 for i in range( len( S ) ) ]</line-3>
<line-4>for i in range( len( S ) - 1, -1, -1 ):</line-4>
<line-5> if i == len( S ) - 1:</line-5>
<line-6> mn[ i ] = ord( S[ i ] )</line-6>
<line-7> else:</line-7>
<line-8> mn[ i ] = min( mn[ i + 1 ], ord( S[ i ] ) )</line-8>
<line-9>ans = ""</line-9>
<line-10>dq = deque()</line-10>
<line-11>for i in range( len( S ) ):</line-11>
<line-12> dq.append( ord( S[ i ] ) )</line-12>
<line-13> while len( dq ) and ( i + 1 == len( S ) or dq[ len( dq ) - 1 ] <= mn[ i + 1 ] ):</line-13>
<line-14> ans += chr( dq[ len( dq ) - 1 ] )</line-14>
<line-16>print( ans )</line-16>
|
{"code": "<line-2>S = input()</line-2>\n<line-15> dq.pop()</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>T = int(input())</line-4>
<line-5>for _ in range(T):</line-5>
<line-6> n = int(input())</line-6>
<line-7> lastP = 0</line-7>
<line-8> lastC = 0</line-8>
<line-9> works = True</line-9>
<line-10> for _ in range(n):</line-10>
<line-11> p, c = list(map(int, input().split()))</line-11>
<line-12> pDiff = p-lastP</line-12>
<line-13> cDiff = c-lastC</line-13>
<line-14> if 0 <= cDiff <= pDiff:</line-14>
<line-15> pass</line-15>
<line-16> else:</line-16>
<line-17> works = False</line-17>
<line-18> lastP = p</line-18>
<line-19> lastC = c</line-19>
<line-20> if works:</line-20>
<line-21> print('YES')</line-21>
<line-23> print('NO')</line-23>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-22> else:</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>s = input()</line-1>
<line-3>m = int(s[3:])</line-3>
<line-4></line-4>
<line-5>def ispalin(h, m):</line-5>
<line-6> s = "%02d:%02d"%(h,m)</line-6>
<line-7> return s == s[::-1]</line-7>
<line-8></line-8>
<line-9>for d in range(999999):</line-9>
<line-10> if ispalin(h, m):</line-10>
<line-11> print(d)</line-11>
<line-12> break</line-12>
<line-13> m+= 1</line-13>
<line-14> if m == 60:</line-14>
<line-16> m = 0</line-16>
|
{"code": "<line-2>h = int(s[:2])</line-2>\n<line-15> h = (h+1)%24</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>read = lambda: list(map(int, input().split()))</line-1>
<line-3>a = list(read())</line-3>
<line-4>x, y = a.index(1), a.index(n)</line-4>
<line-6>print(ans)</line-6>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-5>ans = max(x, y, n - x - 1, n - y - 1)</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>import sys, math</line-1>
<line-3>pal='AHIMOoTUVvWwXxY'</line-3>
<line-4>n=len(s)</line-4>
<line-5>l=0</line-5>
<line-6>r=n-1</line-6>
<line-7>flag=True</line-7>
<line-8>fir='pq'</line-8>
<line-9>sec='bd'</line-9>
<line-10>while l<=r:</line-10>
<line-11> if s[l]==s[r] and s[l] in pal:</line-11>
<line-12> l+=1</line-12>
<line-13> r-=1</line-13>
<line-14> continue</line-14>
<line-15> elif s[l]==s[r]:</line-15>
<line-16> flag=False</line-16>
<line-17> break</line-17>
<line-18> elif (s[l] in fir) and (s[r] in fir):</line-18>
<line-19> l+=1</line-19>
<line-20> r-=1</line-20>
<line-21> continue</line-21>
<line-22> elif (s[l] in sec) and (s[r] in sec):</line-22>
<line-23> l+=1</line-23>
<line-24> r-=1</line-24>
<line-25> continue</line-25>
<line-26> else:</line-26>
<line-27> flag=False</line-27>
<line-28> break</line-28>
<line-29>if flag:</line-29>
<line-30> print('TAK')</line-30>
<line-32> print('NIE')</line-32>
<line-33> </line-33>
|
{"code": "<line-2>s=input()</line-2>\n<line-31>else:</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>a = list(input())</line-1>
<line-3>a.sort()</line-3>
<line-4>a = a[::-1]</line-4>
<line-5>prefix = ""</line-5>
<line-6>while(len(a) > 0):</line-6>
<line-7> for i in range(len(a)):</line-7>
<line-8> num = prefix + a[i] + "".join(sorted(a[:i] + a[i + 1:]))</line-8>
<line-9> if (int(num) <= b):</line-9>
<line-10> prefix += a[i]</line-10>
<line-11> a = a[:i] + a[i+1:]</line-11>
<line-13>print(prefix)</line-13>
|
{"code": "<line-2>b = int(input())</line-2>\n<line-12>\t\t\tbreak</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>s = [ [ c for c in input() ] for i in range(10) ]</line-1>
<line-3> for i in range(10):</line-3>
<line-4> for j in range(10):</line-4>
<line-5> ok = True</line-5>
<line-6> for k in range(5):</line-6>
<line-7> if j+k>9: ok = False</line-7>
<line-8> elif s[i][j+k] != 'X': ok = False</line-8>
<line-9> if ok: return True</line-9>
<line-10> ok = True</line-10>
<line-11> for k in range(5):</line-11>
<line-12> if i+k>9: ok = False</line-12>
<line-13> elif s[i+k][j] != 'X': ok = False</line-13>
<line-14> if ok: return True</line-14>
<line-15> ok = True</line-15>
<line-16> for k in range(5):</line-16>
<line-17> if j+k>9 or i+k>9: ok = False</line-17>
<line-18> elif s[i+k][j+k] != 'X': ok = False</line-18>
<line-19> if ok: return True</line-19>
<line-20> ok = True</line-20>
<line-21> for k in range(5):</line-21>
<line-22> if i-k<0 or j+k>9: ok = False</line-22>
<line-23> elif s[i-k][j+k] != 'X': ok = False</line-23>
<line-24> if ok: return True</line-24>
<line-25> return False</line-25>
<line-26>for i in range(10):</line-26>
<line-27> for j in range(10):</line-27>
<line-28> if s[i][j]=='.':</line-28>
<line-29> s[i][j] = 'X'</line-29>
<line-30> if win():</line-30>
<line-31> print('YES')</line-31>
<line-32> return</line-32>
<line-34>print('NO')</line-34>
|
{"code": "<line-2>def win():</line-2>\n<line-33> s[i][j] = '.'</line-33>", "lines": [2, 33]}
#### 0
|
<line-1>#!/usr/bin/env python3</line-1>
<line-2></line-2>
<line-4> import sys</line-4>
<line-5></line-5>
<line-6> readln = sys.stdin.readline</line-6>
<line-7> try:</line-7>
<line-8> while True:</line-8>
<line-9> n, k = list(map(int, input().split()))</line-9>
<line-10> a = [['0'] * n for i in range(n)]</line-10>
<line-11> i = j = 0</line-11>
<line-12> while k > 0:</line-12>
<line-13> if i == j:</line-13>
<line-14> a[i][j] = '1'</line-14>
<line-15> k -= 1</line-15>
<line-16> j += 1</line-16>
<line-17> elif k >= 2:</line-17>
<line-18> a[i][j] = a[j][i] = '1'</line-18>
<line-19> k -= 2</line-19>
<line-20> j += 1</line-20>
<line-21> elif i != n - 1:</line-21>
<line-22> a[i + 1][i + 1] = '1'</line-22>
<line-23> k = 0</line-23>
<line-24> else:</line-24>
<line-25> assert a[i][i] == '1'</line-25>
<line-26> a[i][i] = '0'</line-26>
<line-27> a[i][j] = a[j][i] = '1'</line-27>
<line-28> k = 0</line-28>
<line-29></line-29>
<line-30> if j == n:</line-30>
<line-31> i += 1</line-31>
<line-32> if i == n and k > 0:</line-32>
<line-33> print(-1)</line-33>
<line-34> break</line-34>
<line-35> j = i</line-35>
<line-36> else:</line-36>
<line-37> for row in a:</line-37>
<line-38> print(' '.join(row))</line-38>
<line-39></line-39>
<line-40> except EOFError:</line-40>
<line-42></line-42>
<line-43>main()</line-43>
|
{"code": "<line-3>def main():</line-3>\n<line-41> pass</line-41>", "lines": [3, 41]}
#### 0
|
<line-1>from math import log</line-1>
<line-3></line-3>
<line-4>s = ['x^y^z', 'x^z^y', '(x^y)^z', 'y^x^z', 'y^z^x', '(y^x)^z', 'z^x^y', 'z^y^x', '(z^x)^y']</line-4>
<line-5></line-5>
<line-6>x, y, z = list(map(Decimal, input().split()))</line-6>
<line-7></line-7>
<line-8>f = []</line-8>
<line-9>f += [(Decimal(log(x)) * (y ** z), 0)]</line-9>
<line-10>f += [(Decimal(log(x)) * (z ** y), -1)]</line-10>
<line-11>f += [(Decimal(log(x)) * (y * z), -2)]</line-11>
<line-12>f += [(Decimal(log(y)) * (x ** z), -3)]</line-12>
<line-13>f += [(Decimal(log(y)) * (z ** x), -4)]</line-13>
<line-14>f += [(Decimal(log(y)) * (x * z), -5)]</line-14>
<line-15>f += [(Decimal(log(z)) * (x ** y), -6)]</line-15>
<line-16>f += [(Decimal(log(z)) * (y ** x), -7)]</line-16>
<line-17>f += [(Decimal(log(z)) * (x * y), -8)]</line-17>
<line-18></line-18>
<line-20></line-20>
<line-21>print(s[-f[-1][1]])</line-21>
|
{"code": "<line-2>from decimal import Decimal</line-2>\n<line-19>f.sort()</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>ans = n</line-3>
<line-4>now = ''</line-4>
<line-5>ma = 0</line-5>
<line-6>for i in range(n // 2):</line-6>
<line-7> now += st[i]</line-7>
<line-8> t = ''</line-8>
<line-9> for j in range(i + 1, 2 * i + 2):</line-9>
<line-10> t += st[j]</line-10>
<line-11> if t == now:</line-11>
<line-13>print(ans - ma)</line-13>
|
{"code": "<line-2>st = input()</line-2>\n<line-12> ma = i</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>b, a = d = [], []</line-3>
<line-4>h, s = [], []</line-4>
<line-5></line-5>
<line-6>for i in range(n):</line-6>
<line-7> f, k = input().split()</line-7>
<line-8> d[int(k)].append(f)</line-8>
<line-9></line-9>
<line-10>m = len(a)</line-10>
<line-11>for i in a:</line-11>
<line-12> if i.isdigit() and i[0] != '0':</line-12>
<line-13> j = int(i)</line-13>
<line-14> if 0 < j <= m:</line-14>
<line-15> t[j] = 1</line-15>
<line-16> elif m < j <= n:</line-16>
<line-17> t[j] = -1</line-17>
<line-18> else:</line-18>
<line-19> s.append(i)</line-19>
<line-20> else:</line-20>
<line-21> s.append(i)</line-21>
<line-22>for i in b:</line-22>
<line-23> if i.isdigit() and i[0] != '0':</line-23>
<line-24> j = int(i)</line-24>
<line-25> if m < j <= n:</line-25>
<line-26> t[j] = 1</line-26>
<line-27> elif 0 < j <= m:</line-27>
<line-28> t[j] = -1</line-28>
<line-29> else:</line-29>
<line-30> s.append(i)</line-30>
<line-31> else:</line-31>
<line-32> s.append(i)</line-32>
<line-33></line-33>
<line-34>x = [j for j in range(1, m + 1) if t[j] < 0]</line-34>
<line-35>y = [j for j in range(m + 1, n + 1) if t[j] < 0]</line-35>
<line-36></line-36>
<line-37>u = [j for j in range(1, m + 1) if not t[j]]</line-37>
<line-38>v = [j for j in range(m + 1, n + 1) if not t[j]]</line-38>
<line-39></line-39>
<line-40>if not s and (x or y):</line-40>
<line-41> s = ['0']</line-41>
<line-42> if y:</line-42>
<line-43> i = y.pop()</line-43>
<line-44> v.append(i)</line-44>
<line-45> else:</line-45>
<line-46> i = x.pop()</line-46>
<line-47> u.append(i)</line-47>
<line-48> h.append(str(i) + ' 0')</line-48>
<line-49> t[i] = 0</line-49>
<line-50></line-50>
<line-51>while x or y:</line-51>
<line-52> if v and x:</line-52>
<line-53> i = x.pop()</line-53>
<line-54> j = v.pop()</line-54>
<line-55> t[j] = 1</line-55>
<line-56> h.append(str(i) + ' ' + str(j))</line-56>
<line-57> u.append(i)</line-57>
<line-58> else:</line-58>
<line-59> u, v, x, y = v, u, y, x</line-59>
<line-60></line-60>
<line-61>k = 1</line-61>
<line-62>for j in s:</line-62>
<line-63> while t[k] == 1: k += 1</line-63>
<line-64> h.append(j + ' ' + str(k))</line-64>
<line-65> k += 1</line-65>
<line-66></line-66>
<line-68>print(str(len(h)) + d + d.join(h) if h else 0)</line-68>
|
{"code": "<line-2>t = [1] + [0] * n</line-2>\n<line-67>d = '\\nmove '</line-67>", "lines": [2, 67]}
#### 0
|
<line-1>x=int(input())</line-1>
<line-3> r=0</line-3>
<line-4> while a>0:</line-4>
<line-5> r+=a%10</line-5>
<line-6> a//=10</line-6>
<line-7> return r</line-7>
<line-8>def d(a,b):</line-8>
<line-9> r=0</line-9>
<line-10> for i in range(6):</line-10>
<line-11> if a%10!=b%10:</line-11>
<line-12> r += 1</line-12>
<line-13> a//=10</line-13>
<line-14> b//=10</line-14>
<line-15> return r</line-15>
<line-16>c=6</line-16>
<line-17>for i in range(1000000):</line-17>
<line-18> if s(i%1000)==s(i//1000):</line-18>
<line-20>print(c)</line-20>
|
{"code": "<line-2>def s(a):</line-2>\n<line-19> c=min(c,d(x,i))</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>from math import gcd</line-1>
<line-3> a%=m</line-3>
<line-4> r=1</line-4>
<line-5> while b:</line-5>
<line-6> if b&1:r=r*a%m</line-6>
<line-7> a=a*a%m</line-7>
<line-8> b>>=1</line-8>
<line-9> return r</line-9>
<line-10></line-10>
<line-11>def f(n):</line-11>
<line-12> r=[]</line-12>
<line-13> if (n&1)==0:</line-13>
<line-14> e=0</line-14>
<line-15> while (n&1)==0:n>>=1;e+=1</line-15>
<line-16> yield (2,e)</line-16>
<line-17> p=3</line-17>
<line-18> while n>1:</line-18>
<line-19> if p*p>n:p=n</line-19>
<line-20> if n%p:</line-20>
<line-21> p+=2</line-21>
<line-22> continue</line-22>
<line-23> e=1;n//=p</line-23>
<line-24> while n%p==0:n//=p;e+=1</line-24>
<line-25> yield (p,e)</line-25>
<line-26> p+=2</line-26>
<line-27> return r</line-27>
<line-28>m,x=map(int,input().split())</line-28>
<line-29>p=2</line-29>
<line-30>r=[(1,1)]</line-30>
<line-31>for p,e in f(m):</line-31>
<line-32> assert e>=1</line-32>
<line-33> ord=p-1</line-33>
<line-34> assert powmod(x,ord,p)==1</line-34>
<line-35> for pi,ei in f(p-1):</line-35>
<line-36> while ord % pi == 0 and powmod(x,ord//pi,p)==1: ord//=pi</line-36>
<line-37> ords=[(1,1),(ord,p-1)]</line-37>
<line-38> q=p</line-38>
<line-39> for v in range(2,e+1):</line-39>
<line-40> q*=p</line-40>
<line-41> if powmod(x,ord,q)!=1:ord*=p</line-41>
<line-42> assert powmod(x,ord,q)==1</line-42>
<line-43> ords.append((ord,q//p*(p-1)))</line-43>
<line-45>print(sum(y//x for x,y in r))</line-45>
|
{"code": "<line-2>def powmod(a,b,m):</line-2>\n<line-44> r=[(a//gcd(a,c)*c,b*d) for a,b in r for c,d in ords]</line-44>", "lines": [2, 44]}
#### 0
|
<line-1>m = 10** 6 + 3</line-1>
<line-2></line-2>
<line-4>p = 1</line-4>
<line-5>for i in range(n):</line-5>
<line-6> p *= 2</line-6>
<line-7> if p > k:</line-7>
<line-8> break</line-8>
<line-9>if p < k:</line-9>
<line-10> print('1 1')</line-10>
<line-11> return</line-11>
<line-12></line-12>
<line-13>gcd = tmp = k - 1</line-13>
<line-14>while tmp:</line-14>
<line-15> gcd -= tmp % 2</line-15>
<line-16> tmp //= 2</line-16>
<line-17>b = pow(2, (k - 1) * n - gcd, m)</line-17>
<line-18>a = 1</line-18>
<line-19>mem = [-1]*100</line-19>
<line-20>for i in range(1, k):</line-20>
<line-21> cnt = 0</line-21>
<line-22> while i % 2 == 0:</line-22>
<line-23> i //= 2</line-23>
<line-24> cnt += 1</line-24>
<line-25> if mem[cnt] == -1:</line-25>
<line-26> mem[cnt] = pow(2, n - cnt, m)</line-26>
<line-27> a = a * (mem[cnt] - i + m) % m</line-27>
<line-28> if a == 0:</line-28>
<line-30>print((b - a + m) % m, b)</line-30>
|
{"code": "<line-3>n, k = list(map(int, input().split()))</line-3>\n<line-29> break</line-29>", "lines": [3, 29]}
#### 0
|
<line-1>"""</line-1>
<line-3></line-3>
<line-4>Author : chaotic_iak</line-4>
<line-5>Language: Python 3.5.2</line-5>
<line-6>"""</line-6>
<line-7></line-7>
<line-8>################################################### SOLUTION</line-8>
<line-9></line-9>
<line-10>def main():</line-10>
<line-11> latitude = 0</line-11>
<line-12> n, = read()</line-12>
<line-13> for i in range(n):</line-13>
<line-14> l, d = read(str)</line-14>
<line-15> l = int(l)</line-15>
<line-16> if latitude == 0:</line-16>
<line-17> if d != "South":</line-17>
<line-18> return "NO"</line-18>
<line-19> if latitude == 20000:</line-19>
<line-20> if d != "North":</line-20>
<line-21> return "NO"</line-21>
<line-22> if d == "South":</line-22>
<line-23> latitude += l</line-23>
<line-24> elif d == "North":</line-24>
<line-25> latitude -= l</line-25>
<line-26> if not (0 <= latitude <= 20000):</line-26>
<line-27> return "NO"</line-27>
<line-28> if latitude != 0:</line-28>
<line-29> return "NO"</line-29>
<line-30> return "YES"</line-30>
<line-31></line-31>
<line-32>#################################################### HELPERS</line-32>
<line-33></line-33>
<line-34>def read(callback=int):</line-34>
<line-35> return list(map(callback, input().strip().split()))</line-35>
<line-36></line-36>
<line-37>def write(value, end="\n"):</line-37>
<line-38> if value is None: return</line-38>
<line-39> try:</line-39>
<line-40> if not isinstance(value, str):</line-40>
<line-41> value = " ".join(map(str, value))</line-41>
<line-42> except:</line-42>
<line-43> pass</line-43>
<line-45></line-45>
<line-46>write(main())</line-46>
|
{"code": "<line-2>Codeforces Good Bye 2016 Contest Problem B</line-2>\n<line-44> print(value, end=end)</line-44>", "lines": [2, 44]}
#### 0
|
<line-1>import sys, collections</line-1>
<line-2></line-2>
<line-4> if b == 0: return a</line-4>
<line-5> return gcd(b, a % b)</line-5>
<line-6></line-6>
<line-7>def lcm(a, b):</line-7>
<line-8> return a // gcd(a, b) * b</line-8>
<line-9></line-9>
<line-10>def extgcd(a, b):</line-10>
<line-11> if b == 0: return 1, 0</line-11>
<line-12> x, y = extgcd(b, a % b)</line-12>
<line-13> return y, x - a // b * y</line-13>
<line-14></line-14>
<line-15>def prime_factor(n):</line-15>
<line-16> res = collections.defaultdict(int)</line-16>
<line-17></line-17>
<line-18> i = 2</line-18>
<line-19> while i * i <= n:</line-19>
<line-20> cnt = 0</line-20>
<line-21> while n % i == 0:</line-21>
<line-22> n //= i</line-22>
<line-23> cnt += 1</line-23>
<line-24> if cnt > 0: res[i] = cnt</line-24>
<line-25> i += 1</line-25>
<line-26> if n != 1: res[n] = 1</line-26>
<line-27></line-27>
<line-28> return res</line-28>
<line-29></line-29>
<line-30>def modinv(a, mod):</line-30>
<line-31> if a == 0: return -1</line-31>
<line-32> if gcd(a, mod) != 1: return -1</line-32>
<line-33> return extgcd(a, mod)[0] % mod</line-33>
<line-34></line-34>
<line-35>def normalize(a1, a2):</line-35>
<line-36> p1 = prime_factor(a1)</line-36>
<line-37> p2 = prime_factor(a2)</line-37>
<line-38></line-38>
<line-39> keys = list(set(p1.keys()) | set(p2.keys()))</line-39>
<line-40></line-40>
<line-41> r1 = 1</line-41>
<line-42> r2 = 1</line-42>
<line-43> for k in keys:</line-43>
<line-44> if p1[k] >= p2[k]:</line-44>
<line-45> r1 *= k ** p1[k]</line-45>
<line-46> else:</line-46>
<line-47> r2 *= k ** p2[k]</line-47>
<line-48> return r1, r2</line-48>
<line-49></line-49>
<line-50>def solve(a1, b1, a2, b2):</line-50>
<line-51> g = gcd(a1, a2)</line-51>
<line-52> if (b1 - b2) % g != 0: return -1</line-52>
<line-53></line-53>
<line-54> a1, a2 = normalize(a1, a2)</line-54>
<line-55> u = b1 % a1</line-55>
<line-56> inv = modinv(a1, a2)</line-56>
<line-57> v = (b2 - u) * inv % a2</line-57>
<line-58> return u + v * a1</line-58>
<line-59></line-59>
<line-60>def f(x0, T, v):</line-60>
<line-61> ok = 10 ** 36</line-61>
<line-62> ng = -1</line-62>
<line-63></line-63>
<line-64> while ok - ng > 1:</line-64>
<line-65> mid = (ok + ng) // 2</line-65>
<line-66></line-66>
<line-67> if x0 + T * mid >= v:</line-67>
<line-68> ok = mid</line-68>
<line-69> else:</line-69>
<line-70> ng = mid</line-70>
<line-71></line-71>
<line-72> return ok</line-72>
<line-73></line-73>
<line-74>a1, b1, a2, b2, L, R = map(int, input().split())</line-74>
<line-75></line-75>
<line-76>T = lcm(a1, a2)</line-76>
<line-77>x0 = solve(a1, b1, a2, b2)</line-77>
<line-78></line-78>
<line-79>if x0 == -1:</line-79>
<line-80> print(0)</line-80>
<line-81> return</line-81>
<line-82></line-82>
<line-83>x0 -= T * 10 ** 36</line-83>
<line-84></line-84>
<line-85>ok = 10 ** 60</line-85>
<line-86>ng = -1</line-86>
<line-87></line-87>
<line-88>while ok - ng > 1:</line-88>
<line-89> mid = (ok + ng) // 2</line-89>
<line-90></line-90>
<line-91> val = x0 + T * mid</line-91>
<line-92> k = (val - b1) // a1</line-92>
<line-93> l = (val - b2) // a2</line-93>
<line-94> if k >= 0 and l >= 0:</line-94>
<line-95> ok = mid</line-95>
<line-96> else:</line-96>
<line-97> ng = mid</line-97>
<line-98></line-98>
<line-99>x0 += ok * T</line-99>
<line-100></line-100>
<line-101># L <= x0 + kT < R + 1</line-101>
<line-103></line-103>
<line-104>print(ans)</line-104>
|
{"code": "<line-3>def gcd(a, b):</line-3>\n<line-102>ans = f(x0, T, R + 1) - f(x0, T, L)</line-102>", "lines": [3, 102]}
#### 0
|
<line-1>n, a, b = map(int, input().split())</line-1>
<line-3>for i in range(1, n):</line-3>
<line-5>print(ans)</line-5>
|
{"code": "<line-2>ans = 0</line-2>\n<line-4> ans = max(ans, min(a // i, b // (n - i)))</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>n,m=list(map(int,input().split()))</line-1>
<line-3>def clr(ss):</line-3>
<line-4> cc = None</line-4>
<line-5> for s in ss:</line-5>
<line-6> for c in s:</line-6>
<line-7> if cc is None:</line-7>
<line-8> cc = c</line-8>
<line-9> elif cc != c:</line-9>
<line-10> return None</line-10>
<line-11> return cc</line-11>
<line-12>if n%3 == 0:</line-12>
<line-13> s = set()</line-13>
<line-14> for i in range(0,n,n//3):</line-14>
<line-15> ret = clr(f[i:i+n//3])</line-15>
<line-16> if ret is None:</line-16>
<line-17> continue</line-17>
<line-18> s.add(ret)</line-18>
<line-19> if len(s) == 3:</line-19>
<line-20> print('YES')</line-20>
<line-21> return</line-21>
<line-22>if m%3 == 0:</line-22>
<line-23> s = set()</line-23>
<line-24> for j in range(0,m,m//3):</line-24>
<line-25> ff = []</line-25>
<line-26> for i in f:</line-26>
<line-27> ff.append(i[j:j+m//3])</line-27>
<line-28> ret = clr(ff)</line-28>
<line-29> if ret is None:</line-29>
<line-30> continue</line-30>
<line-31> s.add(ret)</line-31>
<line-32> if len(s) == 3:</line-32>
<line-33> print('YES')</line-33>
<line-35>print('NO')</line-35>
|
{"code": "<line-2>f=[input() for _ in range(n)]</line-2>\n<line-34> return</line-34>", "lines": [2, 34]}
#### 0
|
<line-1>def f(n):</line-1>
<line-3> while right - left > 1:</line-3>
<line-4> mid = (left + right) // 2</line-4>
<line-5> x = 6 * mid * (mid + 1) // 2 + 5 * (mid + 1)</line-5>
<line-6> if x > n:</line-6>
<line-7> right = mid</line-7>
<line-8> else:</line-8>
<line-9> left = mid</line-9>
<line-10> if left >= 0:</line-10>
<line-11> mid = left</line-11>
<line-12> x = 6 * mid * (mid + 1) // 2 + 5 * (mid + 1)</line-12>
<line-13> n -= x</line-13>
<line-14> return (n, left + 1)</line-14>
<line-15></line-15>
<line-16>def main():</line-16>
<line-17> n = int(input())</line-17>
<line-18> n, k = f(n)</line-18>
<line-19> x = k</line-19>
<line-20> y = -2 * k</line-20>
<line-21> </line-21>
<line-22> d = [k + 1] * 6</line-22>
<line-23> d[1] -= 1</line-23>
<line-24> dx = [1, -1, -2, -1, 1, 2]</line-24>
<line-25> dy = [2, 2, 0, -2, -2, 0]</line-25>
<line-26> </line-26>
<line-27> for i in range(6):</line-27>
<line-28> x += min(d[i], n) * dx[i]</line-28>
<line-29> y += min(d[i], n) * dy[i]</line-29>
<line-30> n = max(0, n - d[i])</line-30>
<line-31> </line-31>
<line-33></line-33>
<line-34></line-34>
<line-35>main()</line-35>
|
{"code": "<line-2>\tleft, right = -1, n + 1</line-2>\n<line-32>\tprint(x, y)</line-32>", "lines": [2, 32]}
#### 0
|
<line-1>a, b, c = list(map(int, input().split()))</line-1>
<line-3>p[0] = 1</line-3>
<line-4>p[a] = 1</line-4>
<line-5>p[b] = 1</line-5>
<line-6>for i in range(c + 1):</line-6>
<line-7> if p[i]:</line-7>
<line-8> p[i + a] = 1</line-8>
<line-9> p[i + b] = 1</line-9>
<line-10>if p[c]:</line-10>
<line-11> print('Yes')</line-11>
<line-13> print('No')</line-13>
|
{"code": "<line-2>p = [0] * 100000</line-2>\n<line-12>else:</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>def main():</line-1>
<line-3></line-3>
<line-4> x = list(map(int, input().split()))</line-4>
<line-5> y = list(map(int, input().split()))</line-5>
<line-6></line-6>
<line-7> x.append(x[0] + l)</line-7>
<line-8> y.append(y[0] + l)</line-8>
<line-9></line-9>
<line-10> a = [x[i + 1] - x[i] for i in range(n)]</line-10>
<line-11> b = [y[i + 1] - y[i] for i in range(n)]</line-11>
<line-12></line-12>
<line-13> for i in range(n):</line-13>
<line-14> if (a == b[i:] + b[:i]):</line-14>
<line-15> print("YES")</line-15>
<line-16> return</line-16>
<line-18></line-18>
<line-19></line-19>
<line-20>main()</line-20>
|
{"code": "<line-2>\tn, l = map(int, input().split())</line-2>\n<line-17>\tprint(\"NO\")</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>s = input()</line-1>
<line-3>n = len(s)</line-3>
<line-4>for l in range(n):</line-4>
<line-5> for r in range(l, n):</line-5>
<line-6> if s[l:r+1] != s[l:r+1][::-1]:</line-6>
<line-8>print(mx)</line-8>
|
{"code": "<line-2>mx = 0</line-2>\n<line-7> mx = max(mx, r - l + 1)</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>'''input</line-1>
<line-3>3123 3123</line-3>
<line-4>2777 2777</line-4>
<line-5>2246 2246</line-5>
<line-6>2246 2246</line-6>
<line-7>1699 1699</line-7>
<line-8>'''</line-8>
<line-9>n = int(input())</line-9>
<line-10>x = []</line-10>
<line-11>f = 0</line-11>
<line-12>for _ in range(n):</line-12>
<line-13> a, b = list(map(int, input().split()))</line-13>
<line-14> if a != b:</line-14>
<line-15> f = 1</line-15>
<line-16> x.append(a)</line-16>
<line-17>if f == 1:</line-17>
<line-18> print("rated")</line-18>
<line-19>elif sorted(x)[::-1] == x:</line-19>
<line-20> print("maybe")</line-20>
<line-22> print("unrated")</line-22>
<line-23></line-23>
<line-24></line-24>
<line-25></line-25>
<line-26></line-26>
<line-27></line-27>
<line-28></line-28>
<line-29></line-29>
|
{"code": "<line-2>5</line-2>\n<line-21>else:</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>inf = 10 ** 6</line-1>
<line-3>a = list(map(int, input().split()))</line-3>
<line-4>dist = [inf] * n</line-4>
<line-5>for i in range(len(a)):</line-5>
<line-6> if not a[i]:</line-6>
<line-7> dist[i] = 0</line-7>
<line-8> cur = 1</line-8>
<line-9> i1 = i</line-9>
<line-10> while i1 - 1 > - 1 and a[i1 - 1] != 0:</line-10>
<line-11> dist[i1 - 1] = min(dist[i1 - 1], cur)</line-11>
<line-12> i1 -= 1</line-12>
<line-13> cur += 1</line-13>
<line-14> i1 = i</line-14>
<line-15> cur = 1</line-15>
<line-16> while i1 + 1 < n and a[i1 + 1] != 0:</line-16>
<line-17> dist[i1 + 1] = min(dist[i1 + 1], cur)</line-17>
<line-18> i1 += 1</line-18>
<line-20>print(*dist)</line-20>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-19> cur += 1</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>m=len(s)</line-3>
<line-4>z=[[0,0]]</line-4>
<line-5>for c in s:</line-5>
<line-6> ind = z[-1][c]</line-6>
<line-7> z[-1][c] = len(z)</line-7>
<line-8> z.append(z[ind][:])</line-8>
<line-9>assert(len(z) == m+1)</line-9>
<line-10>z[m][0] = z[m][1] = m # make it sticky</line-10>
<line-11></line-11>
<line-12># how many things match directly</line-12>
<line-13>dp = [0 for _ in range(m+1)]</line-13>
<line-14>dp[0] = 1</line-14>
<line-15>for i in range(n):</line-15>
<line-16> ndp = [0 for _ in range(m+1)]</line-16>
<line-17> for i in range(m+1):</line-17>
<line-18> ndp[z[i][0]] += dp[i]</line-18>
<line-19> ndp[z[i][1]] += dp[i]</line-19>
<line-20> dp = ndp</line-20>
<line-21>res = dp[m]</line-21>
<line-22></line-22>
<line-23>for k in range(1, m):</line-23>
<line-24> s0 = 0</line-24>
<line-25> for c in s[-k:]:</line-25>
<line-26> s0 = z[s0][c]</line-26>
<line-27> dp = [0 for _ in range(m+1)]</line-27>
<line-28> dp[s0] = 1</line-28>
<line-29> for i in range(n - k):</line-29>
<line-30> ndp = [0 for _ in range(m+1)]</line-30>
<line-31> for i in range(m+1):</line-31>
<line-32> ndp[z[i][0]] += dp[i]</line-32>
<line-33> ndp[z[i][1]] += dp[i]</line-33>
<line-34> dp = ndp</line-34>
<line-35> for s1 in range(m): # skip m</line-35>
<line-36> v = dp[s1]</line-36>
<line-37> for c in s[-k:]:</line-37>
<line-38> if s1 == m: v = 0</line-38>
<line-39> s1 = z[s1][c]</line-39>
<line-41>print(res)</line-41>
|
{"code": "<line-2>s=[c=='1' for c in input()]</line-2>\n<line-40> if s1 == m: res += v</line-40>", "lines": [2, 40]}
#### 0
|
<line-1>from math import *</line-1>
<line-3>a = []</line-3>
<line-4>n = int(input())</line-4>
<line-5>for i in range(n):</line-5>
<line-6> x,y = list(map(int,input().split()))</line-6>
<line-7> # calculate counterclockwise angle between (1,0) and this vector</line-7>
<line-8> t = acos(x/sqrt(x**2+y**2))</line-8>
<line-9> a.append((i+1,[2*pi-t,t][y>=0],x,y))</line-9>
<line-10>cmp = lambda x:x[1]</line-10>
<line-11>a = sorted(a,key=cmp)</line-11>
<line-12># construct pairs for adjacent vectors</line-12>
<line-13>b = []</line-13>
<line-14>for i in range(n):</line-14>
<line-15> i1,i2 = a[i][0],a[(i+1)%n][0]</line-15>
<line-16> x1,y1 = a[i][2:]</line-16>
<line-17> x2,y2 = a[(i+1)%n][2:]</line-17>
<line-18> inner_prod = x1*x2 + y1*y2</line-18>
<line-19> inner_prod *= abs(inner_prod)</line-19>
<line-20> norm_prod = ((x1**2+y1**2)*(x2**2+y2**2))</line-20>
<line-21> b.append((i1,i2,inner_prod,norm_prod))</line-21>
<line-22># find the nearest vector</line-22>
<line-23>better = lambda p1,p2: p1[2]*p2[3]>p2[2]*p1[3]</line-23>
<line-24>ans = b[-1]</line-24>
<line-25>for i in range(n):</line-25>
<line-26> if better(b[i],ans):</line-26>
<line-28>print(ans[0],ans[1])</line-28>
|
{"code": "<line-2># stores counterclockwise angle between vector (1,0) and each vector in a</line-2>\n<line-27> ans = b[i]</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>d, k, a, b, t = list(map(int, input().split()))</line-1>
<line-2></line-2>
<line-4>t2 = d * a + ((d - 1) // k) * t</line-4>
<line-5>t3 = max(0, d - k) * b + min(k, d) * a</line-5>
<line-6>dd = d % k</line-6>
<line-7>d1 = d - dd</line-7>
<line-9></line-9>
<line-10>print(min([t1, t2, t3, t4]))</line-10>
|
{"code": "<line-3>t1 = d * b</line-3>\n<line-8>t4 = d1 * a + max(0, (d1 // k - 1) * t) + dd * b</line-8>", "lines": [3, 8]}
#### 0
|
<line-1>n, k = map(int, input().split())</line-1>
<line-3>i = 1</line-3>
<line-4>n1 = n</line-4>
<line-5>while i * i <= n:</line-5>
<line-6> if n % i == 0:</line-6>
<line-7> div.append(i)</line-7>
<line-8> div.append(n // i)</line-8>
<line-9> i += 1</line-9>
<line-10>div.sort()</line-10>
<line-11>mx = -1</line-11>
<line-12>for i in range(len(div)):</line-12>
<line-13> a = div[i] * k * (k + 1) // 2</line-13>
<line-14> if a <= n:</line-14>
<line-15> mx = div[i]</line-15>
<line-16>if mx == -1:</line-16>
<line-17> print(-1)</line-17>
<line-18>else:</line-18>
<line-19> for i in range(k - 1):</line-19>
<line-21> print(n - mx * k * (k - 1) // 2)</line-21>
<line-22></line-22>
<line-23> </line-23>
|
{"code": "<line-2>div = []</line-2>\n<line-20> print(mx * (i + 1), end= \" \")</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>ct=0</line-1>
<line-3>x=[0]*5</line-3>
<line-4>for i in range(1, b+1):</line-4>
<line-5> x[i%5]+=1</line-5>
<line-6>for i in range(1, a+1):</line-6>
<line-8>print(ct)</line-8>
|
{"code": "<line-2>a, b = list(map(int, input().split(' ')))</line-2>\n<line-7> ct+=x[(0-i)%5]</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>N, X = list(map(int, input().split()))</line-1>
<line-3></line-3>
<line-4>dp = [[0]*4 for _ in range(N+1)]</line-4>
<line-5></line-5>
<line-6>for i in range(1, N+1):</line-6>
<line-7> dp[i][0] = max(dp[i-1][0] + A[i-1], 0)</line-7>
<line-8> dp[i][1] = max(dp[i-1][1] + A[i-1] * X, dp[i][0])</line-8>
<line-9> dp[i][2] = max(dp[i-1][2] + A[i-1], dp[i][1])</line-9>
<line-11></line-11>
<line-12>print(dp[N][3])</line-12>
|
{"code": "<line-2>A = [int(a) for a in input().split()]</line-2>\n<line-10> dp[i][3] = max(dp[i-1][3], dp[i][2])</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>def main():</line-1>
<line-3> m, n, k = list(map(int, input().split()))</line-3>
<line-4> if n < m:</line-4>
<line-5> n, m = m, n</line-5>
<line-6> lo, hi = 1, k + 1</line-6>
<line-7> while lo + 1 < hi:</line-7>
<line-8> mid = (lo + hi) // 2</line-8>
<line-9> t = mid - 1</line-9>
<line-10> v = min(int(sqrt(t)), m)</line-10>
<line-11> tn, tm = (t - 1) // m, t // n</line-11>
<line-12> vv = [t // i for i in range(tm + 1, v + 1)]</line-12>
<line-13> if t // n * (n + m) + sum(vv) * 2 + max(min((tn - tm), len(vv)) * m, 0) - v * v - sum(</line-13>
<line-14> vv[:max(min(tn - tm, len(vv)), 0)]) < k:</line-14>
<line-15> lo = mid</line-15>
<line-16> else:</line-16>
<line-17> hi = mid</line-17>
<line-18> print(lo)</line-18>
<line-19></line-19>
<line-20></line-20>
<line-21>def __starting_point():</line-21>
<line-23></line-23>
<line-24>__starting_point()</line-24>
|
{"code": "<line-2> from math import sqrt</line-2>\n<line-22> main()</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>k = int(input())</line-1>
<line-2></line-2>
<line-4> print(k)</line-4>
<line-5>else:</line-5>
<line-6> num_arr = [9*(i+1)* 10**i for i in range(11)]</line-6>
<line-7></line-7>
<line-8> index = 0</line-8>
<line-9></line-9>
<line-10> while True:</line-10>
<line-11> if k<=num_arr[index]:</line-11>
<line-12> break</line-12>
<line-13> else:</line-13>
<line-14> k -= num_arr[index]</line-14>
<line-15> index += 1</line-15>
<line-16></line-16>
<line-17> digit = index+1</line-17>
<line-18> k += digit-1</line-18>
<line-19></line-19>
<line-20></line-20>
<line-21> num = k//digit</line-21>
<line-22> offset = k%digit</line-22>
<line-23></line-23>
<line-25></line-25>
<line-26> print(string_num[offset])</line-26>
<line-27></line-27>
|
{"code": "<line-3>if k<=9:</line-3>\n<line-24> string_num = str(10**(digit-1)+ num-1)</line-24>", "lines": [3, 24]}
#### 0
|
<line-1>n, m, r = map(int, input().split())</line-1>
<line-3>B = list(map(int, input().split()))</line-3>
<line-4>x = min(S)</line-4>
<line-5>y = max(B)</line-5>
<line-6>cnt = r % x</line-6>
<line-7>act = r // x</line-7>
<line-9>print(max(r, cnt))</line-9>
|
{"code": "<line-2>S = list(map(int, input().split()))</line-2>\n<line-8>cnt += act * y</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>s = input()</line-1>
<line-3>if len(s)%2==0:</line-3>
<line-4> n = (len(s)-1)//2+1</line-4>
<line-5>else:</line-5>
<line-6> n = (len(s)-1)//2</line-6>
<line-7>for i in range(n, len(s)-1):</line-7>
<line-8> a = i</line-8>
<line-9> b = len(s)-i-1</line-9>
<line-10> if s[:a+1]==s[b:]:</line-10>
<line-11> print('YES')</line-11>
<line-12> print(s[:a+1])</line-12>
<line-13> t = 1</line-13>
<line-14> break</line-14>
<line-16> print('NO')</line-16>
|
{"code": "<line-2>t = 0</line-2>\n<line-15>if t==0:</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>for r in range(100):</line-3>
<line-4> a = 1</line-4>
<line-5> b = 2**(r + 1) - 3</line-5>
<line-6> c = -2 * n</line-6>
<line-7> d = b * b - 4 * a * c</line-7>
<line-8> if d < 0:</line-8>
<line-9> continue</line-9>
<line-10> le = 0</line-10>
<line-11> ri = d</line-11>
<line-12> while le < ri:</line-12>
<line-13> c = (le + ri) // 2</line-13>
<line-14> if c * c < d:</line-14>
<line-15> le = c + 1</line-15>
<line-16> else:</line-16>
<line-17> ri = c</line-17>
<line-18> if le * le == d:</line-18>
<line-19> if (-b - le) % 4 == 2 and -b - le > 0:</line-19>
<line-20> res.add((-b - le) // 2 * 2**r)</line-20>
<line-21> if (-b + le) % 4 == 2 and -b + le > 0:</line-21>
<line-22> res.add((-b + le) // 2 * 2**r)</line-22>
<line-23>for i in sorted(list(res)):</line-23>
<line-24> print(i)</line-24>
<line-26> print(-1)</line-26>
|
{"code": "<line-2>res = set()</line-2>\n<line-25>if not list(res):</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>from collections import Counter</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>def main():</line-5>
<line-6> n, = r()</line-6>
<line-7> s = input()</line-7>
<line-8> cost = list(r())</line-8>
<line-9></line-9>
<line-10> ans = 0</line-10>
<line-11></line-11>
<line-12> cnt = Counter()</line-12>
<line-13></line-13>
<line-14> for i in range(n // 2):</line-14>
<line-15> if s[i] == s[n - 1 - i]:</line-15>
<line-16> ans += min(cost[i], cost[n - 1 - i])</line-16>
<line-17> cnt[s[i]] += 1</line-17>
<line-18> total = sum(cnt.values())</line-18>
<line-19> if total > 0:</line-19>
<line-20> ch, occ = cnt.most_common(1)[0]</line-20>
<line-21> avail = []</line-21>
<line-22> if occ > total - occ:</line-22>
<line-23> for i in range(n // 2):</line-23>
<line-24> if s[i] != s[n - 1 - i] and s[i] != ch and s[n - 1 - i] != ch:</line-24>
<line-25> avail.append(min(cost[i], cost[n - 1 - i]))</line-25>
<line-26> avail.sort()</line-26>
<line-27> ans += sum(avail[:2 * occ - total])</line-27>
<line-28></line-28>
<line-30></line-30>
<line-31>main()</line-31>
|
{"code": "<line-3>r = lambda: list(map(int, input().split()))</line-3>\n<line-29>\tprint(sum(cost) - ans)</line-29>", "lines": [3, 29]}
#### 0
|
<line-1>w,m=map(int,input().split())</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>while(m>0 and bb):</line-5>
<line-6> x=m%w</line-6>
<line-7> if x==1:m-=1</line-7>
<line-8> elif x==w-1:m+=1</line-8>
<line-9> elif x!=0:bb=False</line-9>
<line-10> m//=w</line-10>
<line-11> </line-11>
<line-13>else:print("NO")</line-13>
|
{"code": "<line-3>bb=True</line-3>\n<line-12>if bb:print(\"YES\")</line-12>", "lines": [3, 12]}
#### 0
|
<line-1>from collections import defaultdict</line-1>
<line-2></line-2>
<line-4> as_bin = bin(n)[2:]</line-4>
<line-5> cnt = defaultdict(int)</line-5>
<line-6> cnt.update({i : 1 for i, b in enumerate(reversed(as_bin)) if b == '1'})</line-6>
<line-7> curr_len = len(cnt)</line-7>
<line-8> curr_pow = len(as_bin) - 1</line-8>
<line-9></line-9>
<line-10> if curr_len > k:</line-10>
<line-11> return None</line-11>
<line-12></line-12>
<line-13> while True:</line-13>
<line-14> new_len = curr_len + cnt[curr_pow]</line-14>
<line-15> if new_len > k:</line-15>
<line-16> break</line-16>
<line-17> cnt[curr_pow - 1] += 2 * cnt[curr_pow]</line-17>
<line-18> del cnt[curr_pow]</line-18>
<line-19> curr_pow -= 1</line-19>
<line-20> curr_len = new_len</line-20>
<line-21></line-21>
<line-22> i = min(cnt.keys())</line-22>
<line-23> while curr_len < k:</line-23>
<line-24> cnt[i] -= 1</line-24>
<line-25> cnt[i - 1] += 2</line-25>
<line-26> curr_len += 1</line-26>
<line-27> i -= 1</line-27>
<line-28></line-28>
<line-29> ans = []</line-29>
<line-30> for i in sorted(list(cnt.keys()), reverse=True):</line-30>
<line-31> ans.extend([i] * cnt[i])</line-31>
<line-32> return ans</line-32>
<line-33></line-33>
<line-34>n, k = [int(v) for v in input().split()]</line-34>
<line-35>ans = solve(n, k)</line-35>
<line-36></line-36>
<line-37>if ans is None:</line-37>
<line-38> print('No')</line-38>
<line-39>else:</line-39>
<line-41> print(' '.join(str(c) for c in ans))</line-41>
|
{"code": "<line-3>def solve(n, k):</line-3>\n<line-40> print('Yes')</line-40>", "lines": [3, 40]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.