question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1>import heapq</line-1>
<line-3>d = list(map(int,input().split()))</line-3>
<line-4>pq = [-d[0]]</line-4>
<line-5>heapq.heapify(pq)</line-5>
<line-6>ans = 0</line-6>
<line-7>for i in range(1,n):</line-7>
<line-8> temp = i - d[i]</line-8>
<line-9> heapq.heappush(pq,temp)</line-9>
<line-10> if heapq.nsmallest(1,pq)[0] < temp:</line-10>
<line-11> ans += temp - heapq.nsmallest(1,pq)[0]</line-11>
<line-13>print(ans)</line-13>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-12> heapq.heappushpop(pq,temp)</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>seq = inp.split(' ')</line-3>
<line-4>seq = [ abs(int(x)) for x in seq ]</line-4>
<line-5>Max = max(seq)</line-5>
<line-6>nxt = [0] * n</line-6>
<line-7>cnt = [0] * n</line-7>
<line-8>pos = [n] * (Max+1)</line-8>
<line-9>for i in range(n-1, -1, -1):</line-9>
<line-10> nxt[i] = pos[seq[i]]</line-10>
<line-11> pos[seq[i]] = i</line-11>
<line-12>for i in range(0, Max+1):</line-12>
<line-13> j = pos[i]</line-13>
<line-14> while(j<n):</line-14>
<line-15> front = sum(cnt[0:j])</line-15>
<line-16> back = sum(cnt[j+1:n])</line-16>
<line-17> if(front < back):</line-17>
<line-18> seq[j] = 0 - seq[j]</line-18>
<line-19> j = nxt[j]</line-19>
<line-20> j = pos[i]</line-20>
<line-21> while(j < n):</line-21>
<line-22> cnt[j] = 1</line-22>
<line-23> j = nxt[j]</line-23>
<line-24>#for i in range(0, n-1):</line-24>
<line-25># print(seq[i], sep=' ')</line-25>
<line-26>#print(seq[n-1])</line-26>
<line-27>inv = 0</line-27>
<line-28>for i in range(len(seq)):</line-28>
<line-29> for j in range(i+1, len(seq)):</line-29>
<line-30> if(seq[i] > seq[j]):</line-30>
<line-32>print(inv)</line-32>
|
{"code": "<line-2>inp = input()</line-2>\n<line-31> inv += 1</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>def f(m):</line-1>
<line-3> l = 0</line-3>
<line-4> for i in range(n):</line-4>
<line-5> while l < n and v[l] < v[i] - m:</line-5>
<line-6> l += 1</line-6>
<line-7> if l - 1 > i - k:</line-7>
<line-8> dp[i] = False</line-8>
<line-9> else:</line-9>
<line-10> dp[i] = (sdp[i - k + 1] != sdp[l - 1])</line-10>
<line-11> sdp[i + 1] = sdp[i] + (1 if dp[i] else 0)</line-11>
<line-12> return dp[n - 1]</line-12>
<line-13></line-13>
<line-14>n, k = list(map(int, input().split()))</line-14>
<line-15>dp = [False for i in range(n + 2)]</line-15>
<line-16>sdp = [0 for i in range(n + 2)]</line-16>
<line-17>dp[-1] = True</line-17>
<line-18>sdp[0] = 1</line-18>
<line-19>v = list(map(int, input().split()))</line-19>
<line-20>v.sort()</line-20>
<line-21>le = -1</line-21>
<line-22>r = v[-1] - v[0]</line-22>
<line-23>while r - le > 1:</line-23>
<line-24> m = (r + le) // 2</line-24>
<line-25> if f(m):</line-25>
<line-26> r = m</line-26>
<line-27> else:</line-27>
<line-29>print(r)</line-29>
|
{"code": "<line-2> nonlocal dp, sdp</line-2>\n<line-28> le = m </line-28>", "lines": [2, 28]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>def solve(ax,ay,bx,by,cx,cy):</line-4>
<line-5> x = ax+bx+cx</line-5>
<line-6> y = ay+by+cy</line-6>
<line-7> x -= x//3+1</line-7>
<line-8> y -= y//3+1</line-8>
<line-9> if x==y:</line-9>
<line-10> return x if 0 <= x <= 1 else abs(x)+1</line-10>
<line-11> else:</line-11>
<line-12> return max(abs(x), abs(y))</line-12>
<line-13></line-13>
<line-14>T = int(input())</line-14>
<line-15>for _ in range(T):</line-15>
<line-17> print(solve(ax,ay,bx,by,cx,cy))</line-17>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-16> ax,ay,bx,by,cx,cy = map(int,input().split())</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>def main():</line-1>
<line-3> inv_n = [0]*1001</line-3>
<line-4> nCr = [[1]*(i+1) for i in range(1001)]</line-4>
<line-5> for i in range(1001):</line-5>
<line-6> inv_n[i] = pow(i, mod-2, mod)</line-6>
<line-7> for i in range(2, 1001):</line-7>
<line-8> for j in range(1, i):</line-8>
<line-9> nCr[i][j] = (nCr[i-1][j-1]+nCr[i-1][j]) % mod</line-9>
<line-10> n, a, b, c, d = list(map(int, input().split()))</line-10>
<line-11> dp = [0]*(n+1)</line-11>
<line-12> dp[0] = 1</line-12>
<line-13></line-13>
<line-14> for A in range(b, a-1, -1):</line-14>
<line-15> dp2 = [i for i in dp]</line-15>
<line-16> for N in range(n-c*A, -1, -1):</line-16>
<line-17> e = dp[N]</line-17>
<line-18> if e:</line-18>
<line-19> temp = 1</line-19>
<line-20> for C in range(1, c):</line-20>
<line-21> temp = temp*nCr[n-N-(C-1)*A][A]*inv_n[C] % mod</line-21>
<line-22> for C in range(c, min(d, (n-N)//A)+1):</line-22>
<line-23> temp = temp*nCr[n-N-(C-1)*A][A]*inv_n[C] % mod</line-23>
<line-24> dp2[N+C*A] = (dp2[N+C*A]+temp*e) % mod</line-24>
<line-25> dp = dp2</line-25>
<line-27></line-27>
<line-28></line-28>
<line-29>main()</line-29>
|
{"code": "<line-2> mod = 10**9+7</line-2>\n<line-26> print((dp[-1]))</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>rd = lambda: list(map(int, input().split()))</line-1>
<line-2></line-2>
<line-4> if f[x]!=x: f[x] = root(f[x])</line-4>
<line-5> return f[x]</line-5>
<line-6></line-6>
<line-7>n, m = rd()</line-7>
<line-8>N = list(range(n))</line-8>
<line-9>f = list(N)</line-9>
<line-10>lang = [0]*n</line-10>
<line-11>for i in N: lang[i] = set(rd()[1:])</line-11>
<line-12>for i in N:</line-12>
<line-13> for j in N[:i]:</line-13>
<line-14> rj = root(j)</line-14>
<line-15> if lang[rj].intersection(lang[i]):</line-15>
<line-16> f[rj] = i</line-16>
<line-18>print(sum(1 for i in N if i==root(i)) - (sum(map(len, lang))>0))</line-18>
|
{"code": "<line-3>def root(x):</line-3>\n<line-17> lang[i] = lang[i].union(lang[rj])</line-17>", "lines": [3, 17]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>N, Q = list(map(int, readline().split()))</line-4>
<line-5>state = [[False]*(N+2) for _ in range(2)]</line-5>
<line-6></line-6>
<line-7>cnt = 0</line-7>
<line-8></line-8>
<line-9>Ans = [None]*Q</line-9>
<line-10>for qu in range(Q):</line-10>
<line-11> r, c = list(map(int, readline().split()))</line-11>
<line-12> r -= 1</line-12>
<line-13> c -= 1</line-13>
<line-14> state[r][c] = not state[r][c]</line-14>
<line-15> res = state[r-1][c-1] + state[r-1][c] + state[r-1][c+1] </line-15>
<line-16> if state[r][c]:</line-16>
<line-17> cnt += res</line-17>
<line-18> else:</line-18>
<line-19> cnt -= res</line-19>
<line-21>print('\n'.join(Ans))</line-21>
|
{"code": "<line-2>readline = sys.stdin.readline</line-2>\n<line-20> Ans[qu] = 'No' if cnt else 'Yes'</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>n, k = [int(c) for c in input().split()]</line-1>
<line-3>for i in range(k):</line-3>
<line-4> ak = [int(c) for c in input().split()]</line-4>
<line-5> a.append(ak[1:])</line-5>
<line-6></line-6>
<line-7>total = k - 1</line-7>
<line-8></line-8>
<line-9>for ak in a:</line-9>
<line-10> if ak[0] == 1:</line-10>
<line-11> j = 1</line-11>
<line-12> while j <= len(ak) - 1:</line-12>
<line-13> if ak[j] != ak[j-1] + 1:</line-13>
<line-14> break</line-14>
<line-15> j += 1</line-15>
<line-16> total += 2*(len(ak) - j)</line-16>
<line-17> else:</line-17>
<line-19></line-19>
<line-20>print(total)</line-20>
|
{"code": "<line-2>a = []</line-2>\n<line-18> total += 2*(len(ak) - 1)</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>import os</line-1>
<line-3>import sys</line-3>
<line-4>from typing import List, Dict</line-4>
<line-5></line-5>
<line-6></line-6>
<line-7>class Int:</line-7>
<line-8> def __init__(self, val):</line-8>
<line-9> self.val = val</line-9>
<line-10></line-10>
<line-11> def get(self):</line-11>
<line-12> return self.val + 111</line-12>
<line-13></line-13>
<line-14>class Unique:</line-14>
<line-15> def __init__(self):</line-15>
<line-16> self.s = set()</line-16>
<line-17></line-17>
<line-18> def add(self, val : int):</line-18>
<line-19> self.s.add(val)</line-19>
<line-20></line-20>
<line-21> def __contains__(self, item : int) -> bool:</line-21>
<line-22> return self.s.__contains__(item)</line-22>
<line-23></line-23>
<line-24>def ceil(top : int, bottom : int) -> int:</line-24>
<line-25> return (top + bottom - 1) // bottom</line-25>
<line-26></line-26>
<line-27>def concat(l : List[int]):</line-27>
<line-28> return "".join(map(str, l))</line-28>
<line-29></line-29>
<line-30>def get(d : Dict[int, str], val : int) -> Dict[int, str]:</line-30>
<line-31> return d[val]</line-31>
<line-32></line-32>
<line-33></line-33>
<line-34>#guy who wants small moves first</line-34>
<line-35>#then guy who wants large moves</line-35>
<line-36></line-36>
<line-37>#so lets say we have 4 positions</line-37>
<line-38># 1, 2, 3, 4</line-38>
<line-39>#small wants to ban edges, because if he bans 2 or 3 he is fucked</line-39>
<line-40>#so he bans 1</line-40>
<line-41># and we have 2, 3, 4</line-41>
<line-42># then large bans middle so we have 2, 4 and the ans is 2</line-42>
<line-43># 0, 1, 2, 3, 4, 5, 6, 7</line-43>
<line-44># 0, 1, 2, 3, 4, 5, 6</line-44>
<line-45># 0, 1, 2, 3, 5, 6</line-45>
<line-46># 0, 1, 2, 3, 5</line-46>
<line-47># 0, 1, 3, 5</line-47>
<line-48># 0, 1, 3</line-48>
<line-49># 0, 3</line-49>
<line-50></line-50>
<line-51></line-51>
<line-52># 0, 1, 2, 3, 4, 5, 6, 7</line-52>
<line-53># 0, 4</line-53>
<line-54></line-54>
<line-55># # 0, 3</line-55>
<line-56></line-56>
<line-57></line-57>
<line-58>#1 5 9 19 21 22</line-58>
<line-59># 5 9 19 21 22</line-59>
<line-60># 5 19 21 22</line-60>
<line-61># 19 21 22</line-61>
<line-62></line-62>
<line-63></line-63>
<line-64># 0, 1, 3, 7, 15</line-64>
<line-65># 0, 1, 7, 15</line-65>
<line-66># 0, 1, 7</line-66>
<line-67># 0, 7</line-67>
<line-68>def slowsolve(a):</line-68>
<line-69> a.sort()</line-69>
<line-70> small = True</line-70>
<line-71> while len(a) > 2:</line-71>
<line-72> if small:</line-72>
<line-73> if a[1] - a[0] > a[-1] - a[-2]:</line-73>
<line-74> a.pop(0)</line-74>
<line-75> else:</line-75>
<line-76> a.pop()</line-76>
<line-77> small = False</line-77>
<line-78> else:</line-78>
<line-79> a.pop(len(a) // 2)</line-79>
<line-80> small = True</line-80>
<line-81></line-81>
<line-82> return a[1] - a[0]</line-82>
<line-83></line-83>
<line-84></line-84>
<line-85>def solve(a):</line-85>
<line-86> a.sort()</line-86>
<line-87> candelete = len(a) // 2 - 1</line-87>
<line-88> res = 10 ** 18</line-88>
<line-89> for leftdelete in range(0, candelete + 1):</line-89>
<line-90> leftrem = leftdelete</line-90>
<line-91> rightrem = leftdelete + candelete + 1</line-91>
<line-92> res = min(res, a[rightrem] - a[leftrem])</line-92>
<line-93> return res</line-93>
<line-94></line-94>
<line-95></line-95>
<line-96></line-96>
<line-97>def prt(l): return print(' '.join(l))</line-97>
<line-98>def rv(): return map(int, input().split())</line-98>
<line-99>def rl(n): return [list(map(int, input().split())) for _ in range(n)]</line-99>
<line-100>if os.path.exists("test.txt"): sys.stdin = open("test.txt")</line-100>
<line-101></line-101>
<line-102>n, = rv()</line-102>
<line-103>a, = rl(1)</line-103>
<line-104></line-104>
<line-105># a = sorted([random.randrange(10**2) for _ in range(6)])</line-105>
<line-106># print(a)</line-106>
<line-108>print(solve(a))</line-108>
|
{"code": "<line-2>import random</line-2>\n<line-107># print(solve(a), slowsolve(a))</line-107>", "lines": [2, 107]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>t[0][0] = 0</line-3>
<line-4>n += 1</line-4>
<line-5>u = [-1e7] * n</line-5>
<line-6>v = [0] * n</line-6>
<line-7>for i, (j, a) in list(enumerate(t, 1))[::-1]:</line-7>
<line-8> u[i] = max(u[i], v[i] + a)</line-8>
<line-10>print(u[1])</line-10>
|
{"code": "<line-2>t = [list(map(int, input().split())) for q in range(n)]</line-2>\n<line-9> v[j], u[j] = max(v[j] + v[i], u[j] + u[i]), max(v[j] + u[i], u[j] + v[i])</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>from collections import Counter </line-4>
<line-5></line-5>
<line-6>def getpar(Edge, p):</line-6>
<line-7> N = len(Edge)</line-7>
<line-8> par = [0]*N</line-8>
<line-9> par[0] = -1</line-9>
<line-10> par[p] -1</line-10>
<line-11> stack = [p]</line-11>
<line-12> visited = set([p])</line-12>
<line-13> while stack:</line-13>
<line-14> vn = stack.pop()</line-14>
<line-15> for vf in Edge[vn]:</line-15>
<line-16> if vf in visited:</line-16>
<line-17> continue</line-17>
<line-18> visited.add(vf)</line-18>
<line-19> par[vf] = vn</line-19>
<line-20> stack.append(vf)</line-20>
<line-21> return par</line-21>
<line-22></line-22>
<line-23>def topological_sort_tree(E, r):</line-23>
<line-24> Q = [r]</line-24>
<line-25> L = []</line-25>
<line-26> visited = set([r])</line-26>
<line-27> while Q:</line-27>
<line-28> vn = Q.pop()</line-28>
<line-29> L.append(vn)</line-29>
<line-30> for vf in E[vn]:</line-30>
<line-31> if vf not in visited:</line-31>
<line-32> visited.add(vf)</line-32>
<line-33> Q.append(vf)</line-33>
<line-34> return L</line-34>
<line-35></line-35>
<line-36>def getcld(p):</line-36>
<line-37> res = [[] for _ in range(len(p))]</line-37>
<line-38> for i, v in enumerate(p[1:], 1):</line-38>
<line-39> res[v].append(i)</line-39>
<line-40> return res</line-40>
<line-41></line-41>
<line-42></line-42>
<line-43> </line-43>
<line-44></line-44>
<line-45>N = int(readline())</line-45>
<line-46>We = list(map(int, readline().split()))</line-46>
<line-47>Edge = [[] for _ in range(N)]</line-47>
<line-48>Cost = Counter()</line-48>
<line-49>geta = N+1</line-49>
<line-50>for _ in range(N-1):</line-50>
<line-51> a, b, c = list(map(int, readline().split()))</line-51>
<line-52> a -= 1</line-52>
<line-53> b -= 1</line-53>
<line-54> Edge[a].append(b)</line-54>
<line-55> Edge[b].append(a)</line-55>
<line-56> Cost[b*geta+a] = c</line-56>
<line-57> Cost[a*geta+b] = c</line-57>
<line-58>P = getpar(Edge, 0)</line-58>
<line-59>L = topological_sort_tree(Edge, 0)</line-59>
<line-60>C = getcld(P)</line-60>
<line-61></line-61>
<line-62></line-62>
<line-63>dp = [0]*N</line-63>
<line-64>candi = [[0, 0] for _ in range(N)]</line-64>
<line-65>ans = 0</line-65>
<line-66>for l in L[::-1][:-1]:</line-66>
<line-67> dp[l] += We[l]</line-67>
<line-68> p = P[l]</line-68>
<line-69> k = dp[l] - Cost[l*geta + p]</line-69>
<line-70> if k > 0:</line-70>
<line-71> dp[p] = max(dp[p], k)</line-71>
<line-72> candi[p].append(k)</line-72>
<line-73> </line-73>
<line-74> res = max(candi[l])</line-74>
<line-75> candi[l].remove(res)</line-75>
<line-76> ans = max(ans, We[l] + res + max(candi[l]))</line-76>
<line-77></line-77>
<line-78>res = max(candi[0])</line-78>
<line-79>candi[0].remove(res)</line-79>
<line-81>print(ans) </line-81>
|
{"code": "<line-2>readline = sys.stdin.readline</line-2>\n<line-80>ans = max(ans, We[0] + res + max(candi[0]))</line-80>", "lines": [2, 80]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>if n==1:</line-3>
<line-4> print(1,1)</line-4>
<line-5> print(0)</line-5>
<line-6> print(1,1)</line-6>
<line-7> print(0)</line-7>
<line-8> print(1,1)</line-8>
<line-9> print(-L[0])</line-9>
<line-10>else:</line-10>
<line-11> print(1,n-1)</line-11>
<line-12> for i in range(n-1):print(L[i]*(n-1),end=' ')</line-12>
<line-13> print()</line-13>
<line-14> print(n,n)</line-14>
<line-15> print(-L[n-1])</line-15>
<line-16> print(1,n)</line-16>
<line-18> print(0)</line-18>
|
{"code": "<line-2>L=list(map(int,input().split()))</line-2>\n<line-17> for i in range(n-1):print(-L[i]*n,end=' ')</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>#!/usr/bin/env pypy3</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>def make_nCr_mod(max_n=2*10**5 + 100, mod=10**9 + 7):</line-5>
<line-6> fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)</line-6>
<line-7> fact[0] = 1</line-7>
<line-8> for i in range(max_n):</line-8>
<line-9> fact[i + 1] = fact[i] * (i + 1) % mod</line-9>
<line-10></line-10>
<line-11> inv_fact[-1] = pow(fact[-1], mod - 2, mod)</line-11>
<line-12> for i in reversed(range(max_n)):</line-12>
<line-13> inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod</line-13>
<line-14></line-14>
<line-15> def nCr_mod(n, r):</line-15>
<line-16> res = 1</line-16>
<line-17> while n or r:</line-17>
<line-18> a, b = n % mod, r % mod</line-18>
<line-19> if a < b:</line-19>
<line-20> return 0</line-20>
<line-21> res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod</line-21>
<line-22> n //= mod</line-22>
<line-23> r //= mod</line-23>
<line-24> return res</line-24>
<line-25></line-25>
<line-26> return nCr_mod</line-26>
<line-27></line-27>
<line-28>nCr_mod = make_nCr_mod()</line-28>
<line-29></line-29>
<line-30>MODULUS = 10**9+7</line-30>
<line-31></line-31>
<line-32>input()</line-32>
<line-33>A = input().split(' ')</line-33>
<line-34>A = list(map(int, A))</line-34>
<line-35></line-35>
<line-36>if len(A) == 1:</line-36>
<line-37> print(A[0])</line-37>
<line-38> return</line-38>
<line-39></line-39>
<line-40>if len(A) % 2 == 1:</line-40>
<line-41> new_A = []</line-41>
<line-42> next_plus = True</line-42>
<line-43> for i in range(len(A) - 1):</line-43>
<line-44> if next_plus:</line-44>
<line-45> new_A += [A[i] + A[i+1]]</line-45>
<line-46> else:</line-46>
<line-47> new_A += [A[i] - A[i+1]]</line-47>
<line-48> next_plus = not next_plus</line-48>
<line-49> A = new_A</line-49>
<line-50></line-50>
<line-51>if len(A) % 4 == 2:</line-51>
<line-52> new_A = []</line-52>
<line-53> for i in range(len(A) // 2):</line-53>
<line-54> new_A += [A[2*i] + A[2*i+1]]</line-54>
<line-55> A = new_A</line-55>
<line-56>else:</line-56>
<line-57> new_A = []</line-57>
<line-58> for i in range(len(A) // 2):</line-58>
<line-59> new_A += [A[2*i] - A[2*i+1]]</line-59>
<line-60> A = new_A</line-60>
<line-61></line-61>
<line-62># binomial sum</line-62>
<line-63></line-63>
<line-64>N = len(A)-1</line-64>
<line-65></line-65>
<line-66>ret = 0</line-66>
<line-67></line-67>
<line-68>for i in range(N+1):</line-68>
<line-69> ret += A[i]*nCr_mod(N, i)</line-69>
<line-71></line-71>
<line-72>print(ret)</line-72>
|
{"code": "<line-3>import math</line-3>\n<line-70> ret = ret % MODULUS</line-70>", "lines": [3, 70]}
#### 0
|
<line-1>from collections import Counter</line-1>
<line-3>points = Counter([tuple(map(int, input().split(' '))) for i in range(n)])</line-3>
<line-4></line-4>
<line-5>x, y = Counter([k for k, v in points.elements()]), Counter([v for k, v in points.elements()])</line-5>
<line-6></line-6>
<line-8>print(ans)</line-8>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-7>ans = sum([v*(v-1)//2 for k, v in list(x.items())])+sum([v*(v-1)//2 for k, v in list(y.items())])-sum([v*(v-1)//2 for k, v in list(points.items())])</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>from sys import*</line-1>
<line-3>def check(u, d, l, r):</line-3>
<line-4> used = [pointsx[i][1] for i in range(l)]</line-4>
<line-5> used += [pointsx[-1 - i][1] for i in range(r)]</line-5>
<line-6> used += [pointsy[i][1] for i in range(u)]</line-6>
<line-7> used += [pointsy[-1 - i][1] for i in range(d)]</line-7>
<line-8> if len(set(used)) > k:</line-8>
<line-9> return DOHERA</line-9>
<line-10> dx = pointsx[-1 - r][0] - pointsx[l][0]</line-10>
<line-11> dy = pointsy[-1 - d][0] - pointsy[u][0]</line-11>
<line-12> dx += dx & 1</line-12>
<line-13> dy += dy & 1</line-13>
<line-14> dx = max(2, dx)</line-14>
<line-15> dy = max(2, dy)</line-15>
<line-16> return dx * dy</line-16>
<line-17>#</line-17>
<line-18>(n, k) = list(map(int, input().split()))</line-18>
<line-19>pointsx = []</line-19>
<line-20>pointsy = []</line-20>
<line-21>DOHERA = 10 ** 228</line-21>
<line-22>for i in range(n):</line-22>
<line-23> a = list(map(int, input().split()))</line-23>
<line-24> pointsx += [(a[0] + a[2], i)]</line-24>
<line-25> pointsy += [(a[1] + a[3], i)]</line-25>
<line-26>(pointsx, pointsy) = (sorted(pointsx), sorted(pointsy))</line-26>
<line-27>ans = DOHERA</line-27>
<line-28>for u in range(0, k + 1):</line-28>
<line-29> for d in range(0, k + 1):</line-29>
<line-30> for l in range(0, k + 1):</line-30>
<line-31> for r in range(0, k + 1):</line-31>
<line-32> if l + r <= k and u + d <= k:</line-32>
<line-33> ans = min(ans, check(u, d, l, r))</line-33>
<line-35></line-35>
<line-36></line-36>
<line-37></line-37>
<line-38># Made By Mostafa_Khaled</line-38>
|
{"code": "<line-2>#</line-2>\n<line-34>print(ans // 4)</line-34>", "lines": [2, 34]}
#### 0
|
<line-1>def maximum_xor_secondary(sequence):</line-1>
<line-3> for x in sequence:</line-3>
<line-4> while stack:</line-4>
<line-5> answer = max(answer, stack[-1] ^ x)</line-5>
<line-6> if stack[-1] > x:</line-6>
<line-7> break</line-7>
<line-8> else:</line-8>
<line-9> stack.pop()</line-9>
<line-10> stack.append(x)</line-10>
<line-11></line-11>
<line-12> return answer</line-12>
<line-13></line-13>
<line-14></line-14>
<line-15>size, num = input(), [int(x) for x in input().split()]</line-15>
<line-16></line-16>
<line-17></line-17>
<line-19></line-19>
<line-20></line-20>
<line-21></line-21>
<line-22></line-22>
<line-23></line-23>
<line-24># Made By Mostafa_Khaled</line-24>
|
{"code": "<line-2> stack, answer = [], 0</line-2>\n<line-18>print(maximum_xor_secondary(num))</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>INF = 10 ** 18 + 179</line-1>
<line-3>a.sort()</line-3>
<line-4>dp, l = [[0] * (k - n % k + 1) for x in range(n % k + 1)], n // k</line-4>
<line-5>for i in range(n % k + 1):</line-5>
<line-6> for j in range(k - n % k + 1):</line-6>
<line-7> pos = i * (l + 1) + j * l</line-7>
<line-8> dp[i][j] = min((dp[i - 1][j] + a[pos - 1] - a[pos - l - 1] if i else INF), \</line-8>
<line-10>print(dp[n % k][k - n % k])</line-10>
|
{"code": "<line-2>[n, k], a = [list(map(int, input().split())) for x in range(2)]</line-2>\n<line-9> (dp[i][j - 1] + a[pos - 1] - a[pos - l] if j else INF)) if (i or j) else 0</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>rd = lambda: list(map(int, input().split()))</line-1>
<line-2></line-2>
<line-4>a = sorted(rd(), reverse=True)</line-4>
<line-5>b = sorted(rd(), reverse=True)</line-5>
<line-6>if len(a) > len(b): print("YES"); return</line-6>
<line-7>for i in range(len(a)):</line-7>
<line-9>print("NO")</line-9>
|
{"code": "<line-3>rd()</line-3>\n<line-8> if a[i] > b[i]: print(\"YES\"); return</line-8>", "lines": [3, 8]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3></line-3>
<line-4>def d(a, b):</line-4>
<line-5> return (a[0]-b[0], a[1]-b[1], a[2]-b[2], a[3]-b[3], a[4]-b[4])</line-5>
<line-6></line-6>
<line-7>def m(a, b):</line-7>
<line-8> t = 0</line-8>
<line-9> for i in range(5):</line-9>
<line-10> t += a[i] * b[i]</line-10>
<line-11> return t</line-11>
<line-12></line-12>
<line-13>good_points = []</line-13>
<line-14>for i in range(n):</line-14>
<line-15> good = True</line-15>
<line-16></line-16>
<line-17> for j in range(n):</line-17>
<line-18> if j == i:</line-18>
<line-19> continue</line-19>
<line-20> </line-20>
<line-21> ab = d(p[j], p[i])</line-21>
<line-22></line-22>
<line-23> for k in range(j + 1, n):</line-23>
<line-24> if k == i:</line-24>
<line-25> continue</line-25>
<line-26> </line-26>
<line-27> ac = d(p[k], p[i])</line-27>
<line-28> </line-28>
<line-29> if m(ab, ac) > 0:</line-29>
<line-30> good = False</line-30>
<line-31> break</line-31>
<line-32> </line-32>
<line-33> if not good:</line-33>
<line-34> break</line-34>
<line-35> </line-35>
<line-36> if good:</line-36>
<line-37> good_points.append(i)</line-37>
<line-38></line-38>
<line-39>print(len(good_points))</line-39>
<line-41> print(i + 1)</line-41>
|
{"code": "<line-2>p = [tuple(map(int, input().split())) for i in range(n)]</line-2>\n<line-40>for i in good_points:</line-40>", "lines": [2, 40]}
#### 0
|
<line-1>from collections import defaultdict</line-1>
<line-2></line-2>
<line-4> group = [None] * n</line-4>
<line-5> id_ = {x: i for i, x in enumerate(xs)}</line-5>
<line-6> if a == b:</line-6>
<line-7> for x in xs:</line-7>
<line-8> if a - x not in id_:</line-8>
<line-9> return False</line-9>
<line-10> group = [0] * n</line-10>
<line-11> else:</line-11>
<line-12> for i, x in enumerate(xs):</line-12>
<line-13> if group[i] is not None:</line-13>
<line-14> continue</line-14>
<line-15> y = a - x</line-15>
<line-16> z = b - x</line-16>
<line-17> f1 = y in id_ and group[id_[y]] is None</line-17>
<line-18> f2 = z in id_ and group[id_[z]] is None</line-18>
<line-19> if f1 + f2 == 0:</line-19>
<line-20> return False</line-20>
<line-21> elif f1 + f2 == 1:</line-21>
<line-22> g = int(f2)</line-22>
<line-23> # End of link</line-23>
<line-24> link = []</line-24>
<line-25> t = a if f1 else b</line-25>
<line-26> while x in id_:</line-26>
<line-27> link.append(x)</line-27>
<line-28> x = t - x</line-28>
<line-29> if x + x == t:</line-29>
<line-30> break</line-30>
<line-31> t = a + b - t</line-31>
<line-32> # print(link)</line-32>
<line-33> if len(link) % 2 == 0:</line-33>
<line-34> for i, x in enumerate(link):</line-34>
<line-35> group[id_[x]] = g</line-35>
<line-36> elif link[0] * 2 == (b, a)[g]:</line-36>
<line-37> for i, x in enumerate(link):</line-37>
<line-38> group[id_[x]] = 1 - g</line-38>
<line-39> elif link[-1] * 2 == (a, b)[g]:</line-39>
<line-40> for i, x in enumerate(link):</line-40>
<line-41> group[id_[x]] = g</line-41>
<line-42> else:</line-42>
<line-43> # Found invalid link, answer is "NO"</line-43>
<line-44> return False</line-44>
<line-45></line-45>
<line-46> return group</line-46>
<line-47></line-47>
<line-48>n, a, b = list(map(int, input().split()))</line-48>
<line-49>xs = list(map(int, input().split()))</line-49>
<line-50>group = solve(n, a, b, xs)</line-50>
<line-51>if isinstance(group, list):</line-51>
<line-52> print('YES')</line-52>
<line-53> print(' '.join(map(str, group)))</line-53>
<line-55> print('NO')</line-55>
|
{"code": "<line-3>def solve(n, a, b, xs):</line-3>\n<line-54>else:</line-54>", "lines": [3, 54]}
#### 0
|
<line-1>def main():</line-1>
<line-3> a = list(map(int, (x for x in input())))</line-3>
<line-4> b = list(map(int, (x for x in input())))</line-4>
<line-5> x = [0] * (n - 1)</line-5>
<line-6> x[0] = b[0] - a[0]</line-6>
<line-7> for i in range(1, n - 1):</line-7>
<line-8> x[i] = b[i] - a[i] - x[i - 1]</line-8>
<line-9> if a[n - 1] + x[n - 2] != b[n - 1]:</line-9>
<line-10> print(-1)</line-10>
<line-11> return</line-11>
<line-12> cnt = sum(map(abs, x)) # prevbug: ftl</line-12>
<line-13> print(cnt)</line-13>
<line-14> cnt = min(cnt, 10 ** 5)</line-14>
<line-15> index = 0</line-15>
<line-16></line-16>
<line-17> def handle_zero_nine(cur_zero):</line-17>
<line-18> nonlocal cnt</line-18>
<line-19> nxt = index + 1</line-19>
<line-20> # cur_zero = True prevbug: preserved this line</line-20>
<line-21> while True:</line-21>
<line-22> if cur_zero and a[nxt + 1] != 9:</line-22>
<line-23> break</line-23>
<line-24> if not cur_zero and a[nxt + 1] != 0:</line-24>
<line-25> break</line-25>
<line-26> nxt += 1</line-26>
<line-27> cur_zero = not cur_zero</line-27>
<line-28> while nxt > index:</line-28>
<line-29> if cnt == 0:</line-29>
<line-30> break</line-30>
<line-31> if cur_zero:</line-31>
<line-32> print(nxt + 1, 1)</line-32>
<line-33> a[nxt] += 1</line-33>
<line-34> a[nxt + 1] += 1</line-34>
<line-35> else:</line-35>
<line-36> print(nxt + 1, -1)</line-36>
<line-37> a[nxt] -= 1</line-37>
<line-38> a[nxt + 1] -= 1</line-38>
<line-39> nxt -= 1</line-39>
<line-40> cnt -= 1</line-40>
<line-41> # print(a)</line-41>
<line-42> cur_zero = not cur_zero</line-42>
<line-43></line-43>
<line-44> while cnt > 0:</line-44>
<line-45> if a[index] == b[index]:</line-45>
<line-46> index += 1</line-46>
<line-47> continue</line-47>
<line-48> elif a[index] > b[index] and a[index + 1] == 0:</line-48>
<line-49> handle_zero_nine(True)</line-49>
<line-50> elif a[index] < b[index] and a[index + 1] == 9:</line-50>
<line-51> handle_zero_nine(False)</line-51>
<line-52> elif a[index] > b[index]:</line-52>
<line-53> print(index + 1, -1)</line-53>
<line-54> a[index] -= 1</line-54>
<line-55> a[index + 1] -= 1</line-55>
<line-56> cnt -= 1</line-56>
<line-57> # print(a)</line-57>
<line-58> elif a[index] < b[index]:</line-58>
<line-59> print(index + 1, 1)</line-59>
<line-60> a[index] += 1</line-60>
<line-61> a[index + 1] += 1</line-61>
<line-62> cnt -= 1</line-62>
<line-63> # print(a)</line-63>
<line-64></line-64>
<line-65></line-65>
<line-66>def __starting_point():</line-66>
<line-68></line-68>
<line-69>__starting_point()</line-69>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-67> main()</line-67>", "lines": [2, 67]}
#### 0
|
<line-1>q = int(input())</line-1>
<line-2></line-2>
<line-3></line-3>
<line-4></line-4>
<line-6> res = set()</line-6>
<line-7></line-7>
<line-8> while u >= 1:</line-8>
<line-9> res.add(u)</line-9>
<line-10> u //= 2</line-10>
<line-11></line-11>
<line-12> return res</line-12>
<line-13></line-13>
<line-14></line-14>
<line-15>def get_way(u, v):</line-15>
<line-16> res1 = full_way(u)</line-16>
<line-17> res2 = full_way(v)</line-17>
<line-18></line-18>
<line-19> m = max(res1 & res2)</line-19>
<line-20></line-20>
<line-21> res = set()</line-21>
<line-22> for x in res1 | res2:</line-22>
<line-23> if x > m:</line-23>
<line-24> res.add(x)</line-24>
<line-25></line-25>
<line-26> return res</line-26>
<line-27></line-27>
<line-28></line-28>
<line-29>d = {}</line-29>
<line-30></line-30>
<line-31>for i in range(q):</line-31>
<line-32> a = input().split()</line-32>
<line-33></line-33>
<line-34> if a[0] == '1':</line-34>
<line-35> v, u, w = map(int, a[1:])</line-35>
<line-36> for x in get_way(u, v):</line-36>
<line-37> if x not in d:</line-37>
<line-38> d[x] = 0</line-38>
<line-39> d[x] += w</line-39>
<line-40> else:</line-40>
<line-41> v, u = map(int, a[1:])</line-41>
<line-42> res = 0</line-42>
<line-43> for x in get_way(u, v):</line-43>
<line-44> if x in d:</line-44>
<line-46> print(res)</line-46>
|
{"code": "<line-5>def full_way(u):</line-5>\n<line-45> res += d[x]</line-45>", "lines": [5, 45]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>discount_values = [int(x) for x in sys.stdin.readline().split()]</line-4>
<line-5>n_items = int(sys.stdin.readline())</line-5>
<line-6>item_values = [int(x) for x in sys.stdin.readline().split()]</line-6>
<line-7></line-7>
<line-8>min_discount_req = 10000000</line-8>
<line-9>for discount_value in discount_values:</line-9>
<line-10> min_discount_req = min(min_discount_req, discount_value)</line-10>
<line-11>item_values.sort(reverse=True)</line-11>
<line-12></line-12>
<line-13>index = 0</line-13>
<line-14>overall_price = 0</line-14>
<line-15>while index < n_items:</line-15>
<line-16> n_left = min(min_discount_req, n_items - index)</line-16>
<line-17> for i in range(n_left):</line-17>
<line-18> overall_price += item_values[index+i]</line-18>
<line-20></line-20>
<line-21>print(overall_price)</line-21>
<line-22> </line-22>
|
{"code": "<line-3>n_discounts = int(sys.stdin.readline())</line-3>\n<line-19> index += n_left + 2</line-19>", "lines": [3, 19]}
#### 0
|
<line-1>from math import pi</line-1>
<line-3>def fft(a, lgN, rot=1): # rot=-1 for ifft</line-3>
<line-4> N = 1<<lgN</line-4>
<line-5> assert len(a)==N</line-5>
<line-6> rev = [0]*N</line-6>
<line-7> for i in range(N):</line-7>
<line-8> rev[i] = (rev[i>>1]>>1)+(i&1)*(N>>1)</line-8>
<line-9> A = [a[rev[i]] for i in range(N)]</line-9>
<line-10> h = 1</line-10>
<line-11> while h<N:</line-11>
<line-12> w_m = exp((0+1j) * rot * (pi / h))</line-12>
<line-13> for k in range(0, N, h<<1):</line-13>
<line-14> w = 1</line-14>
<line-15> for j in range(h):</line-15>
<line-16> t = w * A[k+j+h]</line-16>
<line-17> A[k+j+h] = A[k+j]-t</line-17>
<line-18> A[k+j] = A[k+j]+t</line-18>
<line-19> w *= w_m</line-19>
<line-20> h = h<<1</line-20>
<line-21> return A if rot==1 else [x/N for x in A]</line-21>
<line-22></line-22>
<line-23></line-23>
<line-24>import sys</line-24>
<line-25>ints = (int(x) for x in sys.stdin.read().split())</line-25>
<line-26></line-26>
<line-27>n, x = (next(ints) for i in range(2))</line-27>
<line-28>r = [next(ints) for i in range(n)]</line-28>
<line-29>ac = [0]*(n+1)</line-29>
<line-30>for i in range(n): ac[i+1] = (r[i]<x) + ac[i]</line-30>
<line-31></line-31>
<line-32># Multiset addition</line-32>
<line-33>min_A, min_B = 0, -ac[-1]</line-33>
<line-34>max_A, max_B = ac[-1], 0</line-34>
<line-35>N, lgN, m = 1, 0, 2*max(max_A-min_A+1, max_B-min_B+1)</line-35>
<line-36>while N<m: N,lgN = N<<1,lgN+1</line-36>
<line-37>a, b = [0]*N, [0]*N</line-37>
<line-38>for x in ac:</line-38>
<line-39> a[x-min_A] += 1</line-39>
<line-40> b[-x-min_B] += 1</line-40>
<line-41>c = zip(fft(a, lgN), fft(b, lgN))</line-41>
<line-42>c = fft([x*y for x,y in c], lgN, rot=-1)</line-42>
<line-43>c = [round(x.real) for x in c][-min_A-min_B:][:n+1]</line-43>
<line-45>print(*c, *(0 for i in range(n+1-len(c))), flush=True)</line-45>
|
{"code": "<line-2>from cmath import exp</line-2>\n<line-44>c[0] = sum((x*(x-1))//2 for x in a)</line-44>", "lines": [2, 44]}
#### 0
|
<line-1>MOD = 998244353</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>a = list(map(int, input().split()))</line-5>
<line-6>tot = sum(a)</line-6>
<line-7></line-7>
<line-8>def inv(x):</line-8>
<line-9> return pow(x, MOD - 2, MOD)</line-9>
<line-10></line-10>
<line-11>l = [0, pow(n, tot, MOD) - 1]</line-11>
<line-12></line-12>
<line-13>for i in range(1, tot):</line-13>
<line-14> aC = i</line-14>
<line-15> cC = (n - 1) * (tot - i)</line-15>
<line-16> curr = (aC + cC) * l[-1]</line-16>
<line-17> curr -= tot * (n - 1)</line-17>
<line-18> curr -= aC * l[-2]</line-18>
<line-19> curr *= inv(cC)</line-19>
<line-20> curr %= MOD</line-20>
<line-21> l.append(curr)</line-21>
<line-22></line-22>
<line-23>out = 0</line-23>
<line-24>for v in a:</line-24>
<line-25> out += l[tot - v]</line-25>
<line-26> out %= MOD</line-26>
<line-27></line-27>
<line-28>zero = l[tot]</line-28>
<line-29>out -= (n - 1) * zero</line-29>
<line-31>print(out % MOD)</line-31>
|
{"code": "<line-3>n = int(input())</line-3>\n<line-30>out *= inv(n)</line-30>", "lines": [3, 30]}
#### 0
|
<line-1>n, m = map(int, input().split())</line-1>
<line-3>extra = [0 for _ in range(n)]</line-3>
<line-4>query = list()</line-4>
<line-5>for _ in range(m):</line-5>
<line-6> t, l, r, x = map(int, input().split())</line-6>
<line-7> l -= 1</line-7>
<line-8> r -= 1</line-8>
<line-9> query.append((t, l, r, x))</line-9>
<line-10> if t == 1:</line-10>
<line-11> for j in range(l, r + 1):</line-11>
<line-12> extra[j] += x</line-12>
<line-13> else:</line-13>
<line-14> for j in range(l, r + 1):</line-14>
<line-15> a[j] = min(a[j], x - extra[j])</line-15>
<line-16>extra = a.copy()</line-16>
<line-17>for t, l, r, x in query:</line-17>
<line-18> if t == 1:</line-18>
<line-19> for j in range(l, r + 1):</line-19>
<line-20> a[j] += x</line-20>
<line-21> else:</line-21>
<line-22> val = -10**9</line-22>
<line-23> for j in range(l, r + 1):</line-23>
<line-24> val = max(val, a[j])</line-24>
<line-25> if not val == x:</line-25>
<line-26> print('NO')</line-26>
<line-27> return</line-27>
<line-28></line-28>
<line-29>print('YES')</line-29>
<line-31> print(x, end=' ')</line-31>
<line-32> </line-32>
|
{"code": "<line-2>a = [10**9 for _ in range(n)]</line-2>\n<line-30>for x in extra:</line-30>", "lines": [2, 30]}
#### 0
|
<line-1>import heapq</line-1>
<line-2></line-2>
<line-4> x, y = coor</line-4>
<line-5> for dx in dxs:</line-5>
<line-6> for dy in dys:</line-6>
<line-7> yield x + dx, y + dy</line-7>
<line-8></line-8>
<line-9></line-9>
<line-10>def coor_bottoms(coor):</line-10>
<line-11> return coor_neighbor(coor, (-1, 0, 1), (-1, ))</line-11>
<line-12></line-12>
<line-13></line-13>
<line-14>def coor_tops(coor):</line-14>
<line-15> return coor_neighbor(coor, (-1, 0, 1), (1, ))</line-15>
<line-16></line-16>
<line-17></line-17>
<line-18>def coor_sibs(coor):</line-18>
<line-19> return coor_neighbor(coor, (-2, -1, 1, 2), (0, ))</line-19>
<line-20></line-20>
<line-21></line-21>
<line-22>class Figure:</line-22>
<line-23></line-23>
<line-24> def __init__(self, coors):</line-24>
<line-25> self._coors = dict()</line-25>
<line-26> self._stables_min = []</line-26>
<line-27> self._stables_max = []</line-27>
<line-28> self._pushed = set()</line-28>
<line-29> self._dropped = set()</line-29>
<line-30></line-30>
<line-31> cubes = dict()</line-31>
<line-32> self._bots = dict()</line-32>
<line-33> self._tops = dict()</line-33>
<line-34> for idx, coor in enumerate(coors):</line-34>
<line-35> cubes[coor] = idx</line-35>
<line-36> self._coors[idx] = coor</line-36>
<line-37> self._bots[idx] = set()</line-37>
<line-38> self._tops[idx] = set()</line-38>
<line-39></line-39>
<line-40> coor_set = set(coors)</line-40>
<line-41> for idx, coor in enumerate(coors):</line-41>
<line-42> for bottom in coor_bottoms(coor):</line-42>
<line-43> if bottom in coor_set:</line-43>
<line-44> self._bots[idx].add(cubes[bottom])</line-44>
<line-45> for top in coor_tops(coor):</line-45>
<line-46> if top in coor_set:</line-46>
<line-47> self._tops[idx].add(cubes[top])</line-47>
<line-48></line-48>
<line-49> for idx in self._coors:</line-49>
<line-50> if self.isdroppable(idx):</line-50>
<line-51> self.push(idx)</line-51>
<line-52></line-52>
<line-53> def sibs(self, idx):</line-53>
<line-54> for top_idx in self._tops[idx]:</line-54>
<line-55> for sib_idx in self._bots[top_idx]:</line-55>
<line-56> if sib_idx not in self._dropped:</line-56>
<line-57> yield sib_idx</line-57>
<line-58></line-58>
<line-59> def bottom_count(self, idx):</line-59>
<line-60> return len(self._bots[idx])</line-60>
<line-61></line-61>
<line-62> def isdroppable(self, idx):</line-62>
<line-63> return all(len(self._bots[top_idx]) > 1 for top_idx in self._tops[idx])</line-63>
<line-64></line-64>
<line-65> def push(self, idx):</line-65>
<line-66> if idx not in self._pushed:</line-66>
<line-67> heapq.heappush(self._stables_min, idx)</line-67>
<line-68> heapq.heappush(self._stables_max, -idx)</line-68>
<line-69> self._pushed.add(idx)</line-69>
<line-70></line-70>
<line-71> def unpush(self, idx):</line-71>
<line-72> if idx in self._pushed:</line-72>
<line-73> self._pushed.remove(idx)</line-73>
<line-74></line-74>
<line-75> def drop(self, idx):</line-75>
<line-76> if idx not in self._pushed:</line-76>
<line-77> return False</line-77>
<line-78> self._pushed.remove(idx)</line-78>
<line-79> self._dropped.add(idx)</line-79>
<line-80></line-80>
<line-81> for bot_idx in self._bots[idx]:</line-81>
<line-82> self._tops[bot_idx].remove(idx)</line-82>
<line-83> for top_idx in self._tops[idx]:</line-83>
<line-84> self._bots[top_idx].remove(idx)</line-84>
<line-85></line-85>
<line-86> coor = self._coors[idx]</line-86>
<line-87> for bot_idx in self._bots[idx]:</line-87>
<line-88> if self.isdroppable(bot_idx):</line-88>
<line-89> self.push(bot_idx)</line-89>
<line-90> for sib_idx in self.sibs(idx):</line-90>
<line-91> if not self.isdroppable(sib_idx):</line-91>
<line-92> self.unpush(sib_idx)</line-92>
<line-93> return True</line-93>
<line-94></line-94>
<line-95> def drop_min(self):</line-95>
<line-96> while True:</line-96>
<line-97> if not self._stables_min:</line-97>
<line-98> return None</line-98>
<line-99> min_idx = heapq.heappop(self._stables_min)</line-99>
<line-100> if self.drop(min_idx):</line-100>
<line-101> return min_idx</line-101>
<line-102></line-102>
<line-103> def drop_max(self):</line-103>
<line-104> while True:</line-104>
<line-105> if not self._stables_max:</line-105>
<line-106> return None</line-106>
<line-107> max_idx = - heapq.heappop(self._stables_max)</line-107>
<line-108> if self.drop(max_idx):</line-108>
<line-109> return max_idx</line-109>
<line-110></line-110>
<line-111> def __bool__(self):</line-111>
<line-112> return len(self._coors) != len(self._dropped)</line-112>
<line-113></line-113>
<line-114></line-114>
<line-115>def input_tuple():</line-115>
<line-116> return tuple(map(int, input().split()))</line-116>
<line-117></line-117>
<line-118></line-118>
<line-119>def result_add(result, base, num):</line-119>
<line-120> return (result * base + num) % (10 ** 9 + 9)</line-120>
<line-121></line-121>
<line-122></line-122>
<line-123>N = int(input())</line-123>
<line-124>coors = [input_tuple() for _ in range(N)]</line-124>
<line-125></line-125>
<line-126>figure = Figure(coors)</line-126>
<line-127>result = 0</line-127>
<line-128>while True:</line-128>
<line-129> if not figure:</line-129>
<line-130> break</line-130>
<line-131> result = result_add(result, N, figure.drop_max())</line-131>
<line-132> if not figure:</line-132>
<line-133> break</line-133>
<line-135>print(result)</line-135>
|
{"code": "<line-3>def coor_neighbor(coor, dxs, dys):</line-3>\n<line-134> result = result_add(result, N, figure.drop_min())</line-134>", "lines": [3, 134]}
#### 0
|
<line-1>from sys import stdin, stdout</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>def findAllStrings(s):</line-5>
<line-6> n = len(s)</line-6>
<line-7> sDict = {}</line-7>
<line-8> for i in range(1,K+1):</line-8>
<line-9> sDict[i]=set()</line-9>
<line-10> for x in range(n-i+1):</line-10>
<line-11> sDict[i].add(s[x:x+i])</line-11>
<line-12> return sDict</line-12>
<line-13></line-13>
<line-14>n = int(stdin.readline().rstrip())</line-14>
<line-15>stringDicts = []</line-15>
<line-16>stringEnd = []</line-16>
<line-17>stringBegin = []</line-17>
<line-18></line-18>
<line-19>for i in range(n):</line-19>
<line-20> s = stdin.readline().rstrip()</line-20>
<line-21> stringDicts.append(findAllStrings(s))</line-21>
<line-22> if len(s)<K:</line-22>
<line-23> stringEnd.append(s)</line-23>
<line-24> stringBegin.append(s)</line-24>
<line-25> else:</line-25>
<line-26> stringEnd.append(s[-20:])</line-26>
<line-27> stringBegin.append(s[:20])</line-27>
<line-28></line-28>
<line-29>m = int(stdin.readline().rstrip())</line-29>
<line-30></line-30>
<line-31>for _ in range(m):</line-31>
<line-32> a,b = list(map(int,stdin.readline().rstrip().split()))</line-32>
<line-33> a-=1</line-33>
<line-34> b-=1</line-34>
<line-35> </line-35>
<line-36> sDict1 = findAllStrings(stringEnd[a]+stringBegin[b])</line-36>
<line-37> sDict2 = stringDicts[a]</line-37>
<line-38> sDict3 = stringDicts[b]</line-38>
<line-39> sDict={}</line-39>
<line-40> for i in range(1,K+1):</line-40>
<line-41> sDict[i] = sDict1[i]|sDict2[i]|sDict3[i]</line-41>
<line-42> stringDicts.append(sDict)</line-42>
<line-43> for i in range(1,K+1):</line-43>
<line-44> if len(sDict[i])!=2**i:</line-44>
<line-45> print(i-1)</line-45>
<line-46> break</line-46>
<line-47> </line-47>
<line-48> if len(stringBegin[a])<K and len(stringBegin[a])+len(stringBegin[b])<K:</line-48>
<line-49> stringBegin.append(stringBegin[a]+stringBegin[b])</line-49>
<line-50> elif len(stringBegin[a])<K:</line-50>
<line-51> s = stringBegin[a]+stringBegin[b]</line-51>
<line-52> stringBegin.append(s[:K])</line-52>
<line-53> else:</line-53>
<line-54> stringBegin.append(stringBegin[a])</line-54>
<line-55> </line-55>
<line-56> if len(stringEnd[b])<K and len(stringEnd[a])+len(stringEnd[b])<K:</line-56>
<line-57> stringEnd.append(stringEnd[a]+stringEnd[b])</line-57>
<line-58> elif len(stringEnd[b])<K:</line-58>
<line-59> s = stringEnd[a]+stringEnd[b]</line-59>
<line-60> stringEnd.append(s[-K:])</line-60>
<line-62> stringEnd.append(stringEnd[b])</line-62>
<line-63></line-63>
|
{"code": "<line-3>K = 20</line-3>\n<line-61> else:</line-61>", "lines": [3, 61]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>from collections import deque</line-5>
<line-6>N, Q = list(map(int, input().split()))</line-6>
<line-7>que = deque([int(a) for a in input().split()])</line-7>
<line-8>ma = max(que)</line-8>
<line-9></line-9>
<line-10>X = []</line-10>
<line-11>k = -1</line-11>
<line-12>c = 0</line-12>
<line-13>while c <= k+N+5:</line-13>
<line-14> a = deque.popleft(que)</line-14>
<line-15> b = deque.popleft(que)</line-15>
<line-16> </line-16>
<line-17> X.append((a, b))</line-17>
<line-18> c += 1</line-18>
<line-19> if a > b:</line-19>
<line-20> a, b = b, a</line-20>
<line-21> if k < 0 and b == ma:</line-21>
<line-22> k = c</line-22>
<line-23> deque.appendleft(que, b)</line-23>
<line-24> deque.append(que, a)</line-24>
<line-25></line-25>
<line-26>for _ in range(Q):</line-26>
<line-27> i = int(input()) - 1</line-27>
<line-28> if i <= k:</line-28>
<line-29> print(*X[i])</line-29>
<line-30> else:</line-30>
<line-32> print(*X[i])</line-32>
<line-33></line-33>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-31> i = (i-k)%(N-1)+k</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>3</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>n, l, r, ql, qr = list(map(int, sys.stdin.readline().strip().split()))</line-5>
<line-6>w = [int(x) for x in sys.stdin.readline().strip().split()]</line-6>
<line-7></line-7>
<line-8>s = [0]</line-8>
<line-9>for i in range(0, n):</line-9>
<line-10> s.append(s[-1] + w[i])</line-10>
<line-11></line-11>
<line-12>def cost(left):</line-12>
<line-13> right = n - left</line-13>
<line-14> diff = left - right</line-14>
<line-15> bonus = 0</line-15>
<line-16> if diff > 0: # left part is larger</line-16>
<line-17> bonus = ql * (diff - 1)</line-17>
<line-18> elif diff < 0: # right part is larger</line-18>
<line-19> bonus = qr * (-diff - 1)</line-19>
<line-20> return bonus + l * s[left] + r * (s[n] - s[left])</line-20>
<line-21></line-21>
<line-22>best = cost(0)</line-22>
<line-23>for left in range(1, n+1):</line-23>
<line-24> c = cost(left)</line-24>
<line-25> if c < best:</line-25>
<line-27></line-27>
<line-28>print(best)</line-28>
|
{"code": "<line-3>import sys</line-3>\n<line-26> best = c</line-26>", "lines": [3, 26]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3></line-3>
<line-4>dp = [[0]*n for _ in range(n)]</line-4>
<line-5>for i in range(n) :</line-5>
<line-6> dp[i][i] = 1</line-6>
<line-7></line-7>
<line-8>for i in range(n-2, -1, -1) :</line-8>
<line-9> for j in range(i+1, n) :</line-9>
<line-10> dp[i][j] = 1 + dp[i+1][j]</line-10>
<line-11> if C[i] == C[i+1] : dp[i][j] = min( dp[i][j], 1 + (dp[i+2][j] if i+2 < n else 0) )</line-11>
<line-12> for k in range(i+2, j) :</line-12>
<line-13> if C[i] == C[k] : dp[i][j] = min( dp[i][j], dp[i+1][k-1] + dp[k+1][j] )</line-13>
<line-14> if C[i] == C[j] and j-i > 1:</line-14>
<line-16></line-16>
<line-17>print( dp[0][n-1] )</line-17>
<line-18></line-18>
<line-19> </line-19>
<line-20> </line-20>
|
{"code": "<line-2>C = list(map(int, input().split()))</line-2>\n<line-15> dp[i][j] = min( dp[i][j], dp[i+1][j-1] )</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>from operator import __or__, __and__, __xor__</line-1>
<line-3>n, b, c = int(stdin.readline()), 0, 1023</line-3>
<line-4>m = {'|': __or__, '&': __and__, '^': __xor__}</line-4>
<line-5>for i in range(n):</line-5>
<line-6> t, v = [i for i in stdin.readline().split()]</line-6>
<line-7> b = m[t](b, int(v))</line-7>
<line-8> c = m[t](c, int(v))</line-8>
<line-9>x, o, a = 0, 0, 1023</line-9>
<line-10>for i in range(10):</line-10>
<line-11> if ((b >> i) & 1) and ((c >> i) & 1):</line-11>
<line-12> o |= 1 << i</line-12>
<line-13> elif not ((b >> i) & 1) and not ((c >> i) & 1):</line-13>
<line-14> a -= 1 << i</line-14>
<line-15> elif ((b >> i) & 1) and not ((c >> i) & 1):</line-15>
<line-17>stdout.write('3\n| ' + str(o) + '\n^ ' + str(x) + '\n& ' + str(a))</line-17>
<line-18> </line-18>
|
{"code": "<line-2>from sys import stdin, stdout</line-2>\n<line-16> x |= 1 << i</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>from itertools import combinations_with_replacement </line-1>
<line-3></line-3>
<line-4>#sys.stdin = open("input_py.txt","r")</line-4>
<line-5></line-5>
<line-6>n, m = map(int, input().split())</line-6>
<line-7>G = [ [] for i in range(n)]</line-7>
<line-8></line-8>
<line-9>for i in range(m):</line-9>
<line-10> x, y = map(int, input().split())</line-10>
<line-11> x-=1; y-=1</line-11>
<line-12> G[x].append(y)</line-12>
<line-13> G[y].append(x)</line-13>
<line-14></line-14>
<line-15>def BFS(s):</line-15>
<line-16> dist = [-1 for i in range(n)]</line-16>
<line-17> dist[s] = 0</line-17>
<line-18> Q = deque()</line-18>
<line-19> Q.append(s)</line-19>
<line-20> while len(Q) > 0:</line-20>
<line-21> v = Q.popleft()</line-21>
<line-22> for to in G[v]:</line-22>
<line-23> if dist[to] < 0:</line-23>
<line-24> dist[to] = dist[v] + 1</line-24>
<line-25> Q.append(to)</line-25>
<line-26> return dist </line-26>
<line-27></line-27>
<line-28></line-28>
<line-29>Dist = [BFS(i) for i in range(n)]</line-29>
<line-30></line-30>
<line-31>s1, t1, l1 = map(int, input(). split())</line-31>
<line-32>s2, t2, l2 = map(int, input(). split())</line-32>
<line-33>s1-=1; t1-=1; s2-=1; t2-=1</line-33>
<line-34>if Dist[s1][t1] > l1 or Dist[s2][t2] > l2:</line-34>
<line-35> print(-1)</line-35>
<line-36> return</line-36>
<line-37></line-37>
<line-38>rest = Dist[s1][t1] + Dist[s2][t2]</line-38>
<line-39></line-39>
<line-40>for i in range(n):</line-40>
<line-41> for j in range(n):</line-41>
<line-42> if Dist[i][s1] + Dist[i][j] + Dist[j][t1] <= l1 and Dist[i][s2] + Dist[i][j] + Dist[j][t2] <= l2 :</line-42>
<line-43> rest = min(rest, Dist[i][j] + Dist[i][s1] + Dist[i][s2] + Dist[j][t1] + Dist[j][t2])</line-43>
<line-44> if Dist[i][s1] + Dist[i][j] + Dist[j][t1] <= l1 and Dist[j][s2] + Dist[i][j] + Dist[i][t2] <= l2 :</line-44>
<line-46>print(m-rest)</line-46>
|
{"code": "<line-2>from collections import deque</line-2>\n<line-45> rest = min(rest, Dist[i][j] + Dist[j][t1] + Dist[j][s2] + Dist[i][s1] + Dist[i][t2])</line-45>", "lines": [2, 45]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>s = input()</line-4>
<line-5></line-5>
<line-6>M = int(input())</line-6>
<line-7></line-7>
<line-8></line-8>
<line-9>def next_pow_2(n):</line-9>
<line-10> p = 1</line-10>
<line-11> while p < n:</line-11>
<line-12> p <<= 1</line-12>
<line-13> return p</line-13>
<line-14></line-14>
<line-15></line-15>
<line-16>def represented_range(node, size):</line-16>
<line-17> l = node</line-17>
<line-18> r = node</line-18>
<line-19> while l < size:</line-19>
<line-20> l = 2*l</line-20>
<line-21> r = 2*r + 1</line-21>
<line-22> return l-size, r-size</line-22>
<line-23></line-23>
<line-24></line-24>
<line-25>class SegTree:</line-25>
<line-26> def __init__(self, size):</line-26>
<line-27> self.size = next_pow_2(size)</line-27>
<line-28> self.answer = [0] * (2*self.size)</line-28>
<line-29> self.opened = [0] * (2*self.size)</line-29>
<line-30> self.closed = [0] * (2*self.size)</line-30>
<line-31></line-31>
<line-32> # O(size * (O(func) + O(init))</line-32>
<line-33> def build(self, s):</line-33>
<line-34> for i in range(self.size):</line-34>
<line-35> self.answer[self.size + i] = 0</line-35>
<line-36> self.opened[self.size + i] = 1 if i < len(s) and s[i] == '(' else 0</line-36>
<line-37> self.closed[self.size + i] = 1 if i < len(s) and s[i] == ')' else 0</line-37>
<line-38></line-38>
<line-39> for i in range(self.size - 1, 0, -1):</line-39>
<line-40> matched = min(self.opened[2*i], self.closed[2*i+1])</line-40>
<line-41> self.answer[i] = self.answer[2*i] + self.answer[2*i+1] + matched</line-41>
<line-42> self.opened[i] = self.opened[2*i] + self.opened[2*i+1] - matched</line-42>
<line-43> self.closed[i] = self.closed[2*i] + self.closed[2*i+1] - matched</line-43>
<line-44></line-44>
<line-45> # O(log(size)), [l,r]</line-45>
<line-46> def query(self, l, r):</line-46>
<line-47> l += self.size</line-47>
<line-48> r += self.size</line-48>
<line-49></line-49>
<line-50> eventsR = []</line-50>
<line-51> answer = 0</line-51>
<line-52> opened = 0</line-52>
<line-53> while l <= r:</line-53>
<line-54> if l & 1:</line-54>
<line-55> matched = min(self.closed[l], opened)</line-55>
<line-56> answer += self.answer[l] + matched</line-56>
<line-57> opened += self.opened[l] - matched</line-57>
<line-58> l += 1</line-58>
<line-59> if not (r & 1):</line-59>
<line-60> eventsR.append((self.answer[r], self.opened[r], self.closed[r]))</line-60>
<line-61> r -= 1</line-61>
<line-62> l >>= 1</line-62>
<line-63> r >>= 1</line-63>
<line-64></line-64>
<line-65> for i in range(len(eventsR)-1, -1, -1):</line-65>
<line-66> a, o, c = eventsR[i]</line-66>
<line-67> matched = min(c, opened)</line-67>
<line-68> answer += a + matched</line-68>
<line-69> opened += o - matched</line-69>
<line-70></line-70>
<line-71> return answer</line-71>
<line-72></line-72>
<line-73></line-73>
<line-74>seg = SegTree(len(s))</line-74>
<line-75>seg.build(s)</line-75>
<line-76></line-76>
<line-77>for i in range(M):</line-77>
<line-79> print(2*seg.query(l-1, r-1))</line-79>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-78> l, r = [int(_) for _ in input().split()]</line-78>", "lines": [2, 78]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3> print("contest")</line-3>
<line-5> print("home")</line-5>
|
{"code": "<line-2>if n % 2:</line-2>\n<line-4>else:</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>a = list(map(int, input().split()))</line-5>
<line-6>ss = []</line-6>
<line-7>ms = []</line-7>
<line-8>for i in range(n):</line-8>
<line-9> k = a[i]</line-9>
<line-10> ind = bisect_left(ms, -k)</line-10>
<line-11> if ind == len(ms):</line-11>
<line-12> ss.append([])</line-12>
<line-13> ms.append(0)</line-13>
<line-14> ss[ind].append(k)</line-14>
<line-15> ms[ind] = -k</line-15>
<line-16></line-16>
<line-18> print(' '.join([str(i) for i in s]))</line-18>
|
{"code": "<line-2>from bisect import bisect_left</line-2>\n<line-17>for s in ss:</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>def main():</line-1>
<line-3> input = sys.stdin.readline</line-3>
<line-4> </line-4>
<line-5> n = int(input())</line-5>
<line-6> arr = input()</line-6>
<line-7> </line-7>
<line-8> one = arr.count('n')</line-8>
<line-9> zero = arr.count('z')</line-9>
<line-10> </line-10>
<line-11> ans = [1] * one + [0] * zero</line-11>
<line-12> </line-12>
<line-13> print(*ans)</line-13>
<line-14> </line-14>
<line-16></line-16>
<line-17>main()</line-17>
|
{"code": "<line-2> import sys</line-2>\n<line-15> return 0</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>input()</line-1>
<line-3>root=-1</line-3>
<line-4>for i,a in enumerate(A) :</line-4>
<line-5> if i == a-1 :</line-5>
<line-6> root = i</line-6>
<line-7> break</line-7>
<line-8>v = [False]*len(A)</line-8>
<line-9>if root>-1 :</line-9>
<line-10> v[root]=True</line-10>
<line-11>ans= 0</line-11>
<line-12>for i,a in enumerate(A) :</line-12>
<line-13> if v[i] :</line-13>
<line-14> continue</line-14>
<line-15> v[i]= True</line-15>
<line-16> l=[i]</line-16>
<line-17> a-=1</line-17>
<line-18> while not v[a] :</line-18>
<line-19> l.append(a)</line-19>
<line-20> v[a]=True</line-20>
<line-21> a=A[a]-1</line-21>
<line-22> if a in l: #new cycle</line-22>
<line-23> if root==-1:</line-23>
<line-24> A[a]=a+1</line-24>
<line-25> root=a</line-25>
<line-26> ans+=1</line-26>
<line-27> else :</line-27>
<line-28> A[a]=root+1</line-28>
<line-29> ans+=1</line-29>
<line-31>print(' '.join(map(str,A)))</line-31>
|
{"code": "<line-2>A = list(map(int, input().split(' ')))</line-2>\n<line-30>print(ans)</line-30>", "lines": [2, 30]}
#### 0
|
<line-1></line-1>
<line-2>import sys</line-2>
<line-4>input=sys.stdin.readline</line-4>
<line-5></line-5>
<line-6>n=int(input())</line-6>
<line-7>b=list(map(int,input().split()))</line-7>
<line-8>bb=sorted(b)</line-8>
<line-9>c={bb[i]:i for i in range(n)}</line-9>
<line-10>a=[c[b[i]] for i in range(n)]</line-10>
<line-11>vis=[0]*n</line-11>
<line-12></line-12>
<line-13>out=[]</line-13>
<line-14>for i in range(n):</line-14>
<line-15> if vis[i]: continue</line-15>
<line-16> vis[i]=1</line-16>
<line-17> newlist=[i]</line-17>
<line-18> while a[newlist[-1]]!=i:</line-18>
<line-19> newlist.append(a[newlist[-1]])</line-19>
<line-20> vis[newlist[-1]]=1</line-20>
<line-21> out.append(newlist)</line-21>
<line-22></line-22>
<line-23>print(len(out))</line-23>
<line-25> print(" ".join([str(x+1) for x in [len(i)-1]+i]))</line-25>
|
{"code": "<line-3>#sys.stdin=open(\"data.txt\")</line-3>\n<line-24>for i in out:</line-24>", "lines": [3, 24]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>edges = sorted(edges)</line-3>
<line-4>use_count = [0]+[int(input()) for i in range(n)]</line-4>
<line-5>lo,hi = 0,10000</line-5>
<line-6>def getpar(par,u):</line-6>
<line-7> if par[par[u]] == par[u]:</line-7>
<line-8> return par[u]</line-8>
<line-9> par[u] = getpar(par,par[u])</line-9>
<line-10> return par[u]</line-10>
<line-11>def unite(par,sz,use,u,v):</line-11>
<line-12> u = getpar(par,u)</line-12>
<line-13> v = getpar(par,v)</line-13>
<line-14> par[u] = v</line-14>
<line-15> sz[v] += sz[u]</line-15>
<line-16> use[v] += use[u]</line-16>
<line-17>def solve(fp):</line-17>
<line-18> par = [i for i in range(n+1)]</line-18>
<line-19> sz = [1 for i in range(n+1)]</line-19>
<line-20> use = [use_count[i] for i in range(n+1)]</line-20>
<line-21> for edge in edges:</line-21>
<line-22> if edge[2] < fp:</line-22>
<line-23> unite(par,sz,use,edge[0],edge[1])</line-23>
<line-24> total_use = sum(use_count)</line-24>
<line-25> for i in range(n+1):</line-25>
<line-26> p = getpar(par,i)</line-26>
<line-27> if(p == i):</line-27>
<line-28> if(total_use - use[p] < sz[p]):</line-28>
<line-29> return False</line-29>
<line-30> return True</line-30>
<line-31>while lo < hi:</line-31>
<line-32> mid = (lo+hi+1)//2</line-32>
<line-33> if solve(mid):</line-33>
<line-34> lo = mid</line-34>
<line-35> else:</line-35>
<line-37>print(lo)</line-37>
|
{"code": "<line-2>edges = [[int(x) for x in input().split()] for i in range(n-1)]</line-2>\n<line-36> hi = mid-1</line-36>", "lines": [2, 36]}
#### 0
|
<line-1></line-1>
<line-2>import sys</line-2>
<line-4>input=sys.stdin.readline</line-4>
<line-5></line-5>
<line-6>n,m=list(map(int,input().split()))</line-6>
<line-7></line-7>
<line-8>party=[[] for _ in range(m+5)]</line-8>
<line-9>pc=sorted([list(map(int,input().split())) for _ in range(n)],key=lambda x:x[1])</line-9>
<line-10>choose=[0]*n</line-10>
<line-11></line-11>
<line-12>for i in range(n):</line-12>
<line-13> party[pc[i][0]].append(i)</line-13>
<line-14></line-14>
<line-15></line-15>
<line-16></line-16>
<line-17>want=10**18</line-17>
<line-18>for i in range(1,n+1):</line-18>
<line-19> p1=len(party[1])</line-19>
<line-20> # want all other parties to have <i voters</line-20>
<line-21> for j in range(2,m+5):</line-21>
<line-22> if len(party[j])<i: continue</line-22>
<line-23> for k in range(len(party[j])-i+1):</line-23>
<line-24> p1+=1</line-24>
<line-25> choose[party[j][k]]=1</line-25>
<line-26> # want party 1 to have >=i voters</line-26>
<line-27> want2=0</line-27>
<line-28> for j in range(n):</line-28>
<line-29> if p1<i and choose[j]==0 and pc[j][0]!=1:</line-29>
<line-30> choose[j]=1</line-30>
<line-31> p1+=1</line-31>
<line-32> if choose[j]==1:</line-32>
<line-33> want2+=pc[j][1]</line-33>
<line-34> if want>want2:</line-34>
<line-35> want=want2</line-35>
<line-36> #print(i,want2)</line-36>
<line-37> # reset</line-37>
<line-39></line-39>
<line-40>print(want)</line-40>
|
{"code": "<line-3>#sys.stdin=open(\"data.txt\")</line-3>\n<line-38> choose=[0]*n</line-38>", "lines": [3, 38]}
#### 0
|
<line-1>3</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>def __starting_point():</line-5>
<line-6> </line-6>
<line-7> n, k = list(map(int, sys.stdin.readline().split()))</line-7>
<line-8> l = []</line-8>
<line-9> i = 1</line-9>
<line-10> j = k + 1</line-10>
<line-11> while i <= j:</line-11>
<line-12> l.append(str(i))</line-12>
<line-13> i += 1</line-13>
<line-14> if j > i:</line-14>
<line-15> l.append(str(j))</line-15>
<line-16> j -= 1</line-16>
<line-17> for i in range(k+2, n+1):</line-17>
<line-18> l.append(str(i))</line-18>
<line-19> </line-19>
<line-21></line-21>
<line-22></line-22>
<line-23>__starting_point()</line-23>
|
{"code": "<line-3>import sys</line-3>\n<line-20> print(' '.join(l))</line-20>", "lines": [3, 20]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3></line-3>
<line-4>stack = []</line-4>
<line-5>for v in l:</line-5>
<line-6> currVal = v</line-6>
<line-7> currSize = 1</line-7>
<line-8> div = v</line-8>
<line-9> </line-9>
<line-10> while stack:</line-10>
<line-11> nex, nexS, nDiv = stack[-1]</line-11>
<line-12></line-12>
<line-13> if div < nDiv:</line-13>
<line-14> currSize += nexS</line-14>
<line-15> currVal += nex</line-15>
<line-16> stack.pop()</line-16>
<line-17></line-17>
<line-18> div = currVal / currSize</line-18>
<line-19> else:</line-19>
<line-20> break</line-20>
<line-21> stack.append((currVal, currSize, div))</line-21>
<line-22></line-22>
<line-23>out = []</line-23>
<line-24>for a, b, d in stack:</line-24>
<line-25> thingy = str(d)</line-25>
<line-26> for _ in range(b):</line-26>
<line-28> </line-28>
<line-29>print('\n'.join(out))</line-29>
|
{"code": "<line-2>l = list(map(int, input().split()))</line-2>\n<line-27> out.append(thingy)</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>N, M = list(map(int, input().split()))</line-4>
<line-5>D = [{} for _ in range(N)]</line-5>
<line-6>for _ in range(M):</line-6>
<line-7> a, b = list(map(int, input().split()))</line-7>
<line-8> a -= 1</line-8>
<line-9> b -= 1</line-9>
<line-10> D[a][b] = 1</line-10>
<line-11> D[b][a] = 1</line-11>
<line-12></line-12>
<line-13>L = [i-1 for i in range(N)]</line-13>
<line-14>R = [i+1 for i in range(N)]</line-14>
<line-15></line-15>
<line-16>F = [0] * N</line-16>
<line-17>for i in range(N):</line-17>
<line-18> if F[i]: continue</line-18>
<line-19> f = 1</line-19>
<line-20> while f:</line-20>
<line-21> f = 0</line-21>
<line-22> j = R[i]</line-22>
<line-23> while j < N:</line-23>
<line-24> if j in D[i]:</line-24>
<line-25> j = R[j]</line-25>
<line-26> continue</line-26>
<line-27> F[j] = 1</line-27>
<line-28> A = [a for a in D[i] if a not in D[j]]</line-28>
<line-29> if A: f = 1</line-29>
<line-30> for a in A:</line-30>
<line-31> if a in D[i]: del D[i][a]</line-31>
<line-32> if i in D[a]: del D[a][i]</line-32>
<line-33> A = [a for a in D[j] if a not in D[i]]</line-33>
<line-34> if A: f = 1</line-34>
<line-35> for a in A:</line-35>
<line-36> if a in D[j]: del D[j][a]</line-36>
<line-37> if j in D[a]: del D[a][j]</line-37>
<line-38></line-38>
<line-39> if R[j] < N: L[R[j]] = L[j]</line-39>
<line-40> if L[j] >= 0: R[L[j]] = R[j]</line-40>
<line-42></line-42>
<line-43>print(N - sum(F) - 1)</line-43>
|
{"code": "<line-2>input = lambda: sys.stdin.readline().rstrip()</line-2>\n<line-41> j = R[j]</line-41>", "lines": [2, 41]}
#### 0
|
<line-1>k = int(input())</line-1>
<line-3>g = lambda n: n * (n * n - 1) // 6</line-3>
<line-4>i = n = 0</line-4>
<line-5>while g(n + 1) <= k: n += 1</line-5>
<line-6>while i < n + 1:</line-6>
<line-7> for j in range(i): p[i][j] = p[j][i] = '1'</line-7>
<line-8> i += 1</line-8>
<line-9>k -= g(n)</line-9>
<line-10>g = lambda n: n * n - n >> 1</line-10>
<line-11>while k:</line-11>
<line-12> n = 0</line-12>
<line-13> while g(n + 1) <= k: n += 1</line-13>
<line-14> for j in range(n): p[i][j] = p[j][i] = '1'</line-14>
<line-15> k -= g(n)</line-15>
<line-16> i += 1</line-16>
<line-18>for j in range(i): print(''.join(p[j][:i]))</line-18>
|
{"code": "<line-2>p = [['0'] * 100 for j in range(100)]</line-2>\n<line-17>print(i)</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>#!/usr/bin/env python</line-1>
<line-3>#</line-3>
<line-4># Copyright (C) 2015 Sergey</line-4>
<line-5># Licensed under the Apache License, Version 2.0 (the "License");</line-5>
<line-6># you may not use this file except in compliance with the License.</line-6>
<line-7># You may obtain a copy of the License at</line-7>
<line-8># http://www.apache.org/licenses/LICENSE-2.0</line-8>
<line-9>#</line-9>
<line-10># Unless required by applicable law or agreed to in writing, software</line-10>
<line-11># distributed under the License is distributed on an "AS IS" BASIS,</line-11>
<line-12># WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.</line-12>
<line-13># See the License for the specific language governing permissions and</line-13>
<line-14># limitations under the License.</line-14>
<line-15></line-15>
<line-16>"""</line-16>
<line-17>Input</line-17>
<line-18></line-18>
<line-19>The first line contains integers n and m - the number of islands and bridges.</line-19>
<line-20></line-20>
<line-21>Next n lines each contain two integers li and ri - the coordinates of the</line-21>
<line-22>island endpoints.</line-22>
<line-23></line-23>
<line-24>The last line contains m integer numbers a1..am - the lengths of the bridges</line-24>
<line-25>that Andrewid got.</line-25>
<line-26>Output</line-26>
<line-27></line-27>
<line-28>If it is impossible to place a bridge between each pair of adjacent islands</line-28>
<line-29>in the required manner, print on a single line "No" (without the quotes)</line-29>
<line-30>, otherwise print in the first line "Yes" (without the quotes), and in the</line-30>
<line-31>second line print n-1 numbers b1, bn-1, which mean that between islands</line-31>
<line-32>i and i+1 there must be used a bridge number bi.</line-32>
<line-33></line-33>
<line-34>If there are multiple correct answers, print any of them. Note that in this</line-34>
<line-35>problem it is necessary to print "Yes" and "No" in correct case</line-35>
<line-36>"""</line-36>
<line-37></line-37>
<line-38># Standard libraries</line-38>
<line-39>import unittest</line-39>
<line-40>import sys</line-40>
<line-41>import re</line-41>
<line-42></line-42>
<line-43># Additional libraries</line-43>
<line-44>import heapq</line-44>
<line-45></line-45>
<line-46></line-46>
<line-47>###############################################################################</line-47>
<line-48># Fug Class</line-48>
<line-49>###############################################################################</line-49>
<line-50></line-50>
<line-51></line-51>
<line-52>class Fug:</line-52>
<line-53> """ Fug representation """</line-53>
<line-54></line-54>
<line-55> def __init__(self, args):</line-55>
<line-56> """ Default constructor """</line-56>
<line-57> self.list = args[0]</line-57>
<line-58> self.alist = args[1]</line-58>
<line-59> self.gn = len(self.list) - 1</line-59>
<line-60></line-60>
<line-61> # Sorted list of bridges</line-61>
<line-62> self.asrt = sorted((n, i) for i, n in enumerate(self.alist))</line-62>
<line-63></line-63>
<line-64> # List of gaps between islands</line-64>
<line-65> self.gaps = [()]*self.gn</line-65>
<line-66> prevli = self.list[0]</line-66>
<line-67> for i in range(self.gn):</line-67>
<line-68> li = self.list[i+1]</line-68>
<line-69> min = li[0] - prevli[1]</line-69>
<line-70> max = li[1] - prevli[0]</line-70>
<line-71> self.gaps[i] = (min, max, i)</line-71>
<line-72> prevli = li</line-72>
<line-73></line-73>
<line-74> # Sorted list of gaps between islands</line-74>
<line-75> self.gsrt = sorted(self.gaps)</line-75>
<line-76></line-76>
<line-77> self.gmin = [n[0] for n in self.gsrt]</line-77>
<line-78> self.result = [None]*self.gn</line-78>
<line-79> self.heap = []</line-79>
<line-80></line-80>
<line-81> def iterate(self):</line-81>
<line-82></line-82>
<line-83> j = 0</line-83>
<line-84> for (b, i) in self.asrt:</line-84>
<line-85></line-85>
<line-86> # Traverse gmin array</line-86>
<line-87> while j < self.gn and self.gmin[j] <= b:</line-87>
<line-88> it = self.gsrt[j]</line-88>
<line-89> heapq.heappush(self.heap, (it[1], it[0], it[2]))</line-89>
<line-90> j += 1</line-90>
<line-91></line-91>
<line-92> # Update result and remove the element from lists</line-92>
<line-93> if self.heap:</line-93>
<line-94> (mmax, mmin, mi) = self.heap[0]</line-94>
<line-95> if mmin <= b and mmax >= b:</line-95>
<line-96> self.result[mi] = i + 1</line-96>
<line-97> heapq.heappop(self.heap)</line-97>
<line-98></line-98>
<line-99> yield</line-99>
<line-100></line-100>
<line-101> def calculate(self):</line-101>
<line-102> """ Main calcualtion function of the class """</line-102>
<line-103></line-103>
<line-104> for it in self.iterate():</line-104>
<line-105> pass</line-105>
<line-106></line-106>
<line-107> answer = ""</line-107>
<line-108> for (i, n) in enumerate(self.result):</line-108>
<line-109> if n is None:</line-109>
<line-110> return "No"</line-110>
<line-111> answer += (" " if i > 0 else "") + str(n)</line-111>
<line-112></line-112>
<line-113> return "Yes\n" + answer</line-113>
<line-114></line-114>
<line-115></line-115>
<line-116>###############################################################################</line-116>
<line-117># Executable code</line-117>
<line-118>###############################################################################</line-118>
<line-119></line-119>
<line-120></line-120>
<line-121>def get_inputs(test_inputs=None):</line-121>
<line-122></line-122>
<line-123> it = iter(test_inputs.split("\n")) if test_inputs else None</line-123>
<line-124></line-124>
<line-125> def uinput():</line-125>
<line-126> """ Unit-testable input function wrapper """</line-126>
<line-127> if it:</line-127>
<line-128> return next(it)</line-128>
<line-129> else:</line-129>
<line-130> return input()</line-130>
<line-131></line-131>
<line-132> # Getting string inputs. Place all uinput() calls here</line-132>
<line-133> num = [int(s) for s in uinput().split()]</line-133>
<line-134> list = [[int(s) for s in uinput().split()] for i in range(num[0])]</line-134>
<line-135> alist = [int(s) for s in uinput().split()]</line-135>
<line-136></line-136>
<line-137> # Decoding inputs into a list</line-137>
<line-138> inputs = [list, alist]</line-138>
<line-139></line-139>
<line-140> return inputs</line-140>
<line-141></line-141>
<line-142></line-142>
<line-143>def calculate(test_inputs=None):</line-143>
<line-144> """ Base class calculate method wrapper """</line-144>
<line-145> return Fug(get_inputs(test_inputs)).calculate()</line-145>
<line-146></line-146>
<line-147></line-147>
<line-148>###############################################################################</line-148>
<line-149># Unit Tests</line-149>
<line-150>###############################################################################</line-150>
<line-151></line-151>
<line-152></line-152>
<line-153>class unitTests(unittest.TestCase):</line-153>
<line-154></line-154>
<line-155> def test_sample_tests(self):</line-155>
<line-156> """ Quiz sample tests. Add \n to separate lines """</line-156>
<line-157></line-157>
<line-158> # Sample test 1</line-158>
<line-159> test = "4 4\n1 4\n7 8\n9 10\n12 14\n4 5 3 8"</line-159>
<line-160> self.assertEqual(calculate(test), "Yes\n2 3 1")</line-160>
<line-161> self.assertEqual(</line-161>
<line-162> get_inputs(test),</line-162>
<line-163> [[[1, 4], [7, 8], [9, 10], [12, 14]], [4, 5, 3, 8]])</line-163>
<line-164></line-164>
<line-165> # My tests</line-165>
<line-166> test = "5 5\n1 1\n2 7\n8 8\n10 10\n16 16\n1 1 5 6 2"</line-166>
<line-167> self.assertEqual(calculate(test), "Yes\n1 2 5 4")</line-167>
<line-168></line-168>
<line-169> # Other tests</line-169>
<line-170> test = "2 2\n11 14\n17 18\n2 9"</line-170>
<line-171> self.assertEqual(calculate(test), "No")</line-171>
<line-172></line-172>
<line-173> # Other tests</line-173>
<line-174> test = (</line-174>
<line-175> "2 1\n1 1\n1000000000000000000 1000000000000000000" +</line-175>
<line-176> "\n999999999999999999")</line-176>
<line-177> self.assertEqual(calculate(test), "Yes\n1")</line-177>
<line-178></line-178>
<line-179> test = ("5 9\n1 2\n3 3\n5 7\n11 13\n14 20\n2 3 4 10 6 2 6 9 5")</line-179>
<line-180> self.assertEqual(calculate(test), "Yes\n1 6 3 2")</line-180>
<line-181></line-181>
<line-182> size = 100000</line-182>
<line-183> test = str(size) + " " + str(size) + "\n"</line-183>
<line-184> x = size*1000</line-184>
<line-185> for i in range(size):</line-185>
<line-186> x += 2</line-186>
<line-187> test += str(x) + " " + str(x+1) + "\n"</line-187>
<line-188> for i in range(size):</line-188>
<line-189> test += str(2) + " "</line-189>
<line-190> self.assertEqual(calculate(test)[0], "Y")</line-190>
<line-191></line-191>
<line-192> def test_Fug_class__basic_functions(self):</line-192>
<line-193> """ Fug class basic functions testing """</line-193>
<line-194></line-194>
<line-195> # Constructor test</line-195>
<line-196> d = Fug([[[1, 5], [7, 8], [9, 10], [12, 14]], [4, 5, 3, 8]])</line-196>
<line-197> self.assertEqual(d.list[0][0], 1)</line-197>
<line-198> self.assertEqual(d.alist[0], 4)</line-198>
<line-199></line-199>
<line-200> # Sort bridges</line-200>
<line-201> self.assertEqual(d.asrt[0], (3, 2))</line-201>
<line-202></line-202>
<line-203> # Sort Gaps</line-203>
<line-204> self.assertEqual(d.gaps[0], (2, 7, 0))</line-204>
<line-205> self.assertEqual(d.gsrt[0], (1, 3, 1))</line-205>
<line-206></line-206>
<line-207> iter = d.iterate()</line-207>
<line-208> next(iter)</line-208>
<line-209> self.assertEqual(d.gmin, [1, 2, 2])</line-209>
<line-210> self.assertEqual(d.heap, [(5, 2, 2), (7, 2, 0)])</line-210>
<line-211></line-211>
<line-212>def __starting_point():</line-212>
<line-213></line-213>
<line-214> # Avoiding recursion limitaions</line-214>
<line-215> sys.setrecursionlimit(100000)</line-215>
<line-216></line-216>
<line-217> if sys.argv[-1] == "-ut":</line-217>
<line-218> unittest.main(argv=[" "])</line-218>
<line-219></line-219>
<line-220> # Print the result string</line-220>
<line-222></line-222>
<line-223>__starting_point()</line-223>
|
{"code": "<line-2># 556D_fug.py - Codeforces.com 556D Fug quiz</line-2>\n<line-221> print(calculate())</line-221>", "lines": [2, 221]}
#### 0
|
<line-1># </line-1>
<line-3>from functools import cmp_to_key</line-3>
<line-4>#key=cmp_to_key(lambda x,y: 1 if x not in y else -1 )</line-4>
<line-5></line-5>
<line-6>sys.setrecursionlimit(1000000)</line-6>
<line-7>def getIntList():</line-7>
<line-8> return list(map(int, input().split())) </line-8>
<line-9></line-9>
<line-10>import bisect </line-10>
<line-11>try :</line-11>
<line-12> #raise ModuleNotFoundError</line-12>
<line-13> import numpy</line-13>
<line-14> def dprint(*args, **kwargs):</line-14>
<line-15> print(*args, **kwargs, file=sys.stderr)</line-15>
<line-16> dprint('debug mode')</line-16>
<line-17>except ModuleNotFoundError:</line-17>
<line-18> def dprint(*args, **kwargs):</line-18>
<line-19> pass</line-19>
<line-20></line-20>
<line-21></line-21>
<line-22>def memo(func): </line-22>
<line-23> cache={} </line-23>
<line-24> def wrap(*args): </line-24>
<line-25> if args not in cache: </line-25>
<line-26> cache[args]=func(*args) </line-26>
<line-27> return cache[args] </line-27>
<line-28> return wrap</line-28>
<line-29></line-29>
<line-30>@memo</line-30>
<line-31>def comb (n,k):</line-31>
<line-32> if k==0: return 1</line-32>
<line-33> if n==k: return 1</line-33>
<line-34> return comb(n-1,k-1) + comb(n-1,k)</line-34>
<line-35></line-35>
<line-36>inId = 0</line-36>
<line-37>outId = 0</line-37>
<line-38>if inId>0:</line-38>
<line-39> dprint('use input', inId)</line-39>
<line-40> sys.stdin = open('input'+ str(inId) + '.txt', 'r') #标准输出重定向至文件</line-40>
<line-41>if outId>0:</line-41>
<line-42> dprint('use output', outId)</line-42>
<line-43> sys.stdout = open('stdout'+ str(outId) + '.txt', 'w') #标准输出重定向至文件</line-43>
<line-44> atexit.register(lambda :sys.stdout.close()) #idle 中不会执行 atexit</line-44>
<line-45> </line-45>
<line-46>N, = getIntList()</line-46>
<line-47></line-47>
<line-48>zz = getIntList()</line-48>
<line-49>zz.sort()</line-49>
<line-50>result = (zz[N-1] - zz[0]) * (zz[2*N-1] - zz[N])</line-50>
<line-51></line-51>
<line-52>dif = zz[2*N-1] - zz[0]</line-52>
<line-53></line-53>
<line-54>for i in range(N):</line-54>
<line-55> nd = zz[i+N-1] - zz[i]</line-55>
<line-57></line-57>
<line-58>print(result)</line-58>
<line-59></line-59>
<line-60></line-60>
<line-61></line-61>
<line-62></line-62>
<line-63></line-63>
<line-64></line-64>
<line-65></line-65>
|
{"code": "<line-2>import collections, atexit, math, sys</line-2>\n<line-56> result = min(result, nd*dif)</line-56>", "lines": [2, 56]}
#### 0
|
<line-1>3</line-1>
<line-3>a = [True] * (n + 2)</line-3>
<line-4>for i in range(2, n + 2):</line-4>
<line-5> if not a[i]:</line-5>
<line-6> continue</line-6>
<line-7> j = i * i</line-7>
<line-8> while j < n + 2:</line-8>
<line-9> a[j] = False</line-9>
<line-10> j += i</line-10>
<line-11>if n <= 2:</line-11>
<line-12> print(1)</line-12>
<line-13>else:</line-13>
<line-15>print(' '.join('1' if x else '2' for x in a[2:]))</line-15>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-14> print(2)</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>p, n = [], int(input())</line-1>
<line-3>for i in range(n):</line-3>
<line-4> t = list(map(int, input().split()))</line-4>
<line-5> k = t[0] // 2 + 1</line-5>
<line-6> a += sum(t[1: k])</line-6>
<line-7> if t[0] & 1:</line-7>
<line-8> p.append(t[k])</line-8>
<line-9> b += sum(t[k + 1: ])</line-9>
<line-10> else: b += sum(t[k: ])</line-10>
<line-12>print(a + sum(p[0 :: 2]), b + sum(p[1 :: 2]))</line-12>
|
{"code": "<line-2>a = b = 0</line-2>\n<line-11>p.sort(reverse = True)</line-11>", "lines": [2, 11]}
#### 0
|
<line-1></line-1>
<line-2>def main():</line-2>
<line-4> l = len(s)</line-4>
<line-5> </line-5>
<line-6> pretty_count = 0</line-6>
<line-7> for i in range(l):</line-7>
<line-8> left_paren_count = 0</line-8>
<line-9> right_paren_count = 0</line-9>
<line-10> wild_count = 0</line-10>
<line-11> for j in range(i, l):</line-11>
<line-12> if s[j] == '(':</line-12>
<line-13> left_paren_count += 1</line-13>
<line-14> elif s[j] == ')':</line-14>
<line-15> right_paren_count += 1</line-15>
<line-16> else: </line-16>
<line-17> wild_count += 1</line-17>
<line-18> </line-18>
<line-19> if left_paren_count + wild_count < right_paren_count:</line-19>
<line-20> break</line-20>
<line-21> if left_paren_count < wild_count + right_paren_count:</line-21>
<line-22> # Should fix one '?' as '('</line-22>
<line-23> wild_count -= 1</line-23>
<line-24> left_paren_count += 1</line-24>
<line-25> if wild_count < 0:</line-25>
<line-26> break</line-26>
<line-27> if left_paren_count == wild_count + right_paren_count:</line-27>
<line-28> pretty_count += 1</line-28>
<line-29> print(pretty_count)</line-29>
<line-30></line-30>
<line-31></line-31>
<line-32>def __starting_point():</line-32>
<line-34></line-34>
<line-35>__starting_point()</line-35>
|
{"code": "<line-3> s = input()</line-3>\n<line-33> main()</line-33>", "lines": [3, 33]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>n = int(input())</line-4>
<line-5></line-5>
<line-6>for _ in range(n):</line-6>
<line-7> print(s1, s2)</line-7>
<line-8> killed, new = input().split()</line-8>
<line-9> if s1 == killed:</line-9>
<line-10> s1 = new</line-10>
<line-11> else:</line-11>
<line-13></line-13>
<line-14>print(s1, s2)</line-14>
|
{"code": "<line-3>s1, s2 = input().split()</line-3>\n<line-12> s2 = new</line-12>", "lines": [3, 12]}
#### 0
|
<line-1>def i1():</line-1>
<line-3>def i2():</line-3>
<line-4> return [int(i) for i in input().split()]</line-4>
<line-5>q=i1()</line-5>
<line-6>import math</line-6>
<line-7>y=[]</line-7>
<line-8>for i in range(q):</line-8>
<line-9> y.append(i2())</line-9>
<line-10></line-10>
<line-11>for a,b in y:</line-11>
<line-12> x=a*b</line-12>
<line-13> c=int(math.sqrt(x))</line-13>
<line-14> if c**2==x:</line-14>
<line-15> c-=1</line-15>
<line-16> z=2*c</line-16>
<line-17> if c>0 and (x//c)==c:</line-17>
<line-18> z-=1</line-18>
<line-19> if c>0 and x%c==0 and (x//c-1)==c:</line-19>
<line-20> z-=1</line-20>
<line-21> if a<=c:</line-21>
<line-22> z-=1</line-22>
<line-23> if b<=c:</line-23>
<line-25> print(z)</line-25>
|
{"code": "<line-2> return int(input())</line-2>\n<line-24> z-=1</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>l = [0] * (10**6 + 100)</line-3>
<line-4>for x in a:</line-4>
<line-5> l[x] += 1</line-5>
<line-6>cur = 0</line-6>
<line-7>ans = 0</line-7>
<line-8>for x in l:</line-8>
<line-9> cur += x</line-9>
<line-10> if cur % 2:</line-10>
<line-11> ans += 1</line-11>
<line-13>print(ans)</line-13>
|
{"code": "<line-2>a = [int(x) for x in input().split()]</line-2>\n<line-12>\tcur //= 2</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>import itertools</line-1>
<line-3></line-3>
<line-4>n, A, cf, cm, m = [int(x) for x in input().split()]</line-4>
<line-5>skills = [int(x) for x in input().split()]</line-5>
<line-6>sorted_skills = list(sorted((k, i) for i, k in enumerate(skills)))</line-6>
<line-7>bottom_lift = [0 for i in range(n)]</line-7>
<line-8>for i in range(1, n):</line-8>
<line-9> bottom_lift[i] = bottom_lift[i-1] + i * (sorted_skills[i][0] - sorted_skills[i-1][0])</line-9>
<line-10>root_lift = [0 for i in range(n+1)]</line-10>
<line-11>for i in range(1, n+1):</line-11>
<line-12> root_lift[i] = root_lift[i-1] + A - sorted_skills[n-i][0]</line-12>
<line-13></line-13>
<line-14>max_level = -1</line-14>
<line-15>for i in range(n+1):</line-15>
<line-16> money_left = m - root_lift[i]</line-16>
<line-17> if money_left < 0: break</line-17>
<line-18> k = min(bisect.bisect(bottom_lift, money_left), n-i)</line-18>
<line-19> money_left -= bottom_lift[k-1]</line-19>
<line-20> min_level = min(A, sorted_skills[k-1][0] + money_left//k) if k > 0 else A</line-20>
<line-21> level = cf*i + cm*min_level</line-21>
<line-22> if max_level < level:</line-22>
<line-23> max_level = level</line-23>
<line-24> argmax = i</line-24>
<line-25> argmax_min_level = min_level</line-25>
<line-26> argmax_k = k</line-26>
<line-27></line-27>
<line-28>ans = [0 for i in range(n)]</line-28>
<line-29>for i, skill in enumerate(sorted_skills):</line-29>
<line-30> if i < argmax_k:</line-30>
<line-31> ans[skill[1]] = argmax_min_level</line-31>
<line-32> elif i >= n - argmax:</line-32>
<line-33> ans[skill[1]] = A</line-33>
<line-34> else:</line-34>
<line-35> ans[skill[1]] = skill[0]</line-35>
<line-36></line-36>
<line-37>print(max_level)</line-37>
<line-39> print(a, end = ' ')</line-39>
<line-40> </line-40>
|
{"code": "<line-2>import bisect</line-2>\n<line-38>for a in ans:</line-38>", "lines": [2, 38]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3></line-3>
<line-4>inv = 0</line-4>
<line-5>out = 0</line-5>
<line-6>mult = 1</line-6>
<line-7>for i in range(32):</line-7>
<line-8> curr = dict()</line-8>
<line-9> opp = 0</line-9>
<line-10> same = 0</line-10>
<line-11></line-11>
<line-12> for v in l:</line-12>
<line-13> if v ^ 1 in curr:</line-13>
<line-14> if v & 1:</line-14>
<line-15> opp += curr[v ^ 1]</line-15>
<line-16> else:</line-16>
<line-17> same += curr[v ^ 1]</line-17>
<line-18> </line-18>
<line-19> if v not in curr:</line-19>
<line-20> curr[v] = 0</line-20>
<line-21> curr[v] += 1</line-21>
<line-22></line-22>
<line-23> for i in range(n):</line-23>
<line-24> l[i] >>= 1</line-24>
<line-25></line-25>
<line-26> if same <= opp:</line-26>
<line-27> inv += same</line-27>
<line-28> else:</line-28>
<line-29> inv += opp</line-29>
<line-30> out += mult</line-30>
<line-32>print(inv, out)</line-32>
<line-33> </line-33>
<line-34> </line-34>
|
{"code": "<line-2>l = list(map(int, input().split()))</line-2>\n<line-31> mult *= 2</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>3</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>class CumTree:</line-5>
<line-6> </line-6>
<line-7> def __init__(self, a, b):</line-7>
<line-8> self.a = a</line-8>
<line-9> self.b = b</line-9>
<line-10> self.count = 0</line-10>
<line-11> if a == b:</line-11>
<line-12> return</line-12>
<line-13> mid = (a + b) // 2</line-13>
<line-14> self.levo = CumTree(a, mid)</line-14>
<line-15> self.desno = CumTree(mid+1, b)</line-15>
<line-16> </line-16>
<line-17> def manjsi(self, t):</line-17>
<line-18> if self.a >= t:</line-18>
<line-19> return 0</line-19>
<line-20> if self.b < t:</line-20>
<line-21> return self.count</line-21>
<line-22> return self.levo.manjsi(t) + self.desno.manjsi(t)</line-22>
<line-23> </line-23>
<line-24> def vstavi(self, t):</line-24>
<line-25> if self.a <= t <= self.b:</line-25>
<line-26> self.count += 1</line-26>
<line-27> if self.a == self.b:</line-27>
<line-28> return</line-28>
<line-29> self.levo.vstavi(t)</line-29>
<line-30> self.desno.vstavi(t)</line-30>
<line-31> </line-31>
<line-32>n = int(sys.stdin.readline())</line-32>
<line-33>p = [int(x) for x in sys.stdin.readline().strip().split()]</line-33>
<line-34></line-34>
<line-35>ct = CumTree(1, 4096)</line-35>
<line-36></line-36>
<line-37>vsota = 0</line-37>
<line-38>while len(p) > 0:</line-38>
<line-39> x = p.pop()</line-39>
<line-40> vsota += ct.manjsi(x)</line-40>
<line-41> ct.vstavi(x)</line-41>
<line-42></line-42>
<line-44>print("%f" % (4*k + d))</line-44>
|
{"code": "<line-3>import sys</line-3>\n<line-43>k, d = vsota // 2, vsota % 2</line-43>", "lines": [3, 43]}
#### 0
|
<line-1>"""</line-1>
<line-3></line-3>
<line-4>Author : chaotic_iak</line-4>
<line-5>Language: Python 3.3.4</line-5>
<line-6>"""</line-6>
<line-7></line-7>
<line-8>def read(mode=2):</line-8>
<line-9> # 0: String</line-9>
<line-10> # 1: List of strings</line-10>
<line-11> # 2: List of integers</line-11>
<line-12> inputs = input().strip()</line-12>
<line-13> if mode == 0:</line-13>
<line-14> return inputs</line-14>
<line-15> if mode == 1:</line-15>
<line-16> return inputs.split()</line-16>
<line-17> if mode == 2:</line-17>
<line-18> return [int(x) for x in inputs.split()]</line-18>
<line-19></line-19>
<line-20>def write(s="\n"):</line-20>
<line-21> if isinstance(s, list): s = " ".join(map(str,s))</line-21>
<line-22> s = str(s)</line-22>
<line-23> print(s, end="")</line-23>
<line-24></line-24>
<line-25>################################################### SOLUTION</line-25>
<line-26>n,m = read()</line-26>
<line-27>v = read()</line-27>
<line-28>best = 0</line-28>
<line-29>for i in range(m):</line-29>
<line-30> a,b,c = read()</line-30>
<line-31> temp = (v[a-1] + v[b-1]) / c</line-31>
<line-33>print(best)</line-33>
|
{"code": "<line-2>Codeforces Round 254 Div 1 Problem A</line-2>\n<line-32> best = max(best, temp)</line-32>", "lines": [2, 32]}
#### 0
|
<line-1>def Search(L,aa,x):</line-1>
<line-3> b=len(L)</line-3>
<line-4> while(b-a>1):</line-4>
<line-5> i=(b+a)//2</line-5>
<line-6> if(L[i]>x):</line-6>
<line-7> b=i</line-7>
<line-8> elif(L[i]<x):</line-8>
<line-9> a=i</line-9>
<line-10> else:</line-10>
<line-11> return (i+1)-aa-1</line-11>
<line-12> return b-aa-1</line-12>
<line-13></line-13>
<line-14>import math</line-14>
<line-15></line-15>
<line-16>n,d=list(map(int,input().split()))</line-16>
<line-17></line-17>
<line-18>P=list(map(int,input().split()))</line-18>
<line-19>ans=0</line-19>
<line-20>for i in range(n):</line-20>
<line-21> x=Search(P,i,P[i]+d)</line-21>
<line-22> if(x>1):</line-22>
<line-24>print(ans)</line-24>
|
{"code": "<line-2> a=aa</line-2>\n<line-23> ans+=((x)*(x-1))//2</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>m = int(input())</line-1>
<line-3></line-3>
<line-4>sa = [0] * len(s)</line-4>
<line-5>for i in range(len(s)):</line-5>
<line-6> sa[i] = ord(s[i]) - ord('a')</line-6>
<line-7></line-7>
<line-8>sa = [-1] + sa + [-1]</line-8>
<line-9></line-9>
<line-10>def check_value(sa, m, threshold):</line-10>
<line-11> prev_ind = 0</line-11>
<line-12> for i in range(len(sa)):</line-12>
<line-13> if sa[i] <= threshold:</line-13>
<line-14> if i - prev_ind <= m:</line-14>
<line-15> prev_ind = i</line-15>
<line-16> else:</line-16>
<line-17> return False</line-17>
<line-18> return True</line-18>
<line-19></line-19>
<line-20>def get_indexes(sa, threshold):</line-20>
<line-21> seq = [i for i in range(len(sa)) if sa[i] <= threshold]</line-21>
<line-22> # seq = []</line-22>
<line-23> # for i in range(len(sa)):</line-23>
<line-24> # if sa[i] < threshold:</line-24>
<line-25> # seq[i].append(sa[i], i)</line-25>
<line-26> return seq</line-26>
<line-27></line-27>
<line-28>def filter_indexes(sa, seq, el, m):</line-28>
<line-29> new_seq = [0]</line-29>
<line-30> for i in range(1, len(seq) - 1):</line-30>
<line-31> if sa[seq[i]] != el or (sa[seq[i]] == el and seq[i+1] - new_seq[-1] > m):</line-31>
<line-32> new_seq.append(seq[i])</line-32>
<line-33> return new_seq[1:]</line-33>
<line-34></line-34>
<line-35></line-35>
<line-36>threshold = -1</line-36>
<line-37>while (not check_value(sa, m, threshold)):</line-37>
<line-38> # print(threshold, get_indexes(sa, threshold))</line-38>
<line-39> threshold += 1</line-39>
<line-40># print(threshold, get_indexes(sa, threshold), sa)</line-40>
<line-41></line-41>
<line-42>seq = get_indexes(sa, threshold)</line-42>
<line-43>seq = filter_indexes(sa, seq, threshold, m)</line-43>
<line-44></line-44>
<line-46>print(s)</line-46>
|
{"code": "<line-2>s = input().strip()</line-2>\n<line-45>s = ''.join(sorted([chr(ord('a') + sa[x]) for x in seq]))</line-45>", "lines": [2, 45]}
#### 0
|
<line-1>def read_data():</line-1>
<line-3> hs = list(map(int, input().split()))</line-3>
<line-4> return n, hs</line-4>
<line-5></line-5>
<line-6></line-6>
<line-7>def solve(n, hs):</line-7>
<line-8> left = get_left_index(n, hs)</line-8>
<line-9> right = get_right_index(n, hs)</line-9>
<line-10> vals = [[] for i in range(n)]</line-10>
<line-11> for h, l, r in zip(hs, left, right):</line-11>
<line-12> vals[r - l - 2].append(h)</line-12>
<line-13> min_hs = []</line-13>
<line-14> min_h = - float('inf')</line-14>
<line-15> for val in vals[::-1]:</line-15>
<line-16> for v in val:</line-16>
<line-17> min_h = max(min_h, v)</line-17>
<line-18> min_hs.append(min_h)</line-18>
<line-19> print(* min_hs[::-1])</line-19>
<line-20></line-20>
<line-21></line-21>
<line-22>def get_left_index(n, hs):</line-22>
<line-23> left = []</line-23>
<line-24> stack = []</line-24>
<line-25> for i, h in enumerate(hs):</line-25>
<line-26> while stack and hs[stack[-1]] >= h:</line-26>
<line-27> del stack[-1]</line-27>
<line-28> if stack:</line-28>
<line-29> left.append(stack[-1])</line-29>
<line-30> else:</line-30>
<line-31> left.append(-1)</line-31>
<line-32> stack.append(i)</line-32>
<line-33> return left</line-33>
<line-34></line-34>
<line-35></line-35>
<line-36>def get_right_index(n, hs):</line-36>
<line-37> hs.reverse()</line-37>
<line-38> tmp = get_left_index(n, hs)</line-38>
<line-39> hs.reverse()</line-39>
<line-40> tmp.reverse()</line-40>
<line-41> right = [n - 1 - a for a in tmp]</line-41>
<line-42> return right</line-42>
<line-43></line-43>
<line-45>solve(n, hs)</line-45>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-44>n, hs = read_data()</line-44>", "lines": [2, 44]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>b = [0 for i in range(n)]</line-3>
<line-4>s = 0</line-4>
<line-5>for i in range(n):</line-5>
<line-6> j = int((arr[i] << 1) ** 0.5)</line-6>
<line-7> if j * (j + 1) > (arr[i] << 1):</line-7>
<line-8> j -= 1</line-8>
<line-9> s ^= j</line-9>
<line-10>if s != 0:</line-10>
<line-11> print('NO')</line-11>
<line-13> print('YES')</line-13>
|
{"code": "<line-2>arr = [int(input()) for i in range(n)]</line-2>\n<line-12>else:</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>__author__ = 'Think'</line-1>
<line-3>aints=[int(i) for i in input().split()]</line-3>
<line-4>permutes=[int(i)-1 for i in input().split()]</line-4>
<line-5>results=[0]</line-5>
<line-6></line-6>
<line-7>rebuilt={}</line-7>
<line-8>m=0</line-8>
<line-9>for numby in range(n-1, 0, -1):</line-9>
<line-10> p=permutes[numby]</line-10>
<line-11> below=False</line-11>
<line-12> above=False</line-12>
<line-13> if p-1 in rebuilt:</line-13>
<line-14> below=True</line-14>
<line-15> if p+1 in rebuilt:</line-15>
<line-16> above=True</line-16>
<line-17> if above and below:</line-17>
<line-18> bsum, bottom=rebuilt[p-1]</line-18>
<line-19> asum, top=rebuilt[p+1]</line-19>
<line-20> new=bsum+asum+aints[p]</line-20>
<line-21> rebuilt[bottom]=(new, top)</line-21>
<line-22> rebuilt[top]=(new, bottom)</line-22>
<line-23> elif above or below:</line-23>
<line-24> if above:</line-24>
<line-25> other=p+1</line-25>
<line-26> else:</line-26>
<line-27> other=p-1</line-27>
<line-28> psum, prev=rebuilt[other]</line-28>
<line-29> new=psum+aints[p]</line-29>
<line-30> rebuilt[prev]=(new, p)</line-30>
<line-31> rebuilt[p]=(new, prev)</line-31>
<line-32> else:</line-32>
<line-33> new=aints[p]</line-33>
<line-34> rebuilt[p]=(new, p)</line-34>
<line-35> m=max(new, m)</line-35>
<line-36> results.append(m)</line-36>
<line-38> print(results[numby])</line-38>
<line-39></line-39>
<line-40></line-40>
|
{"code": "<line-2>n=int(input())</line-2>\n<line-37>for numby in range(n-1, -1, -1):</line-37>", "lines": [2, 37]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>s, l = 0, 1</line-3>
<line-4>p = [0] * n</line-4>
<line-5>for i in range(n):</line-5>
<line-6> t = list(map(int, input().split()))</line-6>
<line-7> if t[0] == 1:</line-7>
<line-8> b[t[1] - 1] += t[2]</line-8>
<line-9> s += t[1] * t[2]</line-9>
<line-10> elif t[0] == 2:</line-10>
<line-11> a[l] = t[1]</line-11>
<line-12> l += 1</line-12>
<line-13> s += t[1]</line-13>
<line-14> else:</line-14>
<line-15> l -= 1</line-15>
<line-16> s -= a[l] + b[l]</line-16>
<line-17> b[l - 1] += b[l]</line-17>
<line-18> b[l] = 0</line-18>
<line-20>print('\n'.join(p))</line-20>
|
{"code": "<line-2>a, b = [0] * (n + 2), [0] * (n + 2)</line-2>\n<line-19> p[i] = str(s / l)</line-19>", "lines": [2, 19]}
#### 0
|
<line-1># -*- coding: utf-8 -*-</line-1>
<line-3>from sys import stdin</line-3>
<line-4></line-4>
<line-5>def run(n, s):</line-5>
<line-6> m = 0</line-6>
<line-7> small = n // 2</line-7>
<line-8> for big in range(n-1, (n+1)//2-1, -1):</line-8>
<line-9> while small >= 0 and s[small] > s[big] / 2:</line-9>
<line-10> small -= 1</line-10>
<line-11> if small == -1:</line-11>
<line-12> break</line-12>
<line-13> #print(small, big)</line-13>
<line-14> small -= 1</line-14>
<line-15> m += 1</line-15>
<line-16> print(n-m)</line-16>
<line-17></line-17>
<line-18>def run2(n, s):</line-18>
<line-19> r = n - 1</line-19>
<line-20> l = n // 2 - 1</line-20>
<line-21> result = 0</line-21>
<line-22> while l >= 0:</line-22>
<line-23> if s[l] * 2 <= s[r]:</line-23>
<line-24> result += 1</line-24>
<line-25> r -= 1</line-25>
<line-26> l -= 1</line-26>
<line-27> print(n - result)</line-27>
<line-28></line-28>
<line-29>n = int(input())</line-29>
<line-31>run(n, s)</line-31>
|
{"code": "<line-2>from time import perf_counter</line-2>\n<line-30>s = sorted([int(x) for x in stdin.read().strip().split('\\n')])</line-30>", "lines": [2, 30]}
#### 0
|
<line-1>from bisect import bisect_left, insort_left</line-1>
<line-3>n = int(input())</line-3>
<line-4>for _ in range(n):</line-4>
<line-5> #print(a)</line-5>
<line-6> s, d = list(map(int, input().split()))</line-6>
<line-7> if len(a) == 0:</line-7>
<line-8> print(s, s+d - 1)</line-8>
<line-9> a.append((s, s + d - 1))</line-9>
<line-10> continue</line-10>
<line-11> p = bisect_left(a, (s, s + d - 1))</line-11>
<line-12> #print('p', p)</line-12>
<line-13> ok = True</line-13>
<line-14> if p > 0 and a[p-1][1] >= s:</line-14>
<line-15> ok = False</line-15>
<line-16> if p < len(a) and a[p][0] <= s + d - 1:</line-16>
<line-17> ok = False</line-17>
<line-18> if ok:</line-18>
<line-19> insort_left(a, (s, s + d - 1))</line-19>
<line-20> print(s, s + d - 1)</line-20>
<line-21> else:</line-21>
<line-22> ok = False</line-22>
<line-23> for i in range(len(a)):</line-23>
<line-24> if i == 0:</line-24>
<line-25> if a[0][0] > d:</line-25>
<line-26> print(1,d)</line-26>
<line-27> a = [(1, d)] + a</line-27>
<line-28> ok = True</line-28>
<line-29> break</line-29>
<line-30> else:</line-30>
<line-31> if a[i - 1][1] + d < a[i][0]:</line-31>
<line-32> print(a[i - 1][1] + 1, a[i - 1][1] + d)</line-32>
<line-33> insort_left(a, (a[i - 1][1] + 1, a[i - 1][1] + d))</line-33>
<line-34> ok = True</line-34>
<line-35> break</line-35>
<line-36> if not ok:</line-36>
<line-38> insort_left(a, (a[-1][1] + 1, a[-1][1] + d))</line-38>
|
{"code": "<line-2>a = []</line-2>\n<line-37> print(a[-1][1] + 1, a[-1][1] + d)</line-37>", "lines": [2, 37]}
#### 0
|
<line-1>def evens(A):</line-1>
<line-3> l = n//2-1; r = n//2</line-3>
<line-4> if len(A)%2 == 1: l+= 1</line-4>
<line-5> ans = [max(A[l], A[r])]</line-5>
<line-6> while r < n-1:</line-6>
<line-7> l-= 1; r+= 1</line-7>
<line-8> ans.append(max(ans[-1], A[l], A[r]))</line-8>
<line-9> return ans</line-9>
<line-10></line-10>
<line-11>def interleave(A, B):</line-11>
<line-12> q = []</line-12>
<line-13> for i in range(len(B)): q+= [A[i], B[i]]</line-13>
<line-14> if len(A) != len(B): q.append(A[-1])</line-14>
<line-15> return q</line-15>
<line-16></line-16>
<line-17>n = int(input())</line-17>
<line-18>A = list(map(int,input().split()))</line-18>
<line-19>M = [min(A[i],A[i+1]) for i in range(n-1)]</line-19>
<line-20>ansA = evens(A)</line-20>
<line-21>ansM = evens(M) if n>1 else []</line-21>
<line-23>else: print(*interleave(ansM, ansA[1:]), max(A))</line-23>
|
{"code": "<line-2> n = len(A)</line-2>\n<line-22>if n%2 == 0: print(*interleave(ansA, ansM[1:]), max(A))</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>from collections import defaultdict, deque</line-1>
<line-2> </line-2>
<line-4>def bfs(graph, inicio, destino, parent):</line-4>
<line-5> parent.clear()</line-5>
<line-6> queue = deque()</line-6>
<line-7> queue.append([inicio, float("Inf")])</line-7>
<line-8> parent[inicio] = -2</line-8>
<line-9> while (len(queue)):</line-9>
<line-10> current, flow = queue.popleft()</line-10>
<line-11> for i in adj[current]:</line-11>
<line-12> if parent[i] == -1 and graph[current][i] > 0:</line-12>
<line-13> parent[i] = current</line-13>
<line-14> flow = min(flow, graph[current][i])</line-14>
<line-15> if i == destino:</line-15>
<line-16> return flow</line-16>
<line-17> queue.append((i, flow))</line-17>
<line-18> return 0</line-18>
<line-19> </line-19>
<line-20> </line-20>
<line-21>def maxflow(graph, inicio, destino):</line-21>
<line-22> flow = 0</line-22>
<line-23> parent = defaultdict(lambda: -1)</line-23>
<line-24> while True:</line-24>
<line-25> t = bfs(graph, inicio, destino, parent)</line-25>
<line-26> if t:</line-26>
<line-27> flow += t</line-27>
<line-28> current = destino</line-28>
<line-29> while current != inicio:</line-29>
<line-30> prev = parent[current]</line-30>
<line-31> graph[prev][current] -= t</line-31>
<line-32> graph[current][prev] += t</line-32>
<line-33> current = prev</line-33>
<line-34> else:</line-34>
<line-35> break</line-35>
<line-36> return flow</line-36>
<line-37> </line-37>
<line-38> </line-38>
<line-39>n, m, x = [int(i) for i in input().split()]</line-39>
<line-40></line-40>
<line-41>for _ in range(m):</line-41>
<line-42> t = [int(i) for i in input().split()]</line-42>
<line-43> adj[t[0]][t[1]] = t[2]</line-43>
<line-44> </line-44>
<line-45> </line-45>
<line-46>def check(k):</line-46>
<line-47> meh = defaultdict(lambda: defaultdict(lambda: 0))</line-47>
<line-48> for i in adj:</line-48>
<line-49> for j in adj[i]:</line-49>
<line-50> ww = adj[i][j] // k</line-50>
<line-51> meh[i][j] = ww</line-51>
<line-52> flow = maxflow(meh, 1, n)</line-52>
<line-53> return flow</line-53>
<line-54> </line-54>
<line-55> </line-55>
<line-56>lo = 1 / x</line-56>
<line-57>hi = check(1)</line-57>
<line-58> </line-58>
<line-59>for _ in range(70):</line-59>
<line-60> mid = (hi + lo) / 2</line-60>
<line-61> if hi-lo<0.0000000001:</line-61>
<line-62> break</line-62>
<line-63> if check(mid)>=x:</line-63>
<line-64> lo = mid</line-64>
<line-65> else:</line-65>
<line-67>print(format(lo * x, '.9f'))</line-67>
|
{"code": "<line-3>adj = defaultdict(lambda: defaultdict(lambda: 0))</line-3>\n<line-66> hi = mid</line-66>", "lines": [3, 66]}
#### 0
|
<line-1># http://codeforces.com/problemset/problem/848/B</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>def get_dest(start, w, h):</line-5>
<line-6> if start[0] == 1:</line-6>
<line-7> return (str(start[1]), str(h))</line-7>
<line-8> else:</line-8>
<line-9> return (str(w), str(start[1]))</line-9>
<line-10></line-10>
<line-11></line-11>
<line-12>n, w, h = [int(x) for x in input().split()]</line-12>
<line-13>dancers = []</line-13>
<line-14>groups = defaultdict(list)</line-14>
<line-15>destinations = [None for x in range(n)]</line-15>
<line-16>for ii in range(n):</line-16>
<line-17> g, p, t = [int(x) for x in input().split()]</line-17>
<line-18> dancers.append((g, p, t))</line-18>
<line-19> groups[p-t].append(ii)</line-19>
<line-20></line-20>
<line-21></line-21>
<line-22>for gg in list(groups.values()):</line-22>
<line-23> V, H = [], []</line-23>
<line-24> for ii in gg:</line-24>
<line-25> dancer = dancers[ii]</line-25>
<line-26> if dancer[0] == 1:</line-26>
<line-27> V.append(dancer)</line-27>
<line-28> else:</line-28>
<line-29> H.append(dancer)</line-29>
<line-30> V.sort(key=lambda x: -x[1])</line-30>
<line-31> H.sort(key=lambda x: x[1])</line-31>
<line-32> table = {orig: get_dest(new, w, h) for orig, new in zip(V+H, H+V)}</line-32>
<line-33> for ii in gg:</line-33>
<line-34> destinations[ii] = table[dancers[ii]]</line-34>
<line-35></line-35>
<line-36># print(destinations)</line-36>
<line-38> print(" ".join(dd))</line-38>
|
{"code": "<line-2>from collections import defaultdict</line-2>\n<line-37>for dd in destinations:</line-37>", "lines": [2, 37]}
#### 0
|
<line-1></line-1>
<line-2>def Sieve(n): </line-2>
<line-4> divlis = [-1] * (n+1) </line-4>
<line-5> </line-5>
<line-6> flag = [True] * (n+1)</line-6>
<line-7> flag[0] = False</line-7>
<line-8> flag[1] = False</line-8>
<line-9></line-9>
<line-10> ind = 2</line-10>
<line-11> while ind <= n:</line-11>
<line-12></line-12>
<line-13> if flag[ind]:</line-13>
<line-14> ret.append(ind)</line-14>
<line-15></line-15>
<line-16> ind2 = ind ** 2</line-16>
<line-17></line-17>
<line-18> while ind2 <= n:</line-18>
<line-19> flag[ind2] = False</line-19>
<line-20> divlis[ind2] = ind</line-20>
<line-21> ind2 += ind</line-21>
<line-22></line-22>
<line-23> ind += 1</line-23>
<line-24></line-24>
<line-25> return ret,divlis</line-25>
<line-26></line-26>
<line-27></line-27>
<line-28>sev,divlis = Sieve(210000)</line-28>
<line-29></line-29>
<line-30>n = int(input())</line-30>
<line-31>a = list(map(int,input().split()))</line-31>
<line-32></line-32>
<line-33>dic = {}</line-33>
<line-34></line-34>
<line-35>for i in range(n):</line-35>
<line-36></line-36>
<line-37> nd = {}</line-37>
<line-38></line-38>
<line-39> na = a[i]</line-39>
<line-40> while divlis[na] != -1:</line-40>
<line-41></line-41>
<line-42> if divlis[na] not in nd:</line-42>
<line-43> nd[divlis[na]] = 0</line-43>
<line-44> nd[divlis[na]] += 1</line-44>
<line-45></line-45>
<line-46> na //= divlis[na]</line-46>
<line-47></line-47>
<line-48> if na != 1:</line-48>
<line-49> if na not in nd:</line-49>
<line-50> nd[na] = 1</line-50>
<line-51> else:</line-51>
<line-52> nd[na] += 1</line-52>
<line-53></line-53>
<line-54> for x in nd:</line-54>
<line-55> if x not in dic:</line-55>
<line-56> dic[x] = []</line-56>
<line-57> dic[x].append(nd[x])</line-57>
<line-58></line-58>
<line-59>ans = 1</line-59>
<line-60></line-60>
<line-61>for i in dic:</line-61>
<line-62></line-62>
<line-63> if len(dic[i]) < n-1:</line-63>
<line-64> #print (i,"a")</line-64>
<line-65> continue</line-65>
<line-66> </line-66>
<line-67> dic[i].sort()</line-67>
<line-68></line-68>
<line-69> if len(dic[i]) == n:</line-69>
<line-70> ans *= i ** dic[i][1]</line-70>
<line-71> #print (i,"b")</line-71>
<line-72> else:</line-72>
<line-73> ans *= i ** dic[i][0]</line-73>
<line-75></line-75>
<line-76>print (ans)</line-76>
|
{"code": "<line-3> ret = []</line-3>\n<line-74> #print (i,\"c\")</line-74>", "lines": [3, 74]}
#### 0
|
<line-1>class DisjointSet(object):</line-1>
<line-3> self.parent = list(range(n))</line-3>
<line-4> self.rank = [0] * n</line-4>
<line-5> self.num = n # number of disjoint sets</line-5>
<line-6></line-6>
<line-7> def union(self, x, y):</line-7>
<line-8> self._link(self.find_set(x), self.find_set(y))</line-8>
<line-9></line-9>
<line-10> def _link(self, x, y):</line-10>
<line-11> if x == y:</line-11>
<line-12> return</line-12>
<line-13> self.num -= 1</line-13>
<line-14> if self.rank[x] > self.rank[y]:</line-14>
<line-15> self.parent[y] = x</line-15>
<line-16> else:</line-16>
<line-17> self.parent[x] = y</line-17>
<line-18> if self.rank[x] == self.rank[y]:</line-18>
<line-19> self.rank[y] += 1</line-19>
<line-20></line-20>
<line-21> def find_set(self, x):</line-21>
<line-22> xp = self.parent[x]</line-22>
<line-23> if xp != x:</line-23>
<line-24> self.parent[x] = self.find_set(xp)</line-24>
<line-25> return self.parent[x]</line-25>
<line-26></line-26>
<line-27></line-27>
<line-28>def solve():</line-28>
<line-29> n, m = list(map(int, input().split()))</line-29>
<line-30> ds = DisjointSet(n * 2)</line-30>
<line-31> for i in range(m):</line-31>
<line-32> a, b, c = list(map(int, input().split()))</line-32>
<line-33> a -= 1</line-33>
<line-34> b -= 1</line-34>
<line-35> aA = a * 2</line-35>
<line-36> aB = aA + 1</line-36>
<line-37> bA = b * 2</line-37>
<line-38> bB = bA + 1</line-38>
<line-39> if c == 0:</line-39>
<line-40> if ds.find_set(aA) == ds.find_set(bA):</line-40>
<line-41> return 0</line-41>
<line-42> ds.union(aA, bB)</line-42>
<line-43> ds.union(aB, bA)</line-43>
<line-44> else:</line-44>
<line-45> if ds.find_set(aA) == ds.find_set(bB):</line-45>
<line-46> return 0</line-46>
<line-47> ds.union(aA, bA)</line-47>
<line-48> ds.union(aB, bB)</line-48>
<line-50></line-50>
<line-51></line-51>
<line-52>print(solve())</line-52>
|
{"code": "<line-2> def __init__(self, n):</line-2>\n<line-49> return pow(2, (ds.num // 2) - 1, 10**9 + 7)</line-49>", "lines": [2, 49]}
#### 0
|
<line-1>__author__ = 'Pavel Mavrin'</line-1>
<line-2></line-2>
<line-4>a = [int(x) for x in input().split()]</line-4>
<line-5></line-5>
<line-6>s = 0</line-6>
<line-7>res = 0</line-7>
<line-8>for i in a:</line-8>
<line-9> if i == 0:</line-9>
<line-10> res += s</line-10>
<line-11> else:</line-11>
<line-13></line-13>
<line-14>print(res)</line-14>
|
{"code": "<line-3>n = int(input())</line-3>\n<line-12> s += 1</line-12>", "lines": [3, 12]}
#### 0
|
<line-1></line-1>
<line-2>import sys</line-2>
<line-4>input=sys.stdin.readline</line-4>
<line-5>mii=lambda:list(map(int,input().split()))</line-5>
<line-6></line-6>
<line-7>n,m=mii()</line-7>
<line-8>a=[0 for _ in range(n)]</line-8>
<line-9>c=[123456 for _ in range(n)]</line-9>
<line-10>for _ in range(m):</line-10>
<line-11> u,v=mii()</line-11>
<line-12> u%=n</line-12>
<line-13> v%=n</line-13>
<line-14> if v<u: v+=n</line-14>
<line-15> a[u]+=1</line-15>
<line-16> if c[u]>v: c[u]=v</line-16>
<line-17></line-17>
<line-18>ans=[]</line-18>
<line-19>for i in list(range(1,n))+[0]:</line-19>
<line-20> out=0</line-20>
<line-21> for j in range(i,n):</line-21>
<line-22> if not a[j]: continue</line-22>
<line-23> tmp=(j-i)+(a[j]-1)*n+(c[j]-j)</line-23>
<line-24> out=max(out,tmp)</line-24>
<line-25> #print(1,i,j,tmp)</line-25>
<line-26> for j in range(i):</line-26>
<line-27> if not a[j]: continue</line-27>
<line-28> tmp=(j+n-i)+(a[j]-1)*n+(c[j]-j)</line-28>
<line-29> out=max(out,tmp)</line-29>
<line-30> #print(2,i,j,tmp)</line-30>
<line-32>print(" ".join(map(str,ans)))</line-32>
|
{"code": "<line-3>#sys.stdin=open(\"data.txt\")</line-3>\n<line-31> ans.append(out)</line-31>", "lines": [3, 31]}
#### 0
|
<line-1>3</line-1>
<line-2></line-2>
<line-4>from functools import lru_cache</line-4>
<line-5></line-5>
<line-6>MOD = 1000000007</line-6>
<line-7></line-7>
<line-8>cnk = [[1 for i in range(1001)] for j in range(1001)]</line-8>
<line-9>for i in range(1, 1001):</line-9>
<line-10> for j in range(1, i):</line-10>
<line-11> cnk[i][j] = cnk[i - 1][j - 1] + cnk[i - 1][j]</line-11>
<line-12></line-12>
<line-13></line-13>
<line-14>k = int(input())</line-14>
<line-15>cs = [int(input()) for i in range(k)]</line-15>
<line-16></line-16>
<line-17>ans = 1</line-17>
<line-18>sm = 0</line-18>
<line-19>for c in cs:</line-19>
<line-20> sm += c</line-20>
<line-22></line-22>
<line-23>print(ans)</line-23>
|
{"code": "<line-3>import sys</line-3>\n<line-21> ans = (ans * cnk[sm - 1][c - 1]) % MOD</line-21>", "lines": [3, 21]}
#### 0
|
<line-2>n = int(input())</line-2>
<line-3>a = list(map(int, input().split()))</line-3>
<line-4>print(pow(2,n-1,m)-1 - sum(pow(2,a.count(x),m)-1 for x in set(a) if x != -1) % m)</line-4>
|
{"code": "<line-1>m = 1000000007</line-1>", "lines": [1]}
#### 0
|
<line-1>import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools</line-1>
<line-2></line-2>
<line-4>inf = 10**20</line-4>
<line-5>eps = 1.0 / 10**10</line-5>
<line-6>mod = 998244353</line-6>
<line-7>dd = [(-1,0),(0,1),(1,0),(0,-1)]</line-7>
<line-8>ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]</line-8>
<line-9></line-9>
<line-10>def LI(): return list(map(int, sys.stdin.readline().split()))</line-10>
<line-11>def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]</line-11>
<line-12>def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]</line-12>
<line-13>def LF(): return [float(x) for x in sys.stdin.readline().split()]</line-13>
<line-14>def LS(): return sys.stdin.readline().split()</line-14>
<line-15>def I(): return int(sys.stdin.readline())</line-15>
<line-16>def F(): return float(sys.stdin.readline())</line-16>
<line-17>def S(): return input()</line-17>
<line-18>def pf(s): return print(s, flush=True)</line-18>
<line-19>def pe(s): return print(str(s), file=sys.stderr)</line-19>
<line-20>def JA(a, sep): return sep.join(map(str, a))</line-20>
<line-21></line-21>
<line-22>def main():</line-22>
<line-23> n = I()</line-23>
<line-24> aa = [LI() for _ in range(n-1)]</line-24>
<line-25> e = collections.defaultdict(set)</line-25>
<line-26> for a,b in aa:</line-26>
<line-27> e[a].add(b)</line-27>
<line-28> e[b].add(a)</line-28>
<line-29></line-29>
<line-30> q = [[(1,-1)]]</line-30>
<line-31> qi = 0</line-31>
<line-32> while 1:</line-32>
<line-33> t = q[qi]</line-33>
<line-34> nq = []</line-34>
<line-35> for i,p in t:</line-35>
<line-36> for c in e[i]:</line-36>
<line-37> if c == p:</line-37>
<line-38> continue</line-38>
<line-39> nq.append((c,i))</line-39>
<line-40> if len(nq) < 1:</line-40>
<line-41> break</line-41>
<line-42> q.append(nq)</line-42>
<line-43> qi += 1</line-43>
<line-44></line-44>
<line-45> gm = [1]</line-45>
<line-46> for i in range(1,n+1):</line-46>
<line-47> gm.append(i*gm[-1]%mod)</line-47>
<line-48></line-48>
<line-49> m = {}</line-49>
<line-50> def f(i, p):</line-50>
<line-51> t = 1</line-51>
<line-52> r = 1</line-52>
<line-53> for c in e[i]:</line-53>
<line-54> if c == p:</line-54>
<line-55> continue</line-55>
<line-56> # print('c',c)</line-56>
<line-57> r *= m[c]</line-57>
<line-58> r %= mod</line-58>
<line-59> t += 1</line-59>
<line-60></line-60>
<line-61> if p == -1:</line-61>
<line-62> r *= gm[t-1]</line-62>
<line-63> r *= n</line-63>
<line-64> else:</line-64>
<line-65> r *= gm[t]</line-65>
<line-66> r %= mod</line-66>
<line-67> m[i] = r</line-67>
<line-68> # print('r',i,p,r)</line-68>
<line-69> # print('g',gm[t],t)</line-69>
<line-70> return r</line-70>
<line-71></line-71>
<line-72> for qt in q[::-1]:</line-72>
<line-73> for i,p in qt:</line-73>
<line-74> # print('ip', i,p)</line-74>
<line-75> f(i,p)</line-75>
<line-76></line-76>
<line-77> r = f(1,-1)</line-77>
<line-78></line-78>
<line-80></line-80>
<line-81></line-81>
<line-82>print(main())</line-82>
<line-83></line-83>
|
{"code": "<line-3>sys.setrecursionlimit(10**7)</line-3>\n<line-79> return r</line-79>", "lines": [3, 79]}
#### 0
|
<line-1>strings = int(input())</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>for k in range(strings):</line-5>
<line-6> s = input()</line-6>
<line-7> for index in range(7):</line-7>
<line-8> if s[index] == '1':</line-8>
<line-10></line-10>
<line-11>print(max(count))</line-11>
|
{"code": "<line-3>count = [0 for x in range(7)]</line-3>\n<line-9> count[index] += 1</line-9>", "lines": [3, 9]}
#### 0
|
<line-1>from collections import defaultdict, deque</line-1>
<line-2></line-2>
<line-4>adj = [[] for _ in range(n)]</line-4>
<line-5>v = [0] * n</line-5>
<line-6>l = list(map(int, input().split()))</line-6>
<line-7>for i, f in enumerate(l):</line-7>
<line-8> adj[f - 1].append(i + 1)</line-8>
<line-9></line-9>
<line-10>s = list(map(int, input().split()))</line-10>
<line-11></line-11>
<line-12>Q = deque([(0, s[0], s[0])])</line-12>
<line-13>ans = 0</line-13>
<line-14>flag = False</line-14>
<line-15>possible = True</line-15>
<line-16>while Q and possible:</line-16>
<line-17> # print(Q)</line-17>
<line-18> flag = not flag</line-18>
<line-19> for _ in range(len(Q)):</line-19>
<line-20> cur, v, curs = Q.popleft()</line-20>
<line-21> if v < 0:</line-21>
<line-22> possible = False</line-22>
<line-23> ans = -1</line-23>
<line-24> break</line-24>
<line-25> ans += v</line-25>
<line-26> if flag:</line-26>
<line-27> for i in adj[cur]:</line-27>
<line-28> if len(adj[i]) <= 1:</line-28>
<line-29> Q.append((i, 0, curs))</line-29>
<line-30> else:</line-30>
<line-31> temp = min([s[k] for k in adj[i]])</line-31>
<line-32> Q.append((i, temp - curs, temp))</line-32>
<line-33> else:</line-33>
<line-34> for i in adj[cur]:</line-34>
<line-36>print(ans)</line-36>
|
{"code": "<line-3>n = int(input())</line-3>\n<line-35> Q.append((i, s[i] - curs, s[i]))</line-35>", "lines": [3, 35]}
#### 0
|
<line-1>from time import time</line-1>
<line-2></line-2>
<line-3></line-3>
<line-5> 'N': 'S',</line-5>
<line-6> 'S': 'N',</line-6>
<line-7> 'E': 'W',</line-7>
<line-8> 'W': 'E'</line-8>
<line-9>}</line-9>
<line-10>otr = str.maketrans(opposite)</line-10>
<line-11></line-11>
<line-12>bits = {</line-12>
<line-13> 'N': 0,</line-13>
<line-14> 'S': 1,</line-14>
<line-15> 'E': 2,</line-15>
<line-16> 'W': 3,</line-16>
<line-17>}</line-17>
<line-18></line-18>
<line-19>Q = 4294967291</line-19>
<line-20></line-20>
<line-21></line-21>
<line-22>def combine(h, v, q):</line-22>
<line-23> return (h<<2 | v) % q</line-23>
<line-24></line-24>
<line-25></line-25>
<line-26>def combinel(h, v, q, s):</line-26>
<line-27> return (v*s + h) % q</line-27>
<line-28></line-28>
<line-29></line-29>
<line-30>def flip(s):</line-30>
<line-31> return ''.join(reversed(s.translate(otr)))</line-31>
<line-32></line-32>
<line-33></line-33>
<line-34>def solvable(p1, p2):</line-34>
<line-35> h1 = 0</line-35>
<line-36> h2 = 0</line-36>
<line-37> s = 1</line-37>
<line-38> for i in reversed(list(range(len(p1)))):</line-38>
<line-39> n1 = bits[p1[i]]</line-39>
<line-40> n2 = bits[opposite[p2[i]]]</line-40>
<line-41> h1 = combine(h1, n1, Q)</line-41>
<line-42> h2 = combinel(h2, n2, Q, s)</line-42>
<line-43> if h1 == h2 and p1[i:] == flip(p2[i:]):</line-43>
<line-44> return False</line-44>
<line-45> s = (s<<2) % Q</line-45>
<line-46> return True</line-46>
<line-47></line-47>
<line-48></line-48>
<line-49>def __starting_point():</line-49>
<line-50> n = int(input())</line-50>
<line-51> p1 = input()</line-51>
<line-52> p2 = input()</line-52>
<line-54></line-54>
<line-55>__starting_point()</line-55>
|
{"code": "<line-4>opposite = {</line-4>\n<line-53> print('YES' if solvable(p1, p2) else 'NO')</line-53>", "lines": [4, 53]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>N = int(readline())</line-4>
<line-5>A = list(map(int, readline().split()))</line-5>
<line-6>BW = [0, 0]</line-6>
<line-7>for i in range(N):</line-7>
<line-8> a = A[i]</line-8>
<line-9> BW[i%2] += a//2</line-9>
<line-11>print(min(BW))</line-11>
|
{"code": "<line-2>readline = sys.stdin.readline</line-2>\n<line-10> BW[(i+1)%2] += -(-a//2)</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>n, k = map(int, input().split())</line-1>
<line-3>y = x = min(t)</line-3>
<line-4>t = list(t)</line-4>
<line-5>while True:</line-5>
<line-6> for i in t:</line-6>
<line-7> if i % x > k: x = i // (i // x + 1)</line-7>
<line-8> if y == x: break</line-8>
<line-10>print(y)</line-10>
|
{"code": "<line-2>t = set(map(int, input().split()))</line-2>\n<line-9> y = x</line-9>", "lines": [2, 9]}
#### 0
|
{"code": "<line-1>print('YES' if input().count('1')+1>>1<<1 >= input().count('1') else 'NO')</line-1>", "lines": [1]}
#### 0
|
|
<line-1></line-1>
<line-2>import sys</line-2>
<line-4></line-4>
<line-5>def modfac(n, MOD):</line-5>
<line-6> </line-6>
<line-7> f = 1</line-7>
<line-8> factorials = [1]</line-8>
<line-9> for m in range(1, n + 1):</line-9>
<line-10> f *= m</line-10>
<line-11> f %= MOD</line-11>
<line-12> factorials.append(f)</line-12>
<line-13> inv = pow(f, MOD - 2, MOD)</line-13>
<line-14> invs = [1] * (n + 1)</line-14>
<line-15> invs[n] = inv</line-15>
<line-16> for m in range(n, 1, -1):</line-16>
<line-17> inv *= m</line-17>
<line-18> inv %= MOD</line-18>
<line-19> invs[m - 1] = inv</line-19>
<line-20> return factorials, invs</line-20>
<line-21></line-21>
<line-22></line-22>
<line-23>def modnCr(n,r,mod,fac,inv): </line-23>
<line-24> return fac[n] * inv[n-r] * inv[r] % mod</line-24>
<line-25></line-25>
<line-26>mod = 998244353</line-26>
<line-27></line-27>
<line-28>n = int(stdin.readline())</line-28>
<line-29>a = list(map(int,stdin.readline().split()))</line-29>
<line-30>a.sort()</line-30>
<line-32></line-32>
<line-33>print( (modnCr(2*n,n,mod,fac,inv) * (sum(a[n:]) - sum(a[:n]))) % mod )</line-33>
|
{"code": "<line-3>from sys import stdin</line-3>\n<line-31>fac,inv = modfac(2*n+10,mod)</line-31>", "lines": [3, 31]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>m, M = min(b), max(b)</line-5>
<line-6>if m == M:</line-6>
<line-7> if M == 0:</line-7>
<line-8> print('YES')</line-8>
<line-9> print(' '.join(['1' for i in range(n)]))</line-9>
<line-10> else:</line-10>
<line-11> print('NO')</line-11>
<line-12>else:</line-12>
<line-13> print('YES')</line-13>
<line-14></line-14>
<line-15> pos = list([i for i in range(n) if b[i] == M and b[i - 1] < M])[0]</line-15>
<line-16></line-16>
<line-17> a = [0 for i in range(n)]</line-17>
<line-18></line-18>
<line-19> a[pos] = M</line-19>
<line-20> a[pos - 1] = (M << 1) + b[pos - 1]</line-20>
<line-21></line-21>
<line-22> for i in range(2, n):</line-22>
<line-24></line-24>
<line-25> print(*a)</line-25>
|
{"code": "<line-3>b = list(map(int, input().split()))</line-3>\n<line-23> a[pos - i] = a[pos - i + 1] + b[pos - i]</line-23>", "lines": [3, 23]}
#### 0
|
<line-1>import sys</line-1>
<line-3>def parorder(Edge, p):</line-3>
<line-4> N = len(Edge)</line-4>
<line-5> par = [0]*N</line-5>
<line-6> par[p] = -1</line-6>
<line-7> stack = [p]</line-7>
<line-8> order = []</line-8>
<line-9> visited = set([p])</line-9>
<line-10> ast = stack.append</line-10>
<line-11> apo = order.append</line-11>
<line-12> while stack:</line-12>
<line-13> vn = stack.pop()</line-13>
<line-14> apo(vn)</line-14>
<line-15> for vf in Edge[vn]:</line-15>
<line-16> if vf in visited:</line-16>
<line-17> continue</line-17>
<line-18> visited.add(vf)</line-18>
<line-19> par[vf] = vn</line-19>
<line-20> ast(vf)</line-20>
<line-21> return par, order</line-21>
<line-22></line-22>
<line-23>def getcld(p):</line-23>
<line-24> res = [[] for _ in range(len(p))]</line-24>
<line-25> for i, v in enumerate(p[1:], 1):</line-25>
<line-26> res[v].append(i)</line-26>
<line-27> return res</line-27>
<line-28></line-28>
<line-29></line-29>
<line-30></line-30>
<line-31>N = int(readline())</line-31>
<line-32>root = None</line-32>
<line-33>Edge = [[] for _ in range(N)]</line-33>
<line-34>Cr = [None]*N</line-34>
<line-35>for a in range(N):</line-35>
<line-36> b, c = list(map(int, readline().split()))</line-36>
<line-37> b -= 1</line-37>
<line-38> if b == -1:</line-38>
<line-39> root = a</line-39>
<line-40> else:</line-40>
<line-41> Edge[a].append(b)</line-41>
<line-42> Edge[b].append(a)</line-42>
<line-43> Cr[a] = c</line-43>
<line-44></line-44>
<line-45>P, L = parorder(Edge, root)</line-45>
<line-46> </line-46>
<line-47>dp = [0]*N</line-47>
<line-48></line-48>
<line-49>for l in L[:0:-1]:</line-49>
<line-50> p = P[l]</line-50>
<line-51> dp[p] += 1+dp[l]</line-51>
<line-52></line-52>
<line-53>if any(d < c for d, c in zip(dp, Cr)):</line-53>
<line-54> print('NO')</line-54>
<line-55>else:</line-55>
<line-56> print('YES')</line-56>
<line-57> A = [None]*N</line-57>
<line-58> dp2 = [[] for _ in range(N)]</line-58>
<line-59> for l in L[:0:-1]:</line-59>
<line-60> p = P[l]</line-60>
<line-61> dp2[l] = dp2[l][:Cr[l]] + [l] + dp2[l][Cr[l]:]</line-61>
<line-62> dp2[p].extend(dp2[l])</line-62>
<line-63> dp2[root] = dp2[root][:Cr[root]] + [root] + dp2[root][Cr[root]:] </line-63>
<line-64> Ans = [None]*N</line-64>
<line-65> for i in range(N):</line-65>
<line-67> print(' '.join(map(str, Ans)))</line-67>
|
{"code": "<line-2>readline = sys.stdin.readline </line-2>\n<line-66> Ans[dp2[root][i]] = i+1</line-66>", "lines": [2, 66]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>for i in range(n):</line-3>
<line-4> a.append(list(map(int,input().split())))</line-4>
<line-5>ans = [0]*n</line-5>
<line-6>for i in range(n):</line-6>
<line-7> for j in range(n):</line-7>
<line-8> if j!=i:</line-8>
<line-10> print(ans[i],end = ' ')</line-10>
|
{"code": "<line-2>a=[]</line-2>\n<line-9> ans[i] |= a[i][j]</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>from bisect import *</line-1>
<line-2></line-2>
<line-4>fc = []</line-4>
<line-5>fd = []</line-5>
<line-6>mbc = 0</line-6>
<line-7>mbd = 0</line-7>
<line-8>for _ in range(n):</line-8>
<line-9> b, p, ft = input().split()</line-9>
<line-10> b, p = int(b), int(p)</line-10>
<line-11> f = (p, b)</line-11>
<line-12> if ft == 'C':</line-12>
<line-13> if p <= tc:</line-13>
<line-14> fc.append(f)</line-14>
<line-15> mbc = max(mbc, b)</line-15>
<line-16> else:</line-16>
<line-17> if p <= td:</line-17>
<line-18> fd.append(f)</line-18>
<line-19> mbd = max(mbd, b)</line-19>
<line-20></line-20>
<line-21>fc = sorted(fc)</line-21>
<line-22>fd = sorted(fd)</line-22>
<line-23></line-23>
<line-24>def pick2(fc, tc):</line-24>
<line-25> bf = []</line-25>
<line-26> maxb = 0</line-26>
<line-27> ans = 0</line-27>
<line-28> for f in fc:</line-28>
<line-29> p, b = f</line-29>
<line-30> maxpp = tc - p</line-30>
<line-31> ii = bisect_left(bf, (maxpp+1, 0)) - 1</line-31>
<line-32> if ii >= 0:</line-32>
<line-33> pp, bb = bf[ii]</line-33>
<line-34> ans = max(ans, bb + b)</line-34>
<line-35> if b > maxb:</line-35>
<line-36> bf.append(f)</line-36>
<line-37> maxb = b</line-37>
<line-38> return ans</line-38>
<line-39></line-39>
<line-40>ans = mbc + mbd if mbc > 0 and mbd > 0 else 0</line-40>
<line-41>ans = max(ans, pick2(fc, tc))</line-41>
<line-43></line-43>
<line-44>print(ans)</line-44>
|
{"code": "<line-3>n, tc, td = [int(i) for i in input().split()]</line-3>\n<line-42>ans = max(ans, pick2(fd, td))</line-42>", "lines": [3, 42]}
#### 0
|
<line-1></line-1>
<line-2>def main():</line-2>
<line-4> n = []</line-4>
<line-5> a = []</line-5>
<line-6> for i in range(k):</line-6>
<line-7> line = [int(x) for x in input().split()]</line-7>
<line-8> ni = line[0]</line-8>
<line-9> ai = []</line-9>
<line-10> n.append(ni)</line-10>
<line-11> a.append(ai)</line-11>
<line-12> for j in range(ni):</line-12>
<line-13> ai.append(line[1 + j])</line-13>
<line-14> answer, c, p = solve(k, n, a)</line-14>
<line-15> if answer:</line-15>
<line-16> print("Yes")</line-16>
<line-17> for i in range(k):</line-17>
<line-18> print(c[i], p[i] + 1)</line-18>
<line-19> else:</line-19>
<line-20> print("No")</line-20>
<line-21></line-21>
<line-22></line-22>
<line-23>def solve(k, n, a):</line-23>
<line-24> asum, sums = calc_sums(k, n, a)</line-24>
<line-25> if asum % k != 0:</line-25>
<line-26> return False, None, None</line-26>
<line-27> tsum = asum / k</line-27>
<line-28> num_map = build_num_map(k, n, a)</line-28>
<line-29> masks = [None]*(1 << k)</line-29>
<line-30> simple = [False]*(1 << k)</line-30>
<line-31> for i in range(k):</line-31>
<line-32> for j in range(n[i]):</line-32>
<line-33> found, mask, path = find_cycle(i, j, i, j, k, n, a, sums, tsum, num_map, 0, dict())</line-33>
<line-34> if found:</line-34>
<line-35> simple[mask] = True</line-35>
<line-36> masks[mask] = path</line-36>
<line-37> for i in range(1 << k):</line-37>
<line-38> if not simple[i]:</line-38>
<line-39> continue</line-39>
<line-40> mask = i</line-40>
<line-41> zeroes_count = 0</line-41>
<line-42> for u in range(k):</line-42>
<line-43> if (1 << u) > mask:</line-43>
<line-44> break</line-44>
<line-45> if (mask & (1 << u)) == 0:</line-45>
<line-46> zeroes_count += 1</line-46>
<line-47> for mask_mask in range(1 << zeroes_count):</line-47>
<line-48> mask_child = 0</line-48>
<line-49> c = 0</line-49>
<line-50> for u in range(k):</line-50>
<line-51> if (1 << u) > mask:</line-51>
<line-52> break</line-52>
<line-53> if (mask & (1 << u)) == 0:</line-53>
<line-54> if (mask_mask & (1 << c)) != 0:</line-54>
<line-55> mask_child = mask_child | (1 << u)</line-55>
<line-56> c += 1</line-56>
<line-57> if masks[mask_child] and not masks[mask_child | mask]:</line-57>
<line-58> masks[mask_child | mask] = {**masks[mask_child], **masks[mask]}</line-58>
<line-59> if (mask_child | mask) == ((1 << k) - 1):</line-59>
<line-60> c = [-1] * k</line-60>
<line-61> p = [-1] * k</line-61>
<line-62> d = masks[(1 << k) - 1]</line-62>
<line-63> for key, val in list(d.items()):</line-63>
<line-64> c[key] = val[0]</line-64>
<line-65> p[key] = val[1]</line-65>
<line-66> return True, c, p</line-66>
<line-67> if masks[(1 << k) - 1]:</line-67>
<line-68> c = [-1] * k</line-68>
<line-69> p = [-1] * k</line-69>
<line-70> d = masks[(1 << k) - 1]</line-70>
<line-71> for key, val in list(d.items()):</line-71>
<line-72> c[key] = val[0]</line-72>
<line-73> p[key] = val[1]</line-73>
<line-74> return True, c, p</line-74>
<line-75> return False, None, None</line-75>
<line-76></line-76>
<line-77></line-77>
<line-78>def build_num_map(k, n, a):</line-78>
<line-79> result = dict()</line-79>
<line-80> for i in range(k):</line-80>
<line-81> for j in range(n[i]):</line-81>
<line-82> result[a[i][j]] = (i, j)</line-82>
<line-83> return result</line-83>
<line-84></line-84>
<line-85></line-85>
<line-86>def find_cycle(i_origin, j_origin, i, j, k, n, a, sums, tsum, num_map, mask, path):</line-86>
<line-87> if (mask & (1 << i)) != 0:</line-87>
<line-88> if i == i_origin and j == j_origin:</line-88>
<line-89> return True, mask, path</line-89>
<line-90> else:</line-90>
<line-91> return False, None, None</line-91>
<line-92> mask = mask | (1 << i)</line-92>
<line-93> a_needed = tsum - (sums[i] - a[i][j])</line-93>
<line-94> if a_needed not in num_map:</line-94>
<line-95> return False, None, None</line-95>
<line-96> i_next, j_next = num_map[a_needed]</line-96>
<line-97> path[i_next] = (a[i_next][j_next], i)</line-97>
<line-98> return find_cycle(i_origin, j_origin, i_next, j_next, k, n, a, sums, tsum, num_map, mask, path)</line-98>
<line-99></line-99>
<line-100></line-100>
<line-101>def calc_sums(k, n, a):</line-101>
<line-102> sums = [0] * k</line-102>
<line-103> for i in range(k):</line-103>
<line-104> for j in range(n[i]):</line-104>
<line-105> sums[i] = sums[i] + a[i][j]</line-105>
<line-106> asum = 0</line-106>
<line-107> for i in range(k):</line-107>
<line-108> asum = asum + sums[i]</line-108>
<line-109> return asum, sums</line-109>
<line-110></line-110>
<line-111></line-111>
<line-112>def __starting_point():</line-112>
<line-114></line-114>
<line-115>__starting_point()</line-115>
|
{"code": "<line-3> k = int(input())</line-3>\n<line-113> main()</line-113>", "lines": [3, 113]}
#### 0
|
<line-1>s = input()</line-1>
<line-3></line-3>
<line-4>n = len(s)</line-4>
<line-5>m = len(t)</line-5>
<line-6></line-6>
<line-7>t = t + '$' + s</line-7>
<line-8></line-8>
<line-9>p = [0] * (n + m + 1)</line-9>
<line-10>k = 0</line-10>
<line-11>for i in range(1, n + m + 1):</line-11>
<line-12> while k > 0 and t[k] != t[i]:</line-12>
<line-13> k = p[k - 1]</line-13>
<line-14> if t[k] == t[i]:</line-14>
<line-15> k += 1</line-15>
<line-16> p[i] = k</line-16>
<line-17></line-17>
<line-18>ans = [0] * n</line-18>
<line-19>sums = [0] * (n + 1)</line-19>
<line-20>curs = 0</line-20>
<line-21>was = False</line-21>
<line-22>j = 0</line-22>
<line-23>MOD = 10 ** 9 + 7</line-23>
<line-24>for i in range(n):</line-24>
<line-25> if p[i + m + 1] == m:</line-25>
<line-26> if not was:</line-26>
<line-27> was = True</line-27>
<line-28> curs = 1</line-28>
<line-29> while j <= i - m:</line-29>
<line-30> curs = (curs + sums[j] + 1) % MOD</line-30>
<line-31> j += 1</line-31>
<line-32> ans[i] = curs</line-32>
<line-34></line-34>
<line-35>print(sum(ans) % MOD)</line-35>
|
{"code": "<line-2>t = input()</line-2>\n<line-33> sums[i] = (sums[i - 1] + ans[i]) % MOD</line-33>", "lines": [2, 33]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>N, D, M = map(int, readline().split())</line-4>
<line-5>A = list(map(int, readline().split()))</line-5>
<line-6>Am = [a for a in A if a > M]</line-6>
<line-7>Ao = [a for a in A if a <= M]</line-7>
<line-8>Am.sort(reverse = True)</line-8>
<line-9>Ao.sort(reverse = True)</line-9>
<line-10>Cam = Am[:]</line-10>
<line-11>Cao = Ao[:]</line-11>
<line-12></line-12>
<line-13>for i in range(1, len(Cam)):</line-13>
<line-14> Cam[i] += Cam[i-1]</line-14>
<line-15>for i in range(1, len(Cao)):</line-15>
<line-16> Cao[i] += Cao[i-1]</line-16>
<line-17></line-17>
<line-18>k = -(-N//(D+1))</line-18>
<line-19>ans = sum(Am[:k])</line-19>
<line-20>lcam = len(Cam)</line-20>
<line-21>Cam = [0] + Cam</line-21>
<line-22>for i in range(len(Cao)):</line-22>
<line-23> k = min(lcam, -(-(N-(i+1))//(D+1)))</line-23>
<line-25></line-25>
<line-26></line-26>
<line-27>print(ans)</line-27>
|
{"code": "<line-2>readline = sys.stdin.readline</line-2>\n<line-24> ans = max(ans, Cao[i] + Cam[k])</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>n,r1,r2,r3,D = map(int,input().split())</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>a = list(map(int,input().split()))</line-5>
<line-6></line-6>
<line-7># First element</line-7>
<line-8></line-8>
<line-9># Choosing P~P + A</line-9>
<line-10></line-10>
<line-11>state[0] = r1 * a[0] + r3</line-11>
<line-12></line-12>
<line-13># Choosing L + P later or all P</line-13>
<line-14></line-14>
<line-15>state[1] = min(r2 + r1 + D, r1 * (a[0] + 2) + D)</line-15>
<line-16></line-16>
<line-17># Second to Second Last element</line-17>
<line-18></line-18>
<line-19>for i in range(1,n-1):</line-19>
<line-20> newState = [-1,-1]</line-20>
<line-21> newState[0] = min(state[1] + D + r1 * a[i] + r3, state[0] + r1 * a[i] + r3,</line-21>
<line-22> state[1] + r2 + r1 + D, state[1] + r1 * (a[i] + 2) + D)</line-22>
<line-23> newState[1] = min(state[0] + r2 + r1 + D, state[0] + r1 * (a[i] + 2) + D)</line-23>
<line-24> state = newState</line-24>
<line-25></line-25>
<line-26># Last Element</line-26>
<line-27></line-27>
<line-28>ans = min(state[0] + r1 * a[-1] + r3, state[0] + 2 * D + r2 + r1, state[0] + 2 * D + r1 * (a[-1] + 2),</line-28>
<line-30></line-30>
<line-31>print(ans + D * (n-1))</line-31>
|
{"code": "<line-3>state = [0,0] # after odd number of 2 (1st), or not (2nd)</line-3>\n<line-29> state[1] + r1 * a[-1] + r3, state[1] + r2 + r1 + D, state[1] + r1 * (a[-1] + 2) + D)</line-29>", "lines": [3, 29]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4> res = 1</line-4>
<line-5> while n > 0:</line-5>
<line-6> if n % 2 == 1:</line-6>
<line-7> res = (res * a) % p</line-7>
<line-8> a = (a * a) % p</line-8>
<line-9> n >>= 1</line-9>
<line-10> return res</line-10>
<line-11></line-11>
<line-12>def main():</line-12>
<line-13> result = []</line-13>
<line-14> </line-14>
<line-15> t = int(sys.stdin.readline())</line-15>
<line-16> for line in sys.stdin.readlines():</line-16>
<line-17> p, q, b = list(map(int, line.split()))</line-17>
<line-18> for i in range(6):</line-18>
<line-19> b = (b * b) % q</line-19>
<line-20> result.extend(list("Finite\n" if (p * b) % q == 0 else list("Infinite\n")))</line-20>
<line-22></line-22>
<line-23>main()</line-23>
|
{"code": "<line-3>def binpow(a, n, p):</line-3>\n<line-21> sys.stdout.write(\"\".join(result))</line-21>", "lines": [3, 21]}
#### 0
|
<line-1>n, m = map(int, input().split())</line-1>
<line-3> </line-3>
<line-4>y = 2 ** n</line-4>
<line-5>mk = [0] * (2 * y)</line-5>
<line-6>cur = 0</line-6>
<line-7>for x in a:</line-7>
<line-8> if mk[x]: continue</line-8>
<line-9> mk[x] = 1</line-9>
<line-10> st = [x]</line-10>
<line-11> while st:</line-11>
<line-12> u = st.pop()</line-12>
<line-13> if u < y:</line-13>
<line-14> if not mk[y + u]:</line-14>
<line-15> mk[y + u] = 1</line-15>
<line-16> st.append(y + u)</line-16>
<line-17> else:</line-17>
<line-18> for b in range(n):</line-18>
<line-19> v = u | 1 << b</line-19>
<line-20> if u < v and not mk[v]:</line-20>
<line-21> mk[v] = 1</line-21>
<line-22> st.append(v)</line-22>
<line-23> v = y - 1 - (u - y)</line-23>
<line-24> if v in a and not mk[v]:</line-24>
<line-25> mk[v] = 1</line-25>
<line-26> st.append(v)</line-26>
<line-28> </line-28>
<line-29>print(cur)</line-29>
|
{"code": "<line-2>a = set(map(int, input().split()))</line-2>\n<line-27> cur += 1</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>MOD = 987654103</line-4>
<line-5></line-5>
<line-6>n = int(input())</line-6>
<line-7>t = input()</line-7>
<line-8></line-8>
<line-9>place = []</line-9>
<line-10>f1 = []</line-10>
<line-11>e1 = []</line-11>
<line-12></line-12>
<line-13>s = []</line-13>
<line-14>curr = 0</line-14>
<line-15>count1 = 0</line-15>
<line-16>for i in range(n):</line-16>
<line-17> c = t[i]</line-17>
<line-18> if c == '0':</line-18>
<line-19> if count1:</line-19>
<line-20> e1.append(i - 1)</line-20>
<line-21> if count1 & 1:</line-21>
<line-22> s.append(1)</line-22>
<line-23> curr += 1</line-23>
<line-24> e1.append(-1)</line-24>
<line-25> f1.append(-1)</line-25>
<line-26> count1 = 0</line-26>
<line-27> else:</line-27>
<line-28> f1.append(-1)</line-28>
<line-29> e1.append(-1)</line-29>
<line-30></line-30>
<line-31> place.append(curr)</line-31>
<line-32> curr += 1</line-32>
<line-33> s.append(0)</line-33>
<line-34> else:</line-34>
<line-35> if count1 == 0:</line-35>
<line-36> f1.append(i)</line-36>
<line-37> count1 += 1</line-37>
<line-38> place.append(curr)</line-38>
<line-39></line-39>
<line-40>if count1:</line-40>
<line-41> if count1 & 1:</line-41>
<line-42> s.append(1)</line-42>
<line-43> else:</line-43>
<line-44> s.append(0)</line-44>
<line-45> curr += 1</line-45>
<line-46> e1.append(n - 1)</line-46>
<line-47></line-47>
<line-48> e1.append(-1)</line-48>
<line-49> f1.append(-1)</line-49>
<line-50>place.append(curr)</line-50>
<line-51></line-51>
<line-52>pref = [0]</line-52>
<line-53>val = 0</line-53>
<line-54>for i in s:</line-54>
<line-55> val *= 3</line-55>
<line-56> val += i + 1</line-56>
<line-57> val %= MOD</line-57>
<line-58> pref.append(val)</line-58>
<line-59> </line-59>
<line-60></line-60>
<line-61>q = int(input())</line-61>
<line-62>out = []</line-62>
<line-63>for _ in range(q):</line-63>
<line-64> l1, l2, leng = list(map(int, input().split()))</line-64>
<line-65> l1 -= 1</line-65>
<line-66> l2 -= 1</line-66>
<line-67></line-67>
<line-68> starts = (l1, l2)</line-68>
<line-69> hashes = []</line-69>
<line-70> for start in starts:</line-70>
<line-71> end = start + leng - 1</line-71>
<line-72></line-72>
<line-73> smap = place[start]</line-73>
<line-74> emap = place[end]</line-74>
<line-75> if t[end] == '1':</line-75>
<line-76> emap -= 1</line-76>
<line-77> if s[smap] == 1:</line-77>
<line-78> smap += 1</line-78>
<line-79></line-79>
<line-80> prep = False</line-80>
<line-81> app = False</line-81>
<line-82></line-82>
<line-83> if t[start] == '1':</line-83>
<line-84> last = e1[place[start]]</line-84>
<line-85> last = min(last, end)</line-85>
<line-86> count = last - start + 1</line-86>
<line-87> if count % 2:</line-87>
<line-88> prep = True</line-88>
<line-89> if t[end] == '1':</line-89>
<line-90> first = f1[place[end]]</line-90>
<line-91> first = max(first, start)</line-91>
<line-92> count = end - first + 1</line-92>
<line-93> if count % 2:</line-93>
<line-94> app = True</line-94>
<line-95></line-95>
<line-96> preHash = 0</line-96>
<line-97> length = 0</line-97>
<line-98> if smap <= emap:</line-98>
<line-99> length = emap - smap + 1</line-99>
<line-100> preHash = pref[emap + 1]</line-100>
<line-101> preHash -= pref[smap] * pow(3, emap - smap + 1, MOD)</line-101>
<line-102> preHash %= MOD</line-102>
<line-103></line-103>
<line-104></line-104>
<line-105> if length == 0 and prep and app:</line-105>
<line-106> app = False</line-106>
<line-107></line-107>
<line-108> #print(preHash, prep, app, length)</line-108>
<line-109> if prep:</line-109>
<line-110> preHash += pow(3, length, MOD) * 2</line-110>
<line-111> length += 1</line-111>
<line-112> if app:</line-112>
<line-113> preHash *= 3</line-113>
<line-114> preHash += 2</line-114>
<line-115> #print(preHash)</line-115>
<line-116></line-116>
<line-117> preHash %= MOD</line-117>
<line-118> hashes.append(preHash)</line-118>
<line-119> </line-119>
<line-120> if hashes[0] == hashes[1]:</line-120>
<line-121> out.append('Yes')</line-121>
<line-122> else:</line-122>
<line-124></line-124>
<line-125>print('\n'.join(out))</line-125>
<line-126></line-126>
<line-127> </line-127>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-123> out.append('No')</line-123>", "lines": [2, 123]}
#### 0
|
<line-1></line-1>
<line-2>import sys</line-2>
<line-4>input=sys.stdin.readline</line-4>
<line-5></line-5>
<line-6>n,s=list(map(int,input().split()))</line-6>
<line-7></line-7>
<line-8>a=list(map(int,input().split()))</line-8>
<line-9>a.sort()</line-9>
<line-10>med=a[n//2]</line-10>
<line-11></line-11>
<line-12>ans=0</line-12>
<line-13>if med>s:</line-13>
<line-14> for i in range(n//2+1):</line-14>
<line-15> if a[i]>s:</line-15>
<line-16> ans+=a[i]-s</line-16>
<line-17>elif med<s:</line-17>
<line-18> for i in range(n//2,n):</line-18>
<line-19> if s>a[i]:</line-19>
<line-21>print(ans)</line-21>
<line-22></line-22>
|
{"code": "<line-3>#sys.stdin=open(\"data.txt\")</line-3>\n<line-20> ans+=s-a[i]</line-20>", "lines": [3, 20]}
#### 0
|
<line-1># 素因数分解</line-1>
<line-3> i = 2</line-3>
<line-4> table = []</line-4>
<line-5> while i * i <= n:</line-5>
<line-6> while n % i == 0:</line-6>
<line-7> n //= i</line-7>
<line-8> table.append(i)</line-8>
<line-9> i += 1</line-9>
<line-10> if n > 1:</line-10>
<line-11> table.append(n)</line-11>
<line-12> return table</line-12>
<line-13>import sys</line-13>
<line-14>input = sys.stdin.readline</line-14>
<line-15>N = int(input())</line-15>
<line-16>A = list(map(int, input().split()))</line-16>
<line-17># かけらを移動させて共通因数を持つようにする</line-17>
<line-18>su = sum(A)</line-18>
<line-19>if su == 1:</line-19>
<line-20> print(-1)</line-20>
<line-21> return</line-21>
<line-22>primes = list(set(prime_decomposition(su)))</line-22>
<line-23>ans = float("inf")</line-23>
<line-24>Idx1 = [i for i, a in enumerate(A) if a]</line-24>
<line-25></line-25>
<line-26>for p in primes:</line-26>
<line-27> an = 0</line-27>
<line-28> half = p // 2</line-28>
<line-29> for t in zip(*[iter(Idx1)]*p):</line-29>
<line-30> idx = t[half]</line-30>
<line-31> an += sum(abs(i-idx) for i in t)</line-31>
<line-33>print(ans)</line-33>
|
{"code": "<line-2>def prime_decomposition(n):</line-2>\n<line-32> ans = min(ans, an)</line-32>", "lines": [2, 32]}
#### 0
|
<line-1>#!/usr/bin/env python3</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>DEBUG = False</line-5>
<line-6></line-6>
<line-7></line-7>
<line-8>def main():</line-8>
<line-9> if DEBUG:</line-9>
<line-10> test()</line-10>
<line-11></line-11>
<line-12> n = int(input())</line-12>
<line-13></line-13>
<line-14> paths = cycles(n)</line-14>
<line-15></line-15>
<line-16> print(len(paths))</line-16>
<line-17> for p in paths:</line-17>
<line-18> print('%d %s' % (len(p), ' '.join([str(v) for v in p])))</line-18>
<line-19></line-19>
<line-20></line-20>
<line-21>def cycles(n):</line-21>
<line-22> """Builds a set of cycles for a fully connected graph with n vertices."""</line-22>
<line-23> if n % 2 == 0:</line-23>
<line-24> return even(n)</line-24>
<line-25> else:</line-25>
<line-26> return odd(n)</line-26>
<line-27></line-27>
<line-28></line-28>
<line-29>def even(n):</line-29>
<line-30> """Builds a set of cycles that a graph with even vertices."""</line-30>
<line-31> assert n % 2 == 0</line-31>
<line-32></line-32>
<line-33> # Base case for complete graph such that V = {1, 2, 3, 4}.</line-33>
<line-34> cycles = [[1, 2, 3], [2, 3, 4], [3, 4, 1], [4, 1, 2]]</line-34>
<line-35></line-35>
<line-36> for i in range(6, n + 1, 2):</line-36>
<line-37> a, b = i, i - 1</line-37>
<line-38></line-38>
<line-39> # Use edges (a, 1), (a, 0), (b, 1), (b, 0), (a, b) exactly twice each.</line-39>
<line-40> cycles += [[a, 1, b], [a, 2, b], [a, 1, b, 2]]</line-40>
<line-41></line-41>
<line-42> # Similar to odd(...) as we are left with 2n - 2 edges to use</line-42>
<line-43> # connected to i - 4 of the vertices V' = {3 ... i - 2}. Notice that</line-43>
<line-44> # |V'| is even so we can apply the same strategy as in odd(...).</line-44>
<line-45> for k in range(3, i - 1, 2):</line-45>
<line-46> c, d = k, k + 1</line-46>
<line-47> cycles += [[a, c, b, d]] * 2</line-47>
<line-48></line-48>
<line-49> return cycles</line-49>
<line-50></line-50>
<line-51></line-51>
<line-52>def odd(n):</line-52>
<line-53> """Builds a set of cycles that a graph with odd vertices."""</line-53>
<line-54> assert n % 2 == 1</line-54>
<line-55></line-55>
<line-56> # Base case for complete graph such that V = {1, 2, 3}.</line-56>
<line-57> cycles = [[1, 2, 3]] * 2</line-57>
<line-58></line-58>
<line-59> for i in range(5, n + 1, 2):</line-59>
<line-60> a, b = i, i - 1</line-60>
<line-61> # Say the new vertices are {a, b}. Since the graph is fully connected</line-61>
<line-62> # adding these 2 vertices results in 2n + 1 more edges. We use a length</line-62>
<line-63> # 3 cycle a -> b -> 1 > a twice to use up 3 of these edges.</line-63>
<line-64> cycles += [[a, b, 1]] * 2</line-64>
<line-65></line-65>
<line-66> # At this point we are left with 2n + 1 - 3 = 2n - 2 edges to use</line-66>
<line-67> # connected to i - 3 of the vertices V' = {2 ... i - 2}. Notice that</line-67>
<line-68> # |V'| is even. To use these edges and cover vertices V' we take pairs</line-68>
<line-69> # c, d in V' and create two of each path a -> c -> b -> d -> a.</line-69>
<line-70> for k in range(2, i - 1, 2):</line-70>
<line-71> c, d = k, k + 1</line-71>
<line-72> cycles += [[a, c, b, d]] * 2</line-72>
<line-73></line-73>
<line-74> return cycles</line-74>
<line-75></line-75>
<line-76></line-76>
<line-77>def test():</line-77>
<line-78> """Checks the cycles(...) solver for a bunch of inputs."""</line-78>
<line-79> print('Testing...')</line-79>
<line-80></line-80>
<line-81> for n in range(3, 300, 21):</line-81>
<line-82> check(n, cycles(n))</line-82>
<line-83></line-83>
<line-84> print('Tests pass!')</line-84>
<line-85></line-85>
<line-86></line-86>
<line-87>def check(n, paths):</line-87>
<line-88> """Checks the solution for errors."""</line-88>
<line-89> # Check that all vertices are covered.</line-89>
<line-90> vertices = set(sum(paths, list()))</line-90>
<line-91> assert vertices == set(range(1, n + 1))</line-91>
<line-92></line-92>
<line-93> # Check that each edge is used exactly twice.</line-93>
<line-94> counts = defaultdict(int)</line-94>
<line-95></line-95>
<line-96> for p in paths:</line-96>
<line-97> assert len(p) == 3 or len(p) == 4</line-97>
<line-98> assert len(set(p)) == len(p)</line-98>
<line-99></line-99>
<line-100> for i in range(len(p)):</line-100>
<line-101> key = tuple(sorted([p[i - 1], p[i]]))</line-101>
<line-102> counts[key] += 1</line-102>
<line-103></line-103>
<line-104> for i in range(1, n + 1):</line-104>
<line-105> for j in range(i + 1, n + 1):</line-105>
<line-106> assert counts[(i, j)] == 2</line-106>
<line-107></line-107>
<line-108>def __starting_point():</line-108>
<line-110></line-110>
<line-111>__starting_point()</line-111>
|
{"code": "<line-3>from collections import defaultdict</line-3>\n<line-109> main()</line-109>", "lines": [3, 109]}
#### 0
|
<line-1>k, q = list(map(int, input().split()))</line-1>
<line-3>t[1] = 1</line-3>
<line-4>d = [0]</line-4>
<line-5>n = i = 1</line-5>
<line-6>while i < 1001:</line-6>
<line-7> if 2000 * t[k] > i - 1e-7:</line-7>
<line-8> d.append(n)</line-8>
<line-9> i += 1</line-9>
<line-10> else:</line-10>
<line-11> t = [0] + [(j * t[j] + (k - j + 1) * t[j - 1]) / k for j in range(1, k + 1)]</line-11>
<line-13>for i in range(q): print(d[int(input())])</line-13>
|
{"code": "<line-2>t = [0] * (k + 1)</line-2>\n<line-12> n += 1</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>def main():</line-1>
<line-3> aa = []</line-3>
<line-4> for _ in range(n):</line-4>
<line-5> row = list(map(int, input().split()))</line-5>
<line-6> row.append(0)</line-6>
<line-7> aa.append(row)</line-7>
<line-8> aa.append([0] * (m + 1))</line-8>
<line-9> d1, d2, d3, d4 = ([[0] * (m + 1) for _ in range(n + 1)] for _ in (1, 2, 3, 4))</line-9>
<line-10> for i in range(n):</line-10>
<line-11> for j in range(m):</line-11>
<line-12> d1[i][j] = max(d1[i - 1][j], d1[i][j - 1]) + aa[i][j]</line-12>
<line-13> for i in range(n):</line-13>
<line-14> for j in range(m - 1, -1, -1):</line-14>
<line-15> d2[i][j] = max(d2[i - 1][j], d2[i][j + 1]) + aa[i][j]</line-15>
<line-16> for i in range(n - 1, -1, -1):</line-16>
<line-17> for j in range(m):</line-17>
<line-18> d3[i][j] = max(d3[i + 1][j], d3[i][j - 1]) + aa[i][j]</line-18>
<line-19> for i in range(n - 1, -1, -1):</line-19>
<line-20> for j in range(m - 1, -1, -1):</line-20>
<line-21> d4[i][j] = max(d4[i + 1][j], d4[i][j + 1]) + aa[i][j]</line-21>
<line-22> print((max(</line-22>
<line-23> max(d1[i][j - 1] + d2[i - 1][j] + d3[i + 1][j] + d4[i][j + 1] for i in range(1, n - 1) for j in range(1, m - 1)),</line-23>
<line-24> max(d1[i - 1][j] + d2[i][j + 1] + d3[i][j - 1] + d4[i + 1][j] for i in range(1, n - 1) for j in range(1, m - 1)))))</line-24>
<line-25></line-25>
<line-26></line-26>
<line-27>def __starting_point():</line-27>
<line-29></line-29>
<line-30>__starting_point()</line-30>
|
{"code": "<line-2> n, m = list(map(int, input().split()))</line-2>\n<line-28> main()</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>for i in range(n):</line-3>
<line-4> x1, y1, x2, y2 = map(int, input().split())</line-4>
<line-5> res = (x1 & 1) * 2 + (y1 & 1) + 1</line-5>
<line-7>print(ans)</line-7>
|
{"code": "<line-2>ans = 'YES\\n'</line-2>\n<line-6> ans += str(res) + '\\n'</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>def main():</line-1>
<line-3> input()</line-3>
<line-4> s = set(map(int, input().split()))</line-4>
<line-5> xx = [-x for x in s]</line-5>
<line-6> heapify(xx)</line-6>
<line-7> while True:</line-7>
<line-8> x = -xx[0]</line-8>
<line-9> while x != 1:</line-9>
<line-10> x //= 2</line-10>
<line-11> if x not in s:</line-11>
<line-12> s.add(x)</line-12>
<line-13> heapreplace(xx, -x)</line-13>
<line-14> break</line-14>
<line-15> else:</line-15>
<line-16> break</line-16>
<line-17> print(' '.join(str(-x) for x in xx))</line-17>
<line-18></line-18>
<line-19>def __starting_point():</line-19>
<line-21></line-21>
<line-22>__starting_point()</line-22>
|
{"code": "<line-2> from heapq import heapify, heapreplace</line-2>\n<line-20> main()</line-20>", "lines": [2, 20]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.