question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1>n = int(input())</line-1>
<line-3></line-3>
<line-4>m = int(input())</line-4>
<line-5>b = list(map(int, input().split()))</line-5>
<line-6></line-6>
<line-7>ptra = 1</line-7>
<line-8>ptrb = 1</line-8>
<line-9>sa = a[0] </line-9>
<line-10>sb = b[0]</line-10>
<line-11>ans = 0</line-11>
<line-12></line-12>
<line-13>while ptra != n and ptrb != m:</line-13>
<line-14> if sa == sb:</line-14>
<line-15> ans += 1</line-15>
<line-16> sa = a[ptra]</line-16>
<line-17> sb = b[ptrb]</line-17>
<line-18> ptra += 1</line-18>
<line-19> ptrb += 1</line-19>
<line-20> continue</line-20>
<line-21> if sa < sb:</line-21>
<line-22> sa += a[ptra]</line-22>
<line-23> ptra += 1</line-23>
<line-24> else:</line-24>
<line-25> sb += b[ptrb]</line-25>
<line-26> ptrb += 1</line-26>
<line-27>while ptra != n:</line-27>
<line-28> sa += a[ptra]</line-28>
<line-29> ptra += 1</line-29>
<line-30>while ptrb != m:</line-30>
<line-31> sb += b[ptrb]</line-31>
<line-32> ptrb += 1</line-32>
<line-33>if sa != sb:</line-33>
<line-34> print(-1)</line-34>
<line-36>print(ans + 1)</line-36>
<line-37></line-37>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-35> return</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>s = input()</line-1>
<line-3> print('YES')</line-3>
<line-5> print('NO')</line-5>
|
{"code": "<line-2>if (s.count('Danil') + s.count('Olya') + s.count('Slava') + s.count('Ann') + s.count('Nikita') == 1):</line-2>\n<line-4>else:</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>def f(n):</line-1>
<line-3> t = [1] * (n + 1)</line-3>
<line-4> for i in range(3, m):</line-4>
<line-5> if t[i]: t[i * i :: 2 * i] = [0] * ((n - i * i) // (2 * i) + 1)</line-5>
<line-6> return [2] + [i for i in range(3, n + 1, 2) if t[i]]</line-6>
<line-7></line-7>
<line-8>a, b, k = map(int, input().split())</line-8>
<line-9>n = 2000001</line-9>
<line-10></line-10>
<line-11>t, p, x = [-1] * n, f(n), -1</line-11>
<line-12>k -= 1; b += 1</line-12>
<line-13></line-13>
<line-14>for i in range(len(p) - k):</line-14>
<line-15> t[p[i]] = p[i + k] - p[i]</line-15>
<line-16></line-16>
<line-17>t.reverse()</line-17>
<line-18>for i in range(1, n):</line-18>
<line-19> if t[i] < 0: t[i] = t[i - 1] + 1</line-19>
<line-20>t.reverse()</line-20>
<line-21></line-21>
<line-22>for i in range(a + 1, b):</line-22>
<line-23> t[i] = max(t[i], t[i - 1])</line-23>
<line-24></line-24>
<line-25>for l in range(1, b - a + 1):</line-25>
<line-26> if t[b - l] < l:</line-26>
<line-27> x = l</line-27>
<line-29>print(x)</line-29>
|
{"code": "<line-2> m = int(n ** 0.5) + 1</line-2>\n<line-28> break</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>a,h,w=(int(x) for x in input().split())</line-1>
<line-3> if a<h:</line-3>
<line-4> n=w//a</line-4>
<line-5> x=(w-a*n)/(n+1)</line-5>
<line-6> print(x)</line-6>
<line-7> elif a==h:</line-7>
<line-8> print(0)</line-8>
<line-9> else:</line-9>
<line-10> print(-1)</line-10>
<line-11>else:</line-11>
<line-12> for i in range(100):</line-12>
<line-13> if h>w:</line-13>
<line-14> w,h=h,w</line-14>
<line-15> if w>h+a*2:</line-15>
<line-16> w=w-h-a</line-16>
<line-17> if h>w:</line-17>
<line-18> w,h=h,w </line-18>
<line-19> m=h//a</line-19>
<line-20> s=(w-h)//a</line-20>
<line-21> r=0</line-21>
<line-22> if m<s or s==0:</line-22>
<line-23> for i in range(m,0,-1):</line-23>
<line-24> x=(h-a*i)/(i+1)</line-24>
<line-25> w1=w-x</line-25>
<line-26> a1=a+x</line-26>
<line-27> q=w1%a1</line-27>
<line-28> if q<0.00000001 or a1-q<0.0000001:</line-28>
<line-29> r=1</line-29>
<line-30> break</line-30>
<line-31> if r==0:</line-31>
<line-32> print(-1)</line-32>
<line-33> else:</line-33>
<line-34> print(x)</line-34>
<line-35> else:</line-35>
<line-36> for i in range(s,0,-1):</line-36>
<line-37> x=(w-h-i*a)/i</line-37>
<line-38> w1=w-x</line-38>
<line-39> a1=a+x</line-39>
<line-40> q=w1%a1</line-40>
<line-41> if q<0.00000001:</line-41>
<line-42> r=1</line-42>
<line-43> break</line-43>
<line-44> if r==0:</line-44>
<line-45> print(-1)</line-45>
<line-47> print(x)</line-47>
|
{"code": "<line-2>if h==w:</line-2>\n<line-46> else:</line-46>", "lines": [2, 46]}
#### 0
|
<line-1>ii = lambda: int(input())</line-1>
<line-3>li = lambda: list(mi())</line-3>
<line-4></line-4>
<line-5>n = ii()</line-5>
<line-6>a = [li() for _ in range(n)]</line-6>
<line-7>k = ii()</line-7>
<line-8>ans = 0</line-8>
<line-9>for l, r in a:</line-9>
<line-11>print(ans)</line-11>
|
{"code": "<line-2>mi = lambda: map(int, input().split())</line-2>\n<line-10> ans += k <= r</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>fout = sys.stdout</line-4>
<line-5></line-5>
<line-6>#fin = open("input.txt", 'r')</line-6>
<line-7>#fout = open("output.txt", 'w')</line-7>
<line-8></line-8>
<line-9>s = fin.readline().strip()</line-9>
<line-10>n = len(s)</line-10>
<line-11>for L in range(n):</line-11>
<line-12> for R in range(L + 1, n + 1):</line-12>
<line-13> s1 = s[:L]</line-13>
<line-14> s2 = s[L:R]</line-14>
<line-15> s3 = s[R:]</line-15>
<line-16> if (s1 + s3 == "CODEFORCES"):</line-16>
<line-17> print("YES")</line-17>
<line-19>print("NO")</line-19>
|
{"code": "<line-3>fin = sys.stdin</line-3>\n<line-18> return</line-18>", "lines": [3, 18]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>for i in range(1, n - 1):</line-3>
<line-5>print(ans)</line-5>
|
{"code": "<line-2>ans = 0</line-2>\n<line-4> ans += (i + 1) * (i + 2)</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>hola = 0</line-1>
<line-3>d = len(str(a))</line-3>
<line-4>k = 10**(d-1)</line-4>
<line-5>for i in range(1, d):</line-5>
<line-6> hola += i * (10**(i-1)*9)</line-6>
<line-7></line-7>
<line-9>print(hola)</line-9>
|
{"code": "<line-2>a = int(input())</line-2>\n<line-8>hola += d * (a-k+1)</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>from sys import stdin, stdout</line-1>
<line-2></line-2>
<line-4>values = list(map(int, stdin.readline().split()))</line-4>
<line-5></line-5>
<line-6>sze = max(values)</line-6>
<line-7>used = [0 for i in range(sze + 1)]</line-7>
<line-8>challengers = [[] for i in range(n + 1)]</line-8>
<line-9></line-9>
<line-10>i = 0</line-10>
<line-11>cnt = 0</line-11>
<line-12> </line-12>
<line-13>for i in range(n):</line-13>
<line-14> if values[i] == k:</line-14>
<line-15> cnt += 1</line-15>
<line-16> elif used[values[i]] >= cnt:</line-16>
<line-17> used[values[i]] += 1</line-17>
<line-18> challengers[used[values[i]]].append(values[i])</line-18>
<line-19> </line-19>
<line-20>for i in range(n, cnt - 1, -1):</line-20>
<line-21> if len(challengers[i]):</line-21>
<line-22> stdout.write(str(challengers[i][0]))</line-22>
<line-23> break</line-23>
<line-25> stdout.write('-1')</line-25>
|
{"code": "<line-3>n, k = map(int, stdin.readline().split())</line-3>\n<line-24>else:</line-24>", "lines": [3, 24]}
#### 0
|
<line-2>n,x=R()</line-2>
<line-3>print('YES'if sum(R())+n-1==x else'NO')</line-3>
|
{"code": "<line-1>R=lambda:list(map(int,input().split()))</line-1>", "lines": [1]}
#### 0
|
<line-1>n, m =list(map(int, input().split()))</line-1>
<line-3> print( m // n + 1)</line-3>
<line-5> print(m // n)</line-5>
|
{"code": "<line-2>if m % n != 0:</line-2>\n<line-4>else:</line-4>", "lines": [2, 4]}
#### 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>possible=[0]*26</line-6>
<line-7></line-7>
<line-8>for i in input().strip():</line-8>
<line-9> possible[ord(i)-97]+=1</line-9>
<line-10></line-10>
<line-11># make changes</line-11>
<line-12>temp=[]</line-12>
<line-13>for i in range(26):</line-13>
<line-14> if possible[i]%2: temp.append(i)</line-14>
<line-15>while len(temp)>1:</line-15>
<line-16> possible[temp[0]]+=1</line-16>
<line-17> possible[temp[-1]]-=1</line-17>
<line-18> temp.pop(0)</line-18>
<line-19> temp.pop(-1)</line-19>
<line-20></line-20>
<line-21># print stuff</line-21>
<line-22>for i in range(26):</line-22>
<line-23> print(chr(97+i)*(possible[i]//2),end="")</line-23>
<line-24>if temp: print(chr(97+temp[0]),end="")</line-24>
<line-26> print(chr(97+i)*(possible[i]//2),end="")</line-26>
|
{"code": "<line-3>#sys.stdin=open(\"data.txt\")</line-3>\n<line-25>for i in range(26)[::-1]:</line-25>", "lines": [3, 25]}
#### 0
|
<line-1>a = 0</line-1>
<line-3>x = {'Q': 9, 'q':9, 'R':5, 'r':5, 'B':3, 'b':3, 'N':3, 'n':3, 'P': 1, 'p': 1}</line-3>
<line-4>for i in range(8):</line-4>
<line-5> t = [i for i in input()]</line-5>
<line-6> for i in t:</line-6>
<line-7> if ord(i) >= 97 and i in x:</line-7>
<line-8> a += x[i]</line-8>
<line-9> elif i in x:</line-9>
<line-10> b += x[i]</line-10>
<line-11>if a == b:</line-11>
<line-12> print("Draw")</line-12>
<line-13>elif a < b:</line-13>
<line-14> print("White")</line-14>
<line-16> print("Black")</line-16>
|
{"code": "<line-2>b = 0</line-2>\n<line-15>else:</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>from bisect import bisect_left</line-1>
<line-2></line-2>
<line-3></line-3>
<line-5>S = input()</line-5>
<line-6>good = []</line-6>
<line-7>bad = []</line-7>
<line-8>for i in range(N + 1):</line-8>
<line-9> if S[i] == "1":</line-9>
<line-10> bad.append(i)</line-10>
<line-11> else:</line-11>
<line-12> good.append(i)</line-12>
<line-13></line-13>
<line-14>ans = []</line-14>
<line-15>cur = N</line-15>
<line-16>while True:</line-16>
<line-17> if cur == 0:</line-17>
<line-18> print((" ".join(map(str, ans[::-1]))))</line-18>
<line-19> break</line-19>
<line-20> idx = bisect_left(good, cur - M)</line-20>
<line-21> nx = good[idx]</line-21>
<line-22> ans.append(cur - nx)</line-22>
<line-23> if cur == nx:</line-23>
<line-24> print((-1))</line-24>
<line-26> cur = nx</line-26>
|
{"code": "<line-4>N, M = list(map(int, input().split()))</line-4>\n<line-25> break</line-25>", "lines": [4, 25]}
#### 0
|
<line-1>k = int(input())</line-1>
<line-3>ans = []</line-3>
<line-4>if k % 2 == 0:</line-4>
<line-5> if (x + y) % 2 == 1:</line-5>
<line-6> print((-1))</line-6>
<line-7> return</line-7>
<line-8>x_reverse = False</line-8>
<line-9>y_reverse = False</line-9>
<line-10>if x < 0:</line-10>
<line-11> x *= -1</line-11>
<line-12> x_reverse = True</line-12>
<line-13>if y < 0:</line-13>
<line-14> y *= -1</line-14>
<line-15> y_reverse = True</line-15>
<line-16></line-16>
<line-17></line-17>
<line-18>def app(a, b):</line-18>
<line-19> nonlocal ans</line-19>
<line-20> if x_reverse:</line-20>
<line-21> a *= -1</line-21>
<line-22> if y_reverse:</line-22>
<line-23> b *= -1</line-23>
<line-24></line-24>
<line-25> ans.append((a, b))</line-25>
<line-26></line-26>
<line-27></line-27>
<line-28>nowx = 0</line-28>
<line-29>nowy = 0</line-29>
<line-30></line-30>
<line-31>while abs(x - nowx) + abs(y - nowy) >= 2 * k:</line-31>
<line-32> if abs(x - nowx) > k:</line-32>
<line-33> nowx += k</line-33>
<line-34> else:</line-34>
<line-35> nowy += k</line-35>
<line-36> app(nowx, nowy)</line-36>
<line-37></line-37>
<line-38></line-38>
<line-39>def ok():</line-39>
<line-40> app(x, y)</line-40>
<line-41> print((len(ans)))</line-41>
<line-42> for a, b in ans:</line-42>
<line-43> print((a, b))</line-43>
<line-44> return</line-44>
<line-45></line-45>
<line-46></line-46>
<line-47>rest = abs(x - nowx) + abs(y - nowy)</line-47>
<line-48>if rest == k:</line-48>
<line-49> ok()</line-49>
<line-50></line-50>
<line-51>if rest % 2 == 0:</line-51>
<line-52> delta = 2 * k - rest</line-52>
<line-53> assert delta % 2 == 0</line-53>
<line-54> if abs(x - nowx) < abs(y - nowy):</line-54>
<line-55> temp = abs(x - nowx) + delta // 2</line-55>
<line-56> nowx += temp</line-56>
<line-57> nowy += k - temp</line-57>
<line-58> else:</line-58>
<line-59> temp = abs(y - nowy) + delta // 2</line-59>
<line-60> nowy += temp</line-60>
<line-61> nowx += k - temp</line-61>
<line-62> app(nowx, nowy)</line-62>
<line-63> ok()</line-63>
<line-64></line-64>
<line-65># 残りが奇数のときは、条件から一旦ゴールをすぎる方向に移動すれば、</line-65>
<line-66># 残りの距離の偶奇が変わる。</line-66>
<line-67></line-67>
<line-68>if abs(x - nowx) < abs(y - nowy):</line-68>
<line-69> nowx += k</line-69>
<line-70> app(nowx, nowy)</line-70>
<line-71>else:</line-71>
<line-72> nowy += k</line-72>
<line-73> app(nowx, nowy)</line-73>
<line-74></line-74>
<line-75>x_delta = x - nowx</line-75>
<line-76>x_pm = x_delta // abs(x_delta)</line-76>
<line-77>y_delta = y - nowy</line-77>
<line-78>y_pm = y_delta // abs(y_delta)</line-78>
<line-79>if abs(x_delta) < abs(y_delta):</line-79>
<line-80> delta = 2 * k - (abs(x_delta) + abs(y_delta))</line-80>
<line-81> temp = abs(x - nowx) + delta // 2</line-81>
<line-82> nowx += x_pm * temp</line-82>
<line-83> nowy += y_pm * (k - temp)</line-83>
<line-84> app(nowx, nowy)</line-84>
<line-85> ok()</line-85>
<line-86>else:</line-86>
<line-87> delta = 2 * k - (abs(x_delta) + abs(y_delta))</line-87>
<line-88> temp = abs(y - nowy) + delta // 2</line-88>
<line-89> nowy += y_pm * temp</line-89>
<line-90> nowx += x_pm * (k - temp)</line-90>
<line-92> ok()</line-92>
<line-93></line-93>
|
{"code": "<line-2>x, y = list(map(int, input().split()))</line-2>\n<line-91> app(nowx, nowy)</line-91>", "lines": [2, 91]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>D = [x ** 3.0 for x in range(2, 170417)]</line-3>
<line-4>DD = [x*x*x for x in range(2, 170417)]</line-4>
<line-5>while l < r:</line-5>
<line-6> m = (l+r) // 2</line-6>
<line-7> if sum(int(m/d) for d in D) < n:</line-7>
<line-8> l = m + 1</line-8>
<line-9> else:</line-9>
<line-10> r = m;</line-10>
<line-11>if sum(l//d for d in DD) == n:</line-11>
<line-12> print(l);</line-12>
<line-14> print((-1));</line-14>
|
{"code": "<line-2>l, r = 0, 10**16</line-2>\n<line-13>else :</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>#!/usr/bin/env python3</line-1>
<line-3></line-3>
<line-4>import unittest</line-4>
<line-5>import sys</line-5>
<line-6>import math</line-6>
<line-7>import decimal</line-7>
<line-8></line-8>
<line-9>###############################################################################</line-9>
<line-10># Circles Class (Main Program)</line-10>
<line-11>###############################################################################</line-11>
<line-12></line-12>
<line-13></line-13>
<line-14>def sin(x):</line-14>
<line-15> decimal.getcontext().prec += 2</line-15>
<line-16> i, lasts, s, fact, num, sign = 1, 0, x, 1, x, 1</line-16>
<line-17> while s != lasts:</line-17>
<line-18> lasts = s</line-18>
<line-19> i += 2</line-19>
<line-20> fact *= i * (i-1)</line-20>
<line-21> num *= x * x</line-21>
<line-22> sign *= -1</line-22>
<line-23> s += num / fact * sign</line-23>
<line-24> decimal.getcontext().prec -= 2</line-24>
<line-25> return +s</line-25>
<line-26></line-26>
<line-27></line-27>
<line-28>def cos(x):</line-28>
<line-29> decimal.getcontext().prec += 2</line-29>
<line-30> i, lasts, s, fact, num, sign = 0, 0, 1, 1, 1, 1</line-30>
<line-31> while s != lasts:</line-31>
<line-32> lasts = s</line-32>
<line-33> i += 2</line-33>
<line-34> fact *= i * (i-1)</line-34>
<line-35> num *= x * x</line-35>
<line-36> sign *= -1</line-36>
<line-37> s += num / fact * sign</line-37>
<line-38> decimal.getcontext().prec -= 2</line-38>
<line-39> return +s</line-39>
<line-40></line-40>
<line-41></line-41>
<line-42>def pi():</line-42>
<line-43> decimal.getcontext().prec += 2</line-43>
<line-44> three = decimal.Decimal(3)</line-44>
<line-45> lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24</line-45>
<line-46> while s != lasts:</line-46>
<line-47> lasts = s</line-47>
<line-48> n, na = n+na, na+8</line-48>
<line-49> d, da = d+da, da+32</line-49>
<line-50> t = (t * n) / d</line-50>
<line-51> s += t</line-51>
<line-52> decimal.getcontext().prec -= 2</line-52>
<line-53> return +s</line-53>
<line-54></line-54>
<line-55></line-55>
<line-56>def asin(x):</line-56>
<line-57> decimal.getcontext().prec += 2</line-57>
<line-58> b, e = -pi()/2, pi()/2</line-58>
<line-59> while True:</line-59>
<line-60> mid = (b + e) / 2</line-60>
<line-61> if e == mid or b == mid:</line-61>
<line-62> break</line-62>
<line-63> if sin(mid) <= x:</line-63>
<line-64> b = mid</line-64>
<line-65> else:</line-65>
<line-66> e = mid</line-66>
<line-67> decimal.getcontext().prec -= 2</line-67>
<line-68> return +b</line-68>
<line-69></line-69>
<line-70></line-70>
<line-71>def acos(x):</line-71>
<line-72> return pi() / 2 - asin(x)</line-72>
<line-73></line-73>
<line-74></line-74>
<line-75>class Circles:</line-75>
<line-76> """ Circles representation """</line-76>
<line-77></line-77>
<line-78> def __init__(self, test_inputs=None):</line-78>
<line-79> """ Default constructor """</line-79>
<line-80></line-80>
<line-81> it = iter(test_inputs.split("\n")) if test_inputs else None</line-81>
<line-82></line-82>
<line-83> def uinput():</line-83>
<line-84> return next(it) if it else sys.stdin.readline().rstrip()</line-84>
<line-85></line-85>
<line-86> # Reading single elements</line-86>
<line-87> [self.xa, self.ya, self.ra] = list(map(decimal.Decimal, uinput().split()))</line-87>
<line-88> [self.xb, self.yb, self.rb] = list(map(decimal.Decimal, uinput().split()))</line-88>
<line-89></line-89>
<line-90> decimal.getcontext().prec = 40</line-90>
<line-91></line-91>
<line-92> self.l = ((self.xb - self.xa)**2 + (self.yb - self.ya)**2).sqrt()</line-92>
<line-93> self.p = (self.ra + self.rb + self.l)/2</line-93>
<line-94></line-94>
<line-95> if self.l >= self.p:</line-95>
<line-96> self.sa = 0</line-96>
<line-97> self.sb = 0</line-97>
<line-98> elif self.ra >= self.p:</line-98>
<line-99> self.sa = 0</line-99>
<line-100> self.sb = self.rb**2 * decimal.Decimal.from_float(math.pi)</line-100>
<line-101> elif self.rb >= self.p:</line-101>
<line-102> self.sa = self.ra**2 * decimal.Decimal.from_float(math.pi)</line-102>
<line-103> self.sb = 0</line-103>
<line-104> else:</line-104>
<line-105> self.aa = 2 * acos(</line-105>
<line-106> (self.ra**2 - self.rb**2 + self.l**2) /</line-106>
<line-107> (2 * self.ra * self.l))</line-107>
<line-108> self.ab = 2 * acos(</line-108>
<line-109> (self.rb**2 - self.ra**2 + self.l**2) /</line-109>
<line-110> (2 * self.rb * self.l))</line-110>
<line-111> self.sa = self.ra**2 * (self.aa - sin(self.aa)) / 2</line-111>
<line-112> self.sb = self.rb**2 * (self.ab - sin(self.ab)) / 2</line-112>
<line-113></line-113>
<line-114> def calculate(self):</line-114>
<line-115> """ Main calcualtion function of the class """</line-115>
<line-116></line-116>
<line-117> result = self.sa + self.sb</line-117>
<line-118></line-118>
<line-119> return str(result)</line-119>
<line-120></line-120>
<line-121>###############################################################################</line-121>
<line-122># Unit Tests</line-122>
<line-123>###############################################################################</line-123>
<line-124></line-124>
<line-125></line-125>
<line-126>class unitTests(unittest.TestCase):</line-126>
<line-127></line-127>
<line-128> def test_single_test(self):</line-128>
<line-129> """ Circles class testing """</line-129>
<line-130></line-130>
<line-131> # Constructor test</line-131>
<line-132> test = "0 0 4\n6 0 4"</line-132>
<line-133> d = Circles(test)</line-133>
<line-134> self.assertEqual(d.l, 6)</line-134>
<line-135></line-135>
<line-136> # Sample test</line-136>
<line-137> self.assertEqual(Circles(test).calculate()[:8], "7.252988")</line-137>
<line-138></line-138>
<line-139> # Sample test</line-139>
<line-140> test = "0 0 5\n11 0 5"</line-140>
<line-141> self.assertEqual(Circles(test).calculate(), "0")</line-141>
<line-142></line-142>
<line-143> # Sample test</line-143>
<line-144> test = "44721 999999999 400000000\n0 0 600000000"</line-144>
<line-145> self.assertEqual(Circles(test).calculate()[:9], "0.0018834")</line-145>
<line-146></line-146>
<line-147> # My tests</line-147>
<line-148> test = ""</line-148>
<line-149> # self.assertEqual(Circles(test).calculate(), "0")</line-149>
<line-150></line-150>
<line-151> # Time limit test</line-151>
<line-152> # self.time_limit_test(5000)</line-152>
<line-153></line-153>
<line-154> def time_limit_test(self, nmax):</line-154>
<line-155> """ Timelimit testing """</line-155>
<line-156> import random</line-156>
<line-157> import timeit</line-157>
<line-158></line-158>
<line-159> # Random inputs</line-159>
<line-160> test = str(nmax) + " " + str(nmax) + "\n"</line-160>
<line-161> numnums = [str(i) + " " + str(i+1) for i in range(nmax)]</line-161>
<line-162> test += "\n".join(numnums) + "\n"</line-162>
<line-163> nums = [random.randint(1, 10000) for i in range(nmax)]</line-163>
<line-164> test += " ".join(map(str, nums)) + "\n"</line-164>
<line-165></line-165>
<line-166> # Run the test</line-166>
<line-167> start = timeit.default_timer()</line-167>
<line-168> d = Circles(test)</line-168>
<line-169> calc = timeit.default_timer()</line-169>
<line-170> d.calculate()</line-170>
<line-171> stop = timeit.default_timer()</line-171>
<line-172> print(("\nTimelimit Test: " +</line-172>
<line-173> "{0:.3f}s (init {1:.3f}s calc {2:.3f}s)".</line-173>
<line-174> format(stop-start, calc-start, stop-calc)))</line-174>
<line-175></line-175>
<line-176>def __starting_point():</line-176>
<line-177></line-177>
<line-178> # Avoiding recursion limitaions</line-178>
<line-179> sys.setrecursionlimit(100000)</line-179>
<line-180></line-180>
<line-181> if sys.argv[-1] == "-ut":</line-181>
<line-182> unittest.main(argv=[" "])</line-182>
<line-183></line-183>
<line-184> # Print the result string</line-184>
<line-186></line-186>
<line-187>__starting_point()</line-187>
|
{"code": "<line-2># 600D_circles.py - Codeforces.com/problemset/problem/600/D by Sergey 2015</line-2>\n<line-185> sys.stdout.write(Circles().calculate())</line-185>", "lines": [2, 185]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3> print(2)</line-3>
<line-5> print(1)</line-5>
|
{"code": "<line-2>if n==2:</line-2>\n<line-4>else:</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>from collections import deque</line-1>
<line-2></line-2>
<line-4>p = list(map(int,input().split()))</line-4>
<line-5>a = list(map(int,input().split()))</line-5>
<line-6>edge = [[] for i in range(n)]</line-6>
<line-7>for i in range(n-1):</line-7>
<line-8> edge[p[i]-1].append(i+1)</line-8>
<line-9></line-9>
<line-10></line-10>
<line-11>dp = [0 for i in range(n)]</line-11>
<line-12>size = [not edge[v] for v in range(n)]</line-12>
<line-13></line-13>
<line-14>res = []</line-14>
<line-15>deq = deque([0])</line-15>
<line-16>while deq:</line-16>
<line-17> v = deq.popleft()</line-17>
<line-18> res.append(v)</line-18>
<line-19> for nv in edge[v]:</line-19>
<line-20> deq.append(nv)</line-20>
<line-21></line-21>
<line-22>res = res[::-1]</line-22>
<line-23></line-23>
<line-24>for v in res:</line-24>
<line-25> tmp = -1</line-25>
<line-26> S = 0</line-26>
<line-27> for nv in edge[v]:</line-27>
<line-28> tmp = max(tmp,dp[nv])</line-28>
<line-29> size[v] += size[nv]</line-29>
<line-30> S += a[nv]</line-30>
<line-31></line-31>
<line-32> if not edge[v]:</line-32>
<line-33> dp[v] = a[v]</line-33>
<line-34> continue</line-34>
<line-35></line-35>
<line-36> rest = tmp*size[v] - S</line-36>
<line-37> if a[v]<=rest:</line-37>
<line-38> dp[v] = tmp</line-38>
<line-39> else:</line-39>
<line-40> q = (a[v]-rest)//size[v]</line-40>
<line-41> r = (a[v]-rest)%size[v]</line-41>
<line-42> if r:</line-42>
<line-43> dp[v] = tmp + q + 1</line-43>
<line-44> else:</line-44>
<line-45> dp[v] = tmp + q</line-45>
<line-47></line-47>
<line-48>print(dp[0])</line-48>
|
{"code": "<line-3>n = int(input())</line-3>\n<line-46> a[v] += S</line-46>", "lines": [3, 46]}
#### 0
|
<line-1>def check(w, s):</line-1>
<line-3> for i in range(len(s)):</line-3>
<line-4> while j < len(w) and s[i] != w[j]:</line-4>
<line-5> j += 1</line-5>
<line-6> if j >= len(w) or s[i] != w[j]:</line-6>
<line-7> return False</line-7>
<line-8> j += 1</line-8>
<line-9> return True</line-9>
<line-10></line-10>
<line-11>n = int(input())</line-11>
<line-12>s = input()</line-12>
<line-13>t = input()</line-13>
<line-14>st = []</line-14>
<line-15>i = 0</line-15>
<line-16>while i < n and s[i] == t[i]:</line-16>
<line-17> st.append(s[i])</line-17>
<line-18> i += 1</line-18>
<line-19>w1 = st[:]</line-19>
<line-20>w2 = st[:]</line-20>
<line-21>w3 = st[:]</line-21>
<line-22>w4 = st[:]</line-22>
<line-23>w1.append(s[i])</line-23>
<line-24>w1.append(t[i])</line-24>
<line-25>w3.append(s[i])</line-25>
<line-26>w3.append(t[i])</line-26>
<line-27>w2.append(t[i])</line-27>
<line-28>w2.append(s[i])</line-28>
<line-29>w4.append(t[i])</line-29>
<line-30>w4.append(s[i])</line-30>
<line-31>for j in range(i + 1, n):</line-31>
<line-32> w1.append(s[j])</line-32>
<line-33> w2.append(t[j])</line-33>
<line-34> w3.append(t[j])</line-34>
<line-35> w4.append(s[j])</line-35>
<line-36></line-36>
<line-37>res = set()</line-37>
<line-38>for ww in (w1, w2, w3, w4):</line-38>
<line-39> www = ''.join(ww)</line-39>
<line-40> if check(www, s) and check(www, t):</line-40>
<line-42>print(len(res))</line-42>
|
{"code": "<line-2> j = 0</line-2>\n<line-41> res.add(www)</line-41>", "lines": [2, 41]}
#### 0
|
<line-1>def sol():</line-1>
<line-2></line-2>
<line-4> st = list(map(int, input().split(' ')))</line-4>
<line-5> d = {}</line-5>
<line-6> for x in range(n):</line-6>
<line-7> d[x] = []</line-7>
<line-8></line-8>
<line-9> st = [(st[i], i) for i in range(len(st))]</line-9>
<line-10> st = sorted(st)</line-10>
<line-11></line-11>
<line-12> for a0 in range(n - 1):</line-12>
<line-13> u, v = map(int, input().split(' '))</line-13>
<line-14> u, v = u - 1, v - 1</line-14>
<line-15> d[u].append(v)</line-15>
<line-16> d[v].append(u)</line-16>
<line-17></line-17>
<line-18> hardest = []</line-18>
<line-19> almost = []</line-19>
<line-20></line-20>
<line-21> single_hardest = st[-1][0]</line-21>
<line-22></line-22>
<line-23> for x in st[::-1]:</line-23>
<line-24> if x[0] == single_hardest:</line-24>
<line-25> hardest.append(x[1])</line-25>
<line-26> elif x[0] == single_hardest-1:</line-26>
<line-27> almost.append(x[1])</line-27>
<line-28> else:</line-28>
<line-29> break</line-29>
<line-30></line-30>
<line-31> def inter(a, b):</line-31>
<line-32> c = []</line-32>
<line-33> for x in a:</line-33>
<line-34> if x in b:</line-34>
<line-35> c.append(x)</line-35>
<line-36> return c</line-36>
<line-37></line-37>
<line-38> lower_bound = single_hardest</line-38>
<line-39></line-39>
<line-40> inte = d[hardest[0]]+[hardest[0]]</line-40>
<line-41> for h in hardest[1:]:</line-41>
<line-42> inte = inter(inte, d[h]+[h])</line-42>
<line-43></line-43>
<line-44> if not inte:</line-44>
<line-45> return (single_hardest+2)</line-45>
<line-46></line-46>
<line-47> if len(hardest) > 1:</line-47>
<line-48> return single_hardest+1</line-48>
<line-49></line-49>
<line-50> # hardest is len 1</line-50>
<line-51> if not almost:</line-51>
<line-52> return single_hardest</line-52>
<line-53></line-53>
<line-54> cand = st[-1][1]</line-54>
<line-55></line-55>
<line-56> for h in almost:</line-56>
<line-57> if h not in d[cand]:</line-57>
<line-58> return single_hardest+1</line-58>
<line-60></line-60>
<line-61>print(sol())</line-61>
|
{"code": "<line-3> n = int(input())</line-3>\n<line-59> return single_hardest</line-59>", "lines": [3, 59]}
#### 0
|
<line-1>n, m = map(int, input().split())</line-1>
<line-3> print(1)</line-3>
<line-5>print(min(m, n - m))</line-5>
|
{"code": "<line-2>if m <= 1:</line-2>\n<line-4> return</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>k, r = list(map(int, input().split()))</line-1>
<line-2></line-2>
<line-4>for x in range(1, 11):</line-4>
<line-5> mod = k * x % 10</line-5>
<line-6> if mod == 0 or mod == r:</line-6>
<line-7> ans = x</line-7>
<line-9></line-9>
<line-10>print(ans)</line-10>
|
{"code": "<line-3>ans = 10</line-3>\n<line-8> break</line-8>", "lines": [3, 8]}
#### 0
|
<line-1>#!/usr/bin/env python3</line-1>
<line-2></line-2>
<line-4> import re</line-4>
<line-5></line-5>
<line-6> n, m = list(map(int, input().split()))</line-6>
<line-7> left = right = -1</line-7>
<line-8> for i in range(n):</line-8>
<line-9> mt = re.search(r"X+", input())</line-9>
<line-10> if mt is not None:</line-10>
<line-11> t = mt.start()</line-11>
<line-12> if t != left != -1:</line-12>
<line-13> print("NO")</line-13>
<line-14> break</line-14>
<line-15> left = t</line-15>
<line-16> t = mt.end()</line-16>
<line-17> if t != right != -1:</line-17>
<line-18> print("NO")</line-18>
<line-19> break</line-19>
<line-20> right = t</line-20>
<line-21> else:</line-21>
<line-23></line-23>
<line-24>main()</line-24>
|
{"code": "<line-3>def main():</line-3>\n<line-22> print(\"YES\")</line-22>", "lines": [3, 22]}
#### 0
|
<line-1>a, b = list(map(int, input().split(' ')))</line-1>
<line-3>e, f = list(map(int, input().split(' ')))</line-3>
<line-4>x=[[a, b],[c,d],[e,f]]</line-4>
<line-5>x.sort()</line-5>
<line-6>a, b, c, d, e, f = x[0][0], x[0][1], x[1][0], x[1][1], x[2][0], x[2][1]</line-6>
<line-7>if (a==c==e or b==d==f):</line-7>
<line-8> print(1)</line-8>
<line-9> quit()</line-9>
<line-10></line-10>
<line-11>if a == c:</line-11>
<line-12> if b<f<d:</line-12>
<line-13> print(3)</line-13>
<line-14> quit()</line-14>
<line-15> print(2)</line-15>
<line-16> quit()</line-16>
<line-17></line-17>
<line-18>if c == e:</line-18>
<line-19> if (d<b<f):</line-19>
<line-20> print(3)</line-20>
<line-21> quit()</line-21>
<line-22> print(2)</line-22>
<line-23> quit()</line-23>
<line-24></line-24>
<line-25>if b == d:</line-25>
<line-26> print(2)</line-26>
<line-27> quit()</line-27>
<line-28></line-28>
<line-29>if d == f:</line-29>
<line-30> print(2)</line-30>
<line-31> quit()</line-31>
<line-32></line-32>
<line-33>if b == f:</line-33>
<line-34> if a<c<e:</line-34>
<line-35> print(3)</line-35>
<line-36> quit()</line-36>
<line-37> print(2)</line-37>
<line-38> quit()</line-38>
<line-39></line-39>
<line-41>quit()</line-41>
|
{"code": "<line-2>c, d = list(map(int, input().split(' ')))</line-2>\n<line-40>print(3)</line-40>", "lines": [2, 40]}
#### 0
|
<line-1>import math,string,itertools,fractions,heapq,collections,re,array,bisect</line-1>
<line-3>from collections import defaultdict, deque</line-3>
<line-4></line-4>
<line-5>def VI(): return list(map(int,input().split()))</line-5>
<line-6></line-6>
<line-7>def main1(k):</line-7>
<line-8> # works correctly, but too slow and generates many more vertices than necessary.</line-8>
<line-9> # doesn't pass the time constraint with this implementation. (prints 10^5 lines)</line-9>
<line-10> # ==> use the editorial solution below.</line-10>
<line-11> if k%2==0:</line-11>
<line-12> print("NO")</line-12>
<line-13> return</line-13>
<line-14> print("YES")</line-14>
<line-15> n = 2*(k**2-k+1)</line-15>
<line-16> m = n*k//2</line-16>
<line-17> print(n, m)</line-17>
<line-18> i = 0</line-18>
<line-19> g = [[] for i in range(n+1)]</line-19>
<line-20> print(1,n//2+1)</line-20>
<line-21> off = 1</line-21>
<line-22> for j in range(0,k-1,2):</line-22>
<line-23> j1 = off + j+1</line-23>
<line-24> j2 = off + j+2</line-24>
<line-25> print(off,j1)</line-25>
<line-26> print(off,j2)</line-26>
<line-27> l1 = off + k + j*(k-1)</line-27>
<line-28> l2 = off + k + (j+1)*(k-1)</line-28>
<line-29> for l in range(k-1):</line-29>
<line-30> print(j1, l1+l)</line-30>
<line-31> print(j2, l2+l)</line-31>
<line-32> for m in range(k-1):</line-32>
<line-33> print(l1+l,l2+m)</line-33>
<line-34> off = n//2+1</line-34>
<line-35> for j in range(0,k-1,2):</line-35>
<line-36> j1 = off + j+1</line-36>
<line-37> j2 = off + j+2</line-37>
<line-38> print(off,j1)</line-38>
<line-39> print(off,j2)</line-39>
<line-40> l1 = off + k + j*(k-1)</line-40>
<line-41> l2 = off + k + (j+1)*(k-1)</line-41>
<line-42> for l in range(k-1):</line-42>
<line-43> print(j1, l1+l)</line-43>
<line-44> print(j2, l2+l)</line-44>
<line-45> for m in range(k-1):</line-45>
<line-46> print(l1+l,l2+m)</line-46>
<line-47></line-47>
<line-48>def main(k):</line-48>
<line-49> # following the editorial algo</line-49>
<line-50> if k%2==0:</line-50>
<line-51> print("NO")</line-51>
<line-52> return</line-52>
<line-53> print("YES")</line-53>
<line-54> if k==1:</line-54>
<line-55> print("2 1")</line-55>
<line-56> print("1 2")</line-56>
<line-57> return</line-57>
<line-58> n = 2*k+4</line-58>
<line-59> m = n*k//2</line-59>
<line-60> e = []</line-60>
<line-61> e.extend([(1,n//2+1)])</line-61>
<line-62> off = 1</line-62>
<line-63> for j in range(off+1,off+k):</line-63>
<line-64> e.extend([(off, j)])</line-64>
<line-65> for j in range(off+1,off+k):</line-65>
<line-66> for i in range(j+1,off+k):</line-66>
<line-67> if (i==j+1 and (j-off)%2==1):# or (j==off+1 and i==off+k-1):</line-67>
<line-68> #if (i==j+1 and i%2==0) or (j==off+1 and i==off+k-1):</line-68>
<line-69> continue</line-69>
<line-70> e.extend([(j,i)])</line-70>
<line-71> e.extend([(j,off+k),(j,off+k+1)])</line-71>
<line-72> e.extend([(off+k,off+k+1)])</line-72>
<line-73> off = n//2+1</line-73>
<line-74> for j in range(off+1,off+k):</line-74>
<line-75> e.extend([(off, j)])</line-75>
<line-76> for j in range(off+1,off+k):</line-76>
<line-77> for i in range(j+1,off+k):</line-77>
<line-78> if (i==j+1 and (j-off)%2==1):# or (j==off+1 and i==off+k-1):</line-78>
<line-79> continue</line-79>
<line-80> e.extend([(j,i)])</line-80>
<line-81> e.extend([(j,off+k),(j,off+k+1)])</line-81>
<line-82> e.extend([(off+k,off+k+1)])</line-82>
<line-83> print(n, m)</line-83>
<line-84> for x in e:</line-84>
<line-85> print(*x)</line-85>
<line-86></line-86>
<line-87></line-87>
<line-88></line-88>
<line-89>def main_input(info=0):</line-89>
<line-90> k = int(input())</line-90>
<line-91> main(k)</line-91>
<line-92></line-92>
<line-93>def __starting_point():</line-93>
<line-95></line-95>
<line-96>__starting_point()</line-96>
|
{"code": "<line-2>from itertools import chain, dropwhile, permutations, combinations</line-2>\n<line-94> main_input()</line-94>", "lines": [2, 94]}
#### 0
|
<line-1># </line-1>
<line-3></line-3>
<line-4>sys.setrecursionlimit(1000000)</line-4>
<line-5>def getIntList():</line-5>
<line-6> return list(map(int, input().split())) </line-6>
<line-7></line-7>
<line-8>try :</line-8>
<line-9> #raise ModuleNotFoundError</line-9>
<line-10> import numpy</line-10>
<line-11> def dprint(*args, **kwargs):</line-11>
<line-12> print(*args, **kwargs, file=sys.stderr)</line-12>
<line-13> dprint('debug mode')</line-13>
<line-14>except ModuleNotFoundError:</line-14>
<line-15> def dprint(*args, **kwargs):</line-15>
<line-16> pass</line-16>
<line-17></line-17>
<line-18></line-18>
<line-19></line-19>
<line-20>inId = 0</line-20>
<line-21>outId = 0</line-21>
<line-22>if inId>0:</line-22>
<line-23> dprint('use input', inId)</line-23>
<line-24> sys.stdin = open('input'+ str(inId) + '.txt', 'r') #标准输出重定向至文件</line-24>
<line-25>if outId>0:</line-25>
<line-26> dprint('use output', outId)</line-26>
<line-27> sys.stdout = open('stdout'+ str(outId) + '.txt', 'w') #标准输出重定向至文件</line-27>
<line-28> atexit.register(lambda :sys.stdout.close()) #idle 中不会执行 atexit</line-28>
<line-29> </line-29>
<line-30>N, M, Q = getIntList()</line-30>
<line-31></line-31>
<line-32>s1 = input()</line-32>
<line-33>s2 = input()</line-33>
<line-34></line-34>
<line-35>tot = 0</line-35>
<line-36>zt = [0]</line-36>
<line-37></line-37>
<line-38>for i in range(N):</line-38>
<line-39> if s1[i:i+M] == s2:</line-39>
<line-40> tot+=1</line-40>
<line-41> zt.append(tot)</line-41>
<line-42>dprint(zt)</line-42>
<line-43>for i in range(Q):</line-43>
<line-44> a,b = getIntList()</line-44>
<line-45> b0 = b- M+1</line-45>
<line-46> if b0<a:</line-46>
<line-47> print(0)</line-47>
<line-49> print(zt[b0] - zt[a-1])</line-49>
<line-50></line-50>
<line-51></line-51>
<line-52></line-52>
<line-53></line-53>
<line-54></line-54>
<line-55></line-55>
<line-56></line-56>
|
{"code": "<line-2>import collections, atexit, math, sys, bisect </line-2>\n<line-48> else:</line-48>", "lines": [2, 48]}
#### 0
|
<line-1>ans = {}</line-1>
<line-2></line-2>
<line-4> if not ans.get((n, k, d, used)):</line-4>
<line-5> if not n and used:</line-5>
<line-6> ans[(n, k, d, used)] = 1</line-6>
<line-7> else:</line-7>
<line-8> ans[(n, k, d, used)] = sum(gen(n - x, k, d, used or x >= d) for x in range(1, min(n, k) + 1) if max(x, n - x) >= d or used)</line-8>
<line-9> return ans[(n, k, d, used)]</line-9>
<line-10></line-10>
<line-11></line-11>
<line-13>print(gen(n, k, d) % 1000000007)</line-13>
|
{"code": "<line-3>def gen(n, k, d, used = False):</line-3>\n<line-12>n, k, d = list(map(int, input().split()))</line-12>", "lines": [3, 12]}
#### 0
|
<line-1># You lost the game.</line-1>
<line-2></line-2>
<line-4>s = str(input())</line-4>
<line-5></line-5>
<line-6>R = []</line-6>
<line-7>b = 0</line-7>
<line-8>for i in range(n):</line-8>
<line-9> if s[i] == "B":</line-9>
<line-10> b += 1</line-10>
<line-11> elif b > 0:</line-11>
<line-12> R += [b]</line-12>
<line-13> b = 0</line-13>
<line-14>if b > 0:</line-14>
<line-15> R += [b]</line-15>
<line-16>print(len(R))</line-16>
<line-18> print(R[i],end=" ")</line-18>
|
{"code": "<line-3>n = int(input())</line-3>\n<line-17>for i in range(len(R)):</line-17>", "lines": [3, 17]}
#### 0
|
<line-1>n, m, p = [int(x) for x in input().split()]</line-1>
<line-3>B = input().rstrip()</line-3>
<line-4></line-4>
<line-5>pair = [0] * n</line-5>
<line-6>stack = []</line-6>
<line-7>for (i, c) in enumerate(A):</line-7>
<line-8> if c == '(':</line-8>
<line-9> stack.append(i)</line-9>
<line-10> else:</line-10>
<line-11> j = stack.pop()</line-11>
<line-12> pair[i] = j</line-12>
<line-13> pair[j] = i</line-13>
<line-14></line-14>
<line-15>start = 0</line-15>
<line-16>pointer = p - 1</line-16>
<line-17>left = list(range(-1, n-1))</line-17>
<line-18>right = list(range(1, n+1))</line-18>
<line-19>left[0] = None</line-19>
<line-20>right[-1] = None</line-20>
<line-21></line-21>
<line-22>for c in B:</line-22>
<line-23> if c == 'R':</line-23>
<line-24> pointer = right[pointer]</line-24>
<line-25> elif c == 'L':</line-25>
<line-26> pointer = left[pointer]</line-26>
<line-27> else:</line-27>
<line-28> if pair[pointer] < pointer:</line-28>
<line-29> if right[pointer] is not None:</line-29>
<line-30> left[right[pointer]] = left[pair[pointer]]</line-30>
<line-31> if left[pair[pointer]] is not None:</line-31>
<line-32> right[left[pair[pointer]]] = right[pointer]</line-32>
<line-33> else:</line-33>
<line-34> start = right[pointer]</line-34>
<line-35></line-35>
<line-36> if right[pointer] is None:</line-36>
<line-37> pointer = left[pair[pointer]]</line-37>
<line-38> else:</line-38>
<line-39> pointer = right[pointer]</line-39>
<line-40> else:</line-40>
<line-41> if right[pair[pointer]] is not None:</line-41>
<line-42> left[right[pair[pointer]]] = left[pointer]</line-42>
<line-43> if left[pointer] is not None:</line-43>
<line-44> right[left[pointer]] = right[pair[pointer]]</line-44>
<line-45> else:</line-45>
<line-46> start = right[pair[pointer]]</line-46>
<line-47></line-47>
<line-48></line-48>
<line-49> if right[pair[pointer]] is None:</line-49>
<line-50> pointer = left[pointer]</line-50>
<line-51> else:</line-51>
<line-52> pointer = right[pair[pointer]]</line-52>
<line-53></line-53>
<line-54>i = start</line-54>
<line-55>while right[i] is not None:</line-55>
<line-56> print(A[i], end = '')</line-56>
<line-58>print(A[i])</line-58>
|
{"code": "<line-2>A = input().rstrip()</line-2>\n<line-57> i = right[i]</line-57>", "lines": [2, 57]}
#### 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>class InputHandlerObject(object):</line-8>
<line-9> inputs = []</line-9>
<line-10></line-10>
<line-11> def getInput(self, n = 0):</line-11>
<line-12> res = ""</line-12>
<line-13> inputs = self.inputs</line-13>
<line-14> if not inputs: inputs.extend(input().split(" "))</line-14>
<line-15> if n == 0:</line-15>
<line-16> res = inputs[:]</line-16>
<line-17> inputs[:] = []</line-17>
<line-18> while n > len(inputs):</line-18>
<line-19> inputs.extend(input().split(" "))</line-19>
<line-20> if n > 0:</line-20>
<line-21> res = inputs[:n]</line-21>
<line-22> inputs[:n] = []</line-22>
<line-23> return res</line-23>
<line-24>InputHandler = InputHandlerObject()</line-24>
<line-25>g = InputHandler.getInput</line-25>
<line-26></line-26>
<line-27>############################## SOLUTION ##############################</line-27>
<line-28>n = int(input().strip())</line-28>
<line-29>mn = -2*10**9</line-29>
<line-30>mx = 2*10**9</line-30>
<line-31>repl = [(">", "<="), (">=", "<"), ("<=", ">"), ("<", ">=")]</line-31>
<line-32>for i in range(n):</line-32>
<line-33> a = g()</line-33>
<line-34> a[1] = int(a[1])</line-34>
<line-35> if a[2] == "N":</line-35>
<line-36> for qq,qqq in repl:</line-36>
<line-37> if qq == a[0]:</line-37>
<line-38> a[0] = qqq</line-38>
<line-39> break</line-39>
<line-40> if a[0] == ">": a[1] += 1</line-40>
<line-41> if a[0] == "<": a[1] -= 1</line-41>
<line-42> if a[0][0] == ">": mn = max(mn, a[1])</line-42>
<line-43> if a[0][0] == "<": mx = min(mx, a[1])</line-43>
<line-44></line-44>
<line-45>if mn <= mx:</line-45>
<line-46> print(mn)</line-46>
<line-48> print("Impossible")</line-48>
|
{"code": "<line-2>Codeforces Round 241 Div 1 Problem A</line-2>\n<line-47>else:</line-47>", "lines": [2, 47]}
#### 0
|
<line-1>import math</line-1>
<line-3>n=a+b</line-3>
<line-4>ans,l=0,1</line-4>
<line-5>while l<=n:</line-5>
<line-6> g= n//l</line-6>
<line-7> if a<g or b<g:</line-7>
<line-8> l= (n//g) +1</line-8>
<line-9> continue</line-9>
<line-10> r= n//g</line-10>
<line-11> a_low = (a+g)//(g+1)</line-11>
<line-12> a_high = a//g</line-12>
<line-13> b_low=(b+g)//(g+1)</line-13>
<line-14> b_high = b//g</line-14>
<line-15> if (a_low <= a_high and b_low <= b_high):</line-15>
<line-16> ans += max(0,min(r,a_high+b_high)- max(l,a_low +b_low)+1)</line-16>
<line-17></line-17>
<line-19>print(ans)</line-19>
|
{"code": "<line-2>a,b= list(map(int,input().split()))</line-2>\n<line-18> l=r+1</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>n, k = list(map(int, input().split()))</line-1>
<line-3>names = [chr(ord("A") + i) for i in range(26)] + [chr(ord("A") + i) + chr(ord('a') + i) for i in range(26)]</line-3>
<line-4>ans = [names[i] for i in range(n)]</line-4>
<line-5>for i in range(k - 1, n):</line-5>
<line-6> if a[i - k + 1] == "NO":</line-6>
<line-8>print(*ans)</line-8>
|
{"code": "<line-2>a = input().split()</line-2>\n<line-7>\t\tans[i] = ans[i - k + 1]</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>a,b=list(map(int,input().split()))</line-1>
<line-3> if(b==0):</line-3>
<line-4> return a</line-4>
<line-5> return gcd(b,a%b)</line-5>
<line-6>def burn(n):</line-6>
<line-7> c=0</line-7>
<line-8> while(n%2==0):</line-8>
<line-9> c+=1</line-9>
<line-10> n=n//2</line-10>
<line-11> while(n%3==0):</line-11>
<line-12> c+=1</line-12>
<line-13> n=n//3</line-13>
<line-14> while(n%5==0):</line-14>
<line-15> c+=1</line-15>
<line-16> n=n//5</line-16>
<line-17> return [c,n]</line-17>
<line-18>if(a==b):</line-18>
<line-19> print(0)</line-19>
<line-20>else:</line-20>
<line-21> g=gcd(a,b)</line-21>
<line-22> c=a//g</line-22>
<line-23> d=b//g</line-23>
<line-24> l1=burn(c)</line-24>
<line-25> l2=burn(d)</line-25>
<line-26> if(l1[1]==1 and l2[1]==1):</line-26>
<line-27> print(l1[0]+l2[0])</line-27>
<line-29> print(-1)</line-29>
|
{"code": "<line-2>def gcd(a,b):</line-2>\n<line-28> else:</line-28>", "lines": [2, 28]}
#### 0
|
<line-1># import sys</line-1>
<line-3># sys.stdout = open("F:\\Scripts\\output","w")</line-3>
<line-4></line-4>
<line-5></line-5>
<line-6>MOD = 10**9 + 7</line-6>
<line-7>I = lambda:list(map(int,input().split()))</line-7>
<line-8></line-8>
<line-9>n , a , b = I()</line-9>
<line-10>l = I()</line-10>
<line-11>cost = 0</line-11>
<line-12>m = min(a,b)</line-12>
<line-13>for i in range(n//2):</line-13>
<line-14> if l[i] + l[n-i-1] == 1:</line-14>
<line-15> print(-1)</line-15>
<line-16> return</line-16>
<line-17> if l[i] == 2 and l[n - i - 1] == 2:</line-17>
<line-18> cost += 2*m</line-18>
<line-19> elif l[i] == 2 or l[n - i - 1] == 2:</line-19>
<line-20> if l[i] == 1 or l[n - i - 1] == 1:</line-20>
<line-21> cost += b</line-21>
<line-22> else:</line-22>
<line-23> cost += a</line-23>
<line-24>if n%2 and l[n//2] == 2:</line-24>
<line-26>print(cost)</line-26>
|
{"code": "<line-2># sys.stdin = open(\"F:\\\\Scripts\\\\input\",\"r\")</line-2>\n<line-25>\tcost += m</line-25>", "lines": [2, 25]}
#### 0
|
<line-2>print(("-1" if K & 1 else "".join(["wb\n"[2 if k == K else (min(j, k, K - 1 - j,</line-2>
<line-3> K - 1 - k) ^ i) & 1] for i in range(2) for j in range(K) for k in range(K +</line-3>
<line-4> 1)]) * (K >> 1)))</line-4>
|
{"code": "<line-1>K = int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>i = 2</line-3>
<line-4>while i * i <= n:</line-4>
<line-5> if n % i == 0:</line-5>
<line-6> ans *= i</line-6>
<line-7> while n % i == 0:</line-7>
<line-8> n //= i</line-8>
<line-9> i += 1</line-9>
<line-11>print(ans)</line-11>
|
{"code": "<line-2>ans = 1</line-2>\n<line-10>ans *= n</line-10>", "lines": [2, 10]}
#### 0
|
<line-2>a = '0'+input()+'0'</line-2>
<line-3>if '000' in a or '11' in a:print('No')</line-3>
<line-4>else:print('Yes')</line-4>
|
{"code": "<line-1>n = int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>ans = []</line-3>
<line-4></line-4>
<line-5>for k in range(1, n + 1):</line-5>
<line-6> x = [0] * k</line-6>
<line-7></line-7>
<line-8> x[0] = a[0]</line-8>
<line-9> for i in range(1, k):</line-9>
<line-10> x[i] = a[i] - a[i - 1]</line-10>
<line-11></line-11>
<line-12> ok = True</line-12>
<line-13> for i in range(k, n):</line-13>
<line-14> if x[i % k] != a[i] - a[i - 1]:</line-14>
<line-15> ok = False</line-15>
<line-16> break</line-16>
<line-17> if ok:</line-17>
<line-18> ans.append(k)</line-18>
<line-19></line-19>
<line-21>print(*ans)</line-21>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-20>print(len(ans))</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>a = list(map(int, input().split()))</line-1>
<line-3>for i in range(6):</line-3>
<line-4> for j in range(i):</line-4>
<line-5> for k in range(j):</line-5>
<line-6> ss = a[i] + a[j] + a[k]</line-6>
<line-7> if ss == s - ss:</line-7>
<line-8> print('YES')</line-8>
<line-10>print('NO')</line-10>
|
{"code": "<line-2>s = sum(a)</line-2>\n<line-9> return</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>a,b=map(int,input().split())</line-1>
<line-3>for i in range(0,40):</line-3>
<line-4> for j in range(0,40):</line-4>
<line-5> if (2**i)*(3**j)>=a and (2**i)*(3**j)<=b:</line-5>
<line-7>print(ans)</line-7>
|
{"code": "<line-2>ans=0</line-2>\n<line-6> ans+=1</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>n,k=map(int,input().split())</line-1>
<line-3>high=n</line-3>
<line-4>import sys</line-4>
<line-5>while low<=high:</line-5>
<line-6> mid=(low+high)//2</line-6>
<line-7> if mid*(mid+1)//2 -(n-mid)>k:</line-7>
<line-8> high=mid-1</line-8>
<line-9> elif mid*(mid+1)//2-(n-mid)==k:</line-9>
<line-10> print(n-mid)</line-10>
<line-11> return</line-11>
<line-13> low=mid+1</line-13>
|
{"code": "<line-2>low=1</line-2>\n<line-12> else :</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>a.sort()</line-3>
<line-4>ok = False</line-4>
<line-5>for i in range(n - 2):</line-5>
<line-6> if a[i] + a[i + 1] > a[i + 2]:</line-6>
<line-8>print(("NO", "YES")[ok])</line-8>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-7>\t\tok = True</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>x, y = map(int, input().split())</line-1>
<line-2></line-2>
<line-4> print('No')</line-4>
<line-5> return</line-5>
<line-6>else:</line-6>
<line-7> y -= 1</line-7>
<line-8></line-8>
<line-9>if y == 0 and x:</line-9>
<line-10> print('No')</line-10>
<line-11> return</line-11>
<line-12></line-12>
<line-13>if y > x or (x - y) & 1:</line-13>
<line-14> print('No')</line-14>
<line-16> print('Yes')</line-16>
|
{"code": "<line-3>if y == 0:</line-3>\n<line-15>else:</line-15>", "lines": [3, 15]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4> n,k, = rv()</line-4>
<line-5> a, = rl(1)</line-5>
<line-6> res = 0</line-6>
<line-7> count = [0] * 10</line-7>
<line-8> for i in range(n):</line-8>
<line-9> if a[i] < 100:</line-9>
<line-10> count[10 - (a[i] % 10) - 1] += 1</line-10>
<line-11> res += a[i] // 10</line-11>
<line-12> for i in range(10):</line-12>
<line-13> while count[i] > 0 and k >= i + 1:</line-13>
<line-14> res += 1</line-14>
<line-15> count[i] -= 1</line-15>
<line-16> k -= i + 1</line-16>
<line-17> already = res * 10</line-17>
<line-18> possible = n * 100</line-18>
<line-19> diff = possible - already</line-19>
<line-20> if diff > 0:</line-20>
<line-21> actual = min(diff, k)</line-21>
<line-22> res += actual // 10</line-22>
<line-23> print(res)</line-23>
<line-24></line-24>
<line-25></line-25>
<line-26></line-26>
<line-27></line-27>
<line-28></line-28>
<line-29></line-29>
<line-30>def prt(l): return print(' '.join(map(str, l)))</line-30>
<line-31>def rs(): return map(str, input().split())</line-31>
<line-32>def rv(): return map(int, input().split())</line-32>
<line-33>def rl(n): return [list(map(int, input().split())) for _ in range(n)] </line-33>
<line-35>solve()</line-35>
|
{"code": "<line-3>def solve():</line-3>\n<line-34>if sys.hexversion == 50594544 : sys.stdin = open(\"test.txt\")</line-34>", "lines": [3, 34]}
#### 0
|
<line-1>n, m = map(int, input().split())</line-1>
<line-3>b = [int(i) for i in input().split()]</line-3>
<line-4>a.sort()</line-4>
<line-5>b.sort()</line-5>
<line-6>for i in a:</line-6>
<line-7> if i in b:</line-7>
<line-8> print(i)</line-8>
<line-9> break</line-9>
<line-11> print(min(a[0], b[0]), max(a[0], b[0]), sep = '')</line-11>
|
{"code": "<line-2>a = [int(i) for i in input().split()]</line-2>\n<line-10>else:</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>"""</line-1>
<line-3></line-3>
<line-4>Author : chaotic_iak</line-4>
<line-5>Language: Python 3.5.2</line-5>
<line-6>"""</line-6>
<line-7></line-7>
<line-8>################################################### SOLUTION</line-8>
<line-9></line-9>
<line-10>def main():</line-10>
<line-11> n,k = read()</line-11>
<line-12> avail = 240-k</line-12>
<line-13> i = 1</line-13>
<line-14> while i <= n and avail >= 5*i:</line-14>
<line-15> avail -= 5*i</line-15>
<line-16> i += 1</line-16>
<line-17> print(i-1)</line-17>
<line-18></line-18>
<line-19>#################################################### HELPERS</line-19>
<line-20></line-20>
<line-21>def read(callback=int):</line-21>
<line-22> return list(map(callback, input().strip().split()))</line-22>
<line-23></line-23>
<line-24>def write(value, end="\n"):</line-24>
<line-25> if value is None: return</line-25>
<line-26> try:</line-26>
<line-27> value = " ".join(map(str, value))</line-27>
<line-28> except:</line-28>
<line-29> pass</line-29>
<line-31></line-31>
<line-32>write(main())</line-32>
|
{"code": "<line-2>Codeforces Good Bye 2016 Contest Problem A</line-2>\n<line-30> print(value, end=end)</line-30>", "lines": [2, 30]}
#### 0
|
<line-1>import sys,math</line-1>
<line-3>z=list(map(int,input().split()))</line-3>
<line-4>z.sort()</line-4>
<line-5>ans=0</line-5>
<line-6>for i in range(n):</line-6>
<line-7> if z[i]%2==0:</line-7>
<line-8> if x>=z[i]//2:</line-8>
<line-9> x-=z[i]//2</line-9>
<line-10> ans+=1</line-10>
<line-11> else:</line-11>
<line-12> z[i]-=x*2</line-12>
<line-13> x=0</line-13>
<line-14> y-=z[i]</line-14>
<line-15> if y>=0:</line-15>
<line-16> ans+=1</line-16>
<line-17> else:</line-17>
<line-18> break</line-18>
<line-19> else:</line-19>
<line-20> if x>=z[i]//2 and y>=1:</line-20>
<line-21> x-=z[i]//2</line-21>
<line-22> ans+=1</line-22>
<line-23> y-=1</line-23>
<line-24> elif x>=z[i]//2+1:</line-24>
<line-25> x-=z[i]//2+1</line-25>
<line-26> ans+=1</line-26>
<line-27> else:</line-27>
<line-28> z[i]-=x*2</line-28>
<line-29> x=0</line-29>
<line-30> y-=z[i]</line-30>
<line-31> if y>=0:</line-31>
<line-32> ans+=1</line-32>
<line-33> else:</line-33>
<line-35>print(ans)</line-35>
<line-36> </line-36>
<line-37> </line-37>
<line-38> </line-38>
<line-39> </line-39>
<line-40> </line-40>
<line-41> </line-41>
<line-42> </line-42>
<line-43> </line-43>
<line-44></line-44>
<line-45></line-45>
<line-46></line-46>
|
{"code": "<line-2>n,x,y=list(map(int,input().split()))</line-2>\n<line-34> break</line-34>", "lines": [2, 34]}
#### 0
|
<line-1>#JMD</line-1>
<line-3></line-3>
<line-4> </line-4>
<line-5>import sys</line-5>
<line-6>import math</line-6>
<line-7></line-7>
<line-8>#import fractions</line-8>
<line-9>#import numpy</line-9>
<line-10> </line-10>
<line-11>###File Operations###</line-11>
<line-12>fileoperation=0</line-12>
<line-13>if(fileoperation):</line-13>
<line-14> orig_stdout = sys.stdout</line-14>
<line-15> orig_stdin = sys.stdin</line-15>
<line-16> inputfile = open('W:/Competitive Programming/input.txt', 'r')</line-16>
<line-17> outputfile = open('W:/Competitive Programming/output.txt', 'w')</line-17>
<line-18> sys.stdin = inputfile</line-18>
<line-19> sys.stdout = outputfile</line-19>
<line-20></line-20>
<line-21>###Defines...###</line-21>
<line-22>mod=1000000007</line-22>
<line-23> </line-23>
<line-24>###FUF's...###</line-24>
<line-25>def nospace(l):</line-25>
<line-26> ans=''.join(str(i) for i in l)</line-26>
<line-27> return ans</line-27>
<line-28></line-28>
<line-29>ans=[]</line-29>
<line-30></line-30>
<line-31>def printDivisors(n) : </line-31>
<line-32> </line-32>
<line-33> # Note that this loop runs till square root </line-33>
<line-34> i = 1</line-34>
<line-35> while i <= math.sqrt(n): </line-35>
<line-36> </line-36>
<line-37> if (n % i == 0) : </line-37>
<line-38> </line-38>
<line-39> # If divisors are equal, print only one </line-39>
<line-40> if (n / i == i) : </line-40>
<line-41> ans.append(i) </line-41>
<line-42> else : </line-42>
<line-43> # Otherwise print both </line-43>
<line-44> ans.append(i)</line-44>
<line-45> ans.append(n//i) </line-45>
<line-46> i = i + 1</line-46>
<line-47> </line-47>
<line-48> </line-48>
<line-49> </line-49>
<line-50>##### Main ####</line-50>
<line-51>t=1</line-51>
<line-52>for tt in range(t):</line-52>
<line-53> n=int(input())</line-53>
<line-54> printDivisors(n)</line-54>
<line-55> s=set(ans)</line-55>
<line-56> print(len(s))</line-56>
<line-57> #a=list(map(int,sys.stdin.readline().split(' ')))</line-57>
<line-58> #n,k,s= map(int, sys.stdin.readline().split(' '))</line-58>
<line-59> </line-59>
<line-60> </line-60>
<line-61>#####File Operations#####</line-61>
<line-62>if(fileoperation):</line-62>
<line-63> sys.stdout = orig_stdout</line-63>
<line-64> sys.stdin = orig_stdin</line-64>
<line-66> outputfile.close()</line-66>
|
{"code": "<line-2>#Nagendra Jha-4096</line-2>\n<line-65> inputfile.close()</line-65>", "lines": [2, 65]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>l = 0</line-3>
<line-4>ans = 0</line-4>
<line-5>while l < len(s) and s[l] == '<':</line-5>
<line-6> ans += 1</line-6>
<line-7> l += 1</line-7>
<line-8></line-8>
<line-9>r = n - 1</line-9>
<line-10>while r >= 0 and s[r] == '>':</line-10>
<line-11> ans += 1</line-11>
<line-13></line-13>
<line-14>print(ans)</line-14>
|
{"code": "<line-2>s = input()</line-2>\n<line-12> r -= 1</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>arr = [0] * (10 ** 6 + 1)</line-1>
<line-3>for i in input().split():</line-3>
<line-4> arr[int(i)] += 1</line-4>
<line-5>i = 10 ** 6</line-5>
<line-6>j = i</line-6>
<line-7>k = i</line-7>
<line-8>c = 0</line-8>
<line-9>while j > 0:</line-9>
<line-10> if arr[j] % 2 == 1 and (arr[j] > 1 or c == 0):</line-10>
<line-11> arr[j - 1] += 1</line-11>
<line-12> c = 1</line-12>
<line-13> else:</line-13>
<line-14> c = 0</line-14>
<line-15> j -= 1</line-15>
<line-16>r = 0</line-16>
<line-17>while i > 0 and k > 0:</line-17>
<line-18> if arr[i] < 2:</line-18>
<line-19> if i == k:</line-19>
<line-20> k -= 1</line-20>
<line-21> i -= 1</line-21>
<line-22> elif i == k and arr[i] < 4:</line-22>
<line-23> k -= 1</line-23>
<line-24> elif arr[k] < 2:</line-24>
<line-25> k -= 1</line-25>
<line-26> else:</line-26>
<line-27> r += i * k</line-27>
<line-28> arr[i] -= 2</line-28>
<line-30>print(r)</line-30>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-29> arr[k] -= 2</line-29>", "lines": [2, 29]}
#### 0
|
<line-1>'''input</line-1>
<line-3>aa</line-3>
<line-4>jj</line-4>
<line-5>aa</line-5>
<line-6>'''</line-6>
<line-7></line-7>
<line-8>def list_input():</line-8>
<line-9> return list(map(int,input().split()))</line-9>
<line-10>def map_input():</line-10>
<line-11> return map(int,input().split())</line-11>
<line-12>def map_string():</line-12>
<line-13> return input().split()</line-13>
<line-14> </line-14>
<line-15>n = int(input())</line-15>
<line-16>d = {}</line-16>
<line-17>pos = {}</line-17>
<line-18>for _ in range(n):</line-18>
<line-19> s = list(input())</line-19>
<line-20> s = s[::-1]</line-20>
<line-21> for i in range(len(s)):</line-21>
<line-22> try:</line-22>
<line-23> d[s[i]] += 10**i</line-23>
<line-24> except:</line-24>
<line-25> d[s[i]] = 10**i</line-25>
<line-26> pos[s[i]] = True</line-26>
<line-27> if i == len(s)-1:</line-27>
<line-28> pos[s[i]] = False </line-28>
<line-29>a = []</line-29>
<line-30>b = []</line-30>
<line-31>for i in d:</line-31>
<line-32> a.append(d[i])</line-32>
<line-33> if pos[i]:</line-33>
<line-34> b.append(d[i])</line-34>
<line-35>if len(b):a.remove(max(b))</line-35>
<line-36>a.sort(reverse = True)</line-36>
<line-37># print(a)</line-37>
<line-38>ans = 0</line-38>
<line-39>for i in range(len(a)):</line-39>
<line-41>print(ans) </line-41>
|
{"code": "<line-2>3</line-2>\n<line-40>\tans += (i+1)*a[i]</line-40>", "lines": [2, 40]}
#### 0
|
<line-2>print(min([a, b, (a+b)//3]))</line-2>
|
{"code": "<line-1>a, b = list(map(int, input().split(' ')))</line-1>", "lines": [1]}
#### 0
|
<line-1>a = []</line-1>
<line-3>x = input()</line-3>
<line-4>for i in range(len(x)-1):</line-4>
<line-5> if x[i]+x[i+1] == 'AB':</line-5>
<line-6> a.append(i)</line-6>
<line-7> elif x[i]+x[i+1] == 'BA':</line-7>
<line-8> b.append(i)</line-8>
<line-9></line-9>
<line-10>if a == [] or b == []:</line-10>
<line-11> print("NO")</line-11>
<line-12> quit()</line-12>
<line-13> </line-13>
<line-14>if abs(min(a)-max(b))>1 or abs(max(a)-min(b))>1:</line-14>
<line-15> print("YES")</line-15>
<line-17>print("NO")</line-17>
|
{"code": "<line-2>b = []</line-2>\n<line-16> quit()</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>b = [0,]</line-4>
<line-5>ans1 = []</line-5>
<line-6>ans2 = []</line-6>
<line-7>n = int(input())</line-7>
<line-8>s = input()</line-8>
<line-9>nums = s.split()</line-9>
<line-10>for i in range(0, n):</line-10>
<line-11> a.append(int(nums[i]))</line-11>
<line-12></line-12>
<line-13>k = int(input())</line-13>
<line-14>s = input()</line-14>
<line-15>nums = s.split()</line-15>
<line-16>for i in range(0, k):</line-16>
<line-17> b.append(int(nums[i]))</line-17>
<line-18></line-18>
<line-19>def f(x, y, z):</line-19>
<line-20> #print(x,y,z)</line-20>
<line-21> pos1 = x</line-21>
<line-22> pos2 = x</line-22>
<line-23> if x == y:</line-23>
<line-24> return 1</line-24>
<line-25> for i in range(x, y + 1):</line-25>
<line-26> if a[i] > a[pos1]:</line-26>
<line-27> pos1 = i</line-27>
<line-28> if a[i] >= a[pos2]:</line-28>
<line-29> pos2 = i</line-29>
<line-30> for i in range(x, y):</line-30>
<line-31> if a[i] == a[pos2]:</line-31>
<line-32> if a[i + 1] < a[i]:</line-32>
<line-33> pos2 = i</line-33>
<line-34> for i in range(x + 1, y + 1):</line-34>
<line-35> if a[i] == a[pos1]:</line-35>
<line-36> if a[i - 1] < a[i]:</line-36>
<line-37> pos1 = i</line-37>
<line-38> if pos1 != x or a[pos1] > a[pos1 + 1]:</line-38>
<line-39> for i in range(0, pos1 - x):</line-39>
<line-40> ans1.append(pos1 - x + z - i)</line-40>
<line-41> ans2.append('L')</line-41>
<line-42> for i in range(0, y - pos1):</line-42>
<line-43> ans1.append(z)</line-43>
<line-44> ans2.append('R')</line-44>
<line-45> elif pos2 != y or a[pos2] > a[pos2 - 1]:</line-45>
<line-46> for i in range(0, y - pos2):</line-46>
<line-47> ans1.append(pos2 - x + z)</line-47>
<line-48> ans2.append('R')</line-48>
<line-49> for i in range(0, pos2 - x):</line-49>
<line-50> ans1.append(pos2 - x + z - i)</line-50>
<line-51> ans2.append('L')</line-51>
<line-52> else:</line-52>
<line-53> return 0</line-53>
<line-54></line-54>
<line-55> return 1</line-55>
<line-56></line-56>
<line-57>lasti = 0</line-57>
<line-58>j = 1</line-58>
<line-59>sum = 0</line-59>
<line-60>for i in range(1, n+1):</line-60>
<line-61> if j > k:</line-61>
<line-62> print('NO')</line-62>
<line-63> return</line-63>
<line-64> sum += a[i]</line-64>
<line-65> #print(i, sum, j)</line-65>
<line-66> if sum > b[j]:</line-66>
<line-67> print('NO')</line-67>
<line-68> return</line-68>
<line-69> if sum == b[j]:</line-69>
<line-70> if f(lasti + 1, i, j) == 0:</line-70>
<line-71> print('NO')</line-71>
<line-72> return</line-72>
<line-73> lasti = i</line-73>
<line-74> j += 1</line-74>
<line-75> sum = 0</line-75>
<line-76></line-76>
<line-77>if j <= k:</line-77>
<line-78> print('NO')</line-78>
<line-79> return</line-79>
<line-80></line-80>
<line-81>print('YES')</line-81>
<line-83> print(ans1[i], ans2[i])</line-83>
|
{"code": "<line-3>a = [0,]</line-3>\n<line-82>for i in range(0, len(ans1)):</line-82>", "lines": [3, 82]}
#### 0
|
<line-2>if a==b: print("Yes")</line-2>
<line-3>else: print("No")</line-3>
|
{"code": "<line-1>a, b = list(map(int, input().split()))</line-1>", "lines": [1]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>max1 = 1</line-3>
<line-4>for i in l:</line-4>
<line-5> k = 1</line-5>
<line-6> x = i</line-6>
<line-7> while x % 2 == 0:</line-7>
<line-8> k *= 2</line-8>
<line-9> x //= 2</line-9>
<line-10> max1 = max(max1, k)</line-10>
<line-11>c = 0</line-11>
<line-12>for i in l:</line-12>
<line-13> if i % max1 == 0:</line-13>
<line-15>print(max1, c)</line-15>
|
{"code": "<line-2>l = list(map(int, input().split()))</line-2>\n<line-14> c += 1</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>def main():</line-1>
<line-3> res, delta = 0, 1</line-3>
<line-4> while n < m:</line-4>
<line-5> res += 1</line-5>
<line-6> n *= 2</line-6>
<line-7> delta *= 2</line-7>
<line-8> while n > m:</line-8>
<line-9> while n - delta >= m:</line-9>
<line-10> res += 1</line-10>
<line-11> n -= delta</line-11>
<line-12> delta //= 2</line-12>
<line-13> print(res)</line-13>
<line-14></line-14>
<line-15></line-15>
<line-16>def __starting_point():</line-16>
<line-18>__starting_point()</line-18>
|
{"code": "<line-2> n, m = map(int, input().split())</line-2>\n<line-17> main()</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>import sys</line-1>
<line-3>input = reader.__next__</line-3>
<line-4></line-4>
<line-5>class BIT_RSQ():</line-5>
<line-6> def __init__(self, n):</line-6>
<line-7> self.n = n</line-7>
<line-8> self.data = [0]*(n+2)</line-8>
<line-9></line-9>
<line-10> def add(self, i, v):</line-10>
<line-11> while i <= self.n:</line-11>
<line-12> self.data[i] += v</line-12>
<line-13> i += i & -i</line-13>
<line-14></line-14>
<line-15> def sum(self, i):</line-15>
<line-16> ret = 0</line-16>
<line-17> while(i > 0):</line-17>
<line-18> ret += self.data[i]</line-18>
<line-19> i -= i & -i</line-19>
<line-20> return ret</line-20>
<line-21></line-21>
<line-22> def query(self, l, r):</line-22>
<line-23> return self.sum(r) - self.sum(l-1)</line-23>
<line-24></line-24>
<line-25> def lowerBound(self, w):</line-25>
<line-26> if w <= 0: return 0</line-26>
<line-27> x, k = 0, 2**self.n.bit_length()</line-27>
<line-28> while k:</line-28>
<line-29> if x+k <= self.n and self.data[x+k] < w:</line-29>
<line-30> w -= self.data[x+k]</line-30>
<line-31> x += k</line-31>
<line-32> k >>= 1</line-32>
<line-33> return x + 1</line-33>
<line-34></line-34>
<line-35>n = int(input())</line-35>
<line-36>edges = [0]*(2*n)</line-36>
<line-37>c = [0]*(2*n)</line-37>
<line-38>BIT = BIT_RSQ(2*n)</line-38>
<line-39></line-39>
<line-40>uf = [-1]*n</line-40>
<line-41>def root(x):</line-41>
<line-42> if uf[x] < 0:</line-42>
<line-43> return x</line-43>
<line-44> uf[x] = root(uf[x])</line-44>
<line-45> return uf[x]</line-45>
<line-46>def unite(x,y):</line-46>
<line-47> rx, ry = root(x), root(y)</line-47>
<line-48> if rx == ry:</line-48>
<line-49> return False</line-49>
<line-50> if uf[rx] > uf[ry]:</line-50>
<line-51> rx, ry = ry, rx</line-51>
<line-52> uf[rx] += uf[ry]</line-52>
<line-53> uf[ry] = rx</line-53>
<line-54> return True</line-54>
<line-55></line-55>
<line-56>for i in range(n):</line-56>
<line-57> a,b = list(map(int, input().split()))</line-57>
<line-58> a,b = a-1,b-1</line-58>
<line-59> c[a] = c[b] = i</line-59>
<line-60> edges[a] = b</line-60>
<line-61> edges[b] = b</line-61>
<line-62></line-62>
<line-63>for i in reversed(list(range(2*n))):</line-63>
<line-64> j = edges[i]</line-64>
<line-65> if j == i:</line-65>
<line-66> BIT.add(j+1, 1)</line-66>
<line-67> else:</line-67>
<line-68> BIT.add(j+1, -1)</line-68>
<line-69> cnt = BIT.sum(j+1)</line-69>
<line-70> while cnt:</line-70>
<line-71> k = BIT.lowerBound(cnt)</line-71>
<line-72> if not unite(c[j], c[k-1]):</line-72>
<line-73> print("NO")</line-73>
<line-74> return</line-74>
<line-75> cnt -= 1</line-75>
<line-76>if sum(i<0 for i in uf) == 1:</line-76>
<line-77> print("YES")</line-77>
<line-79> print("NO")</line-79>
<line-80></line-80>
|
{"code": "<line-2>reader = (s.rstrip() for s in sys.stdin)</line-2>\n<line-78>else:</line-78>", "lines": [2, 78]}
#### 0
|
<line-1>def prog():</line-1>
<line-3> inp = list(map(int,input().split()))</line-3>
<line-4> ans = 0</line-4>
<line-5> for i in range(len(inp)):</line-5>
<line-6> x,y = 0 ,0</line-6>
<line-7> for j in range(i,len(inp)):</line-7>
<line-8> x+=inp[j]</line-8>
<line-9> y+=100</line-9>
<line-10> if(x>y):</line-10>
<line-11> ans = max(ans,(j-i)+1)</line-11>
<line-13>prog()</line-13>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-12> print(ans)</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>s = input()</line-5>
<line-6></line-6>
<line-7>def max_streak(s):</line-7>
<line-8> result = 0</line-8>
<line-9></line-9>
<line-10> for i in range(len(s)):</line-10>
<line-11> j = i</line-11>
<line-12> while j < len(s) and s[j] == 'N':</line-12>
<line-13> j += 1</line-13>
<line-14></line-14>
<line-15> result = max(result, j - i)</line-15>
<line-16></line-16>
<line-17> return result</line-17>
<line-18></line-18>
<line-19>for i in range(n - k + 1):</line-19>
<line-20> cur = list(s)</line-20>
<line-21> for j in range(i, i + k):</line-21>
<line-22> if cur[j] == '?':</line-22>
<line-23> cur[j] = 'N'</line-23>
<line-24></line-24>
<line-25> for j in range(i):</line-25>
<line-26> if cur[j] == '?':</line-26>
<line-27> cur[j] = 'Y'</line-27>
<line-28></line-28>
<line-29> for j in range(i + k, n):</line-29>
<line-30> if cur[j] == '?':</line-30>
<line-31> cur[j] = 'Y'</line-31>
<line-32></line-32>
<line-33> if max_streak(cur) == k:</line-33>
<line-34> print('YES')</line-34>
<line-36></line-36>
<line-37>print('NO')</line-37>
|
{"code": "<line-3>n, k = list(map(int, input().split(' ')))</line-3>\n<line-35> return</line-35>", "lines": [3, 35]}
#### 0
|
<line-1>def solve():</line-1>
<line-3></line-3>
<line-4> if D == 0:</line-4>
<line-5> if X == 0:</line-5>
<line-6> print((1))</line-6>
<line-7> else:</line-7>
<line-8> print((N+1))</line-8>
<line-9> return</line-9>
<line-10></line-10>
<line-11> LRss = {}</line-11>
<line-12> for k in range(N+1):</line-12>
<line-13> m = X*k</line-13>
<line-14> rem = m%D</line-14>
<line-15> minCoef = m//D + k*(k-1)//2</line-15>
<line-16> maxCoef = m//D + k*(2*N-k-1)//2</line-16>
<line-17> if rem not in LRss:</line-17>
<line-18> LRss[rem] = [(minCoef, maxCoef)]</line-18>
<line-19> else:</line-19>
<line-20> LRss[rem].append((minCoef, maxCoef))</line-20>
<line-21></line-21>
<line-22> ans = 0</line-22>
<line-23> for rem, LRs in list(LRss.items()):</line-23>
<line-24> LRs.sort()</line-24>
<line-25> LNow, RNow = LRs[0]</line-25>
<line-26> for L, R in LRs[1:]:</line-26>
<line-27> if L <= RNow:</line-27>
<line-28> if R > RNow:</line-28>
<line-29> RNow = R</line-29>
<line-30> else:</line-30>
<line-31> ans += RNow - LNow + 1</line-31>
<line-32> LNow, RNow = L, R</line-32>
<line-33> ans += RNow - LNow + 1</line-33>
<line-34></line-34>
<line-36></line-36>
<line-37></line-37>
<line-38>solve()</line-38>
|
{"code": "<line-2> N, X, D = list(map(int, input().split()))</line-2>\n<line-35> print(ans)</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>read = lambda: map(int, input().split())</line-1>
<line-3>for i in range(n):</line-3>
<line-4> name, x, y = input().split()</line-4>
<line-5> x, y = int(x), int(y)</line-5>
<line-6> if x >= 2400 and y > x:</line-6>
<line-7> print('YES')</line-7>
<line-9>print('NO')</line-9>
|
{"code": "<line-2>n = int(input())</line-2>\n<line-8> return</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>s = int(input(), 2)</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>while t < s:</line-5>
<line-6> ans += 1</line-6>
<line-8></line-8>
<line-9>print(ans)</line-9>
|
{"code": "<line-3>t, ans = 1, 0</line-3>\n<line-7>\tt *= 4</line-7>", "lines": [3, 7]}
#### 0
|
<line-1>n,m = [int(i) for i in input().split()]</line-1>
<line-3>for i in range(n):</line-3>
<line-4> l.append(input().strip())</line-4>
<line-5>while len(l)%2 == 0:</line-5>
<line-6> mirror = True</line-6>
<line-7> for i in range(len(l)//2):</line-7>
<line-8> if l[i] != l[len(l)-1-i]:</line-8>
<line-9> mirror = False</line-9>
<line-10> break</line-10>
<line-11> if mirror:</line-11>
<line-12> l = l[:len(l)//2]</line-12>
<line-13> else:</line-13>
<line-15></line-15>
<line-16>print(len(l))</line-16>
|
{"code": "<line-2>l = []</line-2>\n<line-14> break</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>def key_tri(argument):</line-1>
<line-3></line-3>
<line-4>n = int(input())</line-4>
<line-5>L = [list(map(int, input().split())) for _ in range(n)]</line-5>
<line-6>L.sort(key=key_tri)</line-6>
<line-7>r = 1</line-7>
<line-8>t = L[0][1]</line-8>
<line-9>for k in range(1,n):</line-9>
<line-10> if L[k][0]>t:</line-10>
<line-11> r+=1</line-11>
<line-13>print(r)</line-13>
|
{"code": "<line-2> return argument[1]</line-2>\n<line-12> t = L[k][1]</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>def max(a, b):</line-1>
<line-3> return a</line-3>
<line-4> else:</line-4>
<line-5> return b</line-5>
<line-6>n, k = map(int, input().split())</line-6>
<line-7>x = [int(t) for t in input().split()]</line-7>
<line-8>y = [int(t) for t in input().split()]</line-8>
<line-9>f, s = 0, 0</line-9>
<line-10>for i in range(n):</line-10>
<line-11> f = max(0, x[i] + f - k * y[i])</line-11>
<line-12> s = max(0, y[i] + s - k * x[i])</line-12>
<line-13> if f > k or s > k:</line-13>
<line-14> print('NO')</line-14>
<line-16>print('YES')</line-16>
|
{"code": "<line-2>\tif a > b:</line-2>\n<line-15> return</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>p=1048583</line-1>
<line-3>modd=p*q*p*q</line-3>
<line-4>n,k=tuple(map(int,input().split()))</line-4>
<line-5>a=[0]</line-5>
<line-6>wenhao=0</line-6>
<line-7>gai=0</line-7>
<line-8>for i in range(n+1):</line-8>
<line-9> m=input()</line-9>
<line-10> if m[0]=='?':</line-10>
<line-11> a.append('?')</line-11>
<line-12> wenhao+=1</line-12>
<line-13> else:</line-13>
<line-14> a.append(int(m))</line-14>
<line-15> gai+=1</line-15>
<line-16></line-16>
<line-17>if k==0:</line-17>
<line-18> if (a[1]=='?' and gai&1==1) or a[1]==0:</line-18>
<line-19> print('Yes')</line-19>
<line-20> else:</line-20>
<line-21> print('No')</line-21>
<line-22>else:</line-22>
<line-23> if wenhao!=0:</line-23>
<line-24> if n&1==1:</line-24>
<line-25> print('Yes')</line-25>
<line-26> else:</line-26>
<line-27> print('No')</line-27>
<line-28> else:</line-28>
<line-29> m=a[n+1]</line-29>
<line-30> nn=a[n]</line-30>
<line-31> for i in range(n,0,-1):</line-31>
<line-32> m,nn=(nn+k*m)%modd,a[i-1]</line-32>
<line-33> if m==0:</line-33>
<line-34> print('Yes')</line-34>
<line-36> print('No')</line-36>
|
{"code": "<line-2>q=1048589</line-2>\n<line-35> else:</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>from math import floor, sqrt</line-1>
<line-3></line-3>
<line-4>import math</line-4>
<line-5></line-5>
<line-6></line-6>
<line-7>def rwh_primes2(n):</line-7>
<line-8> # https://stackoverflow.com/questions/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188</line-8>
<line-9> """ Input n>=6, Returns a list of primes, 2 <= p < n """</line-9>
<line-10> correction = (n%6>1)</line-10>
<line-11> n = {0:n,1:n-1,2:n+4,3:n+3,4:n+2,5:n+1}[n%6]</line-11>
<line-12> sieve = [True] * (n//3)</line-12>
<line-13> sieve[0] = False</line-13>
<line-14> for i in range(int(n**0.5)//3+1):</line-14>
<line-15> if sieve[i]:</line-15>
<line-16> k=3*i+1|1</line-16>
<line-17> sieve[ ((k*k)//3) ::2*k]=[False]*((n//6-(k*k)//6-1)//k+1)</line-17>
<line-18> sieve[(k*k+4*k-2*k*(i&1))//3::2*k]=[False]*((n//6-(k*k+4*k-2*k*(i&1))//6-1)//k+1)</line-18>
<line-19> return [2,3] + [3*i+1|1 for i in range(1,n//3-correction) if sieve[i]]</line-19>
<line-20></line-20>
<line-21></line-21>
<line-22>k = int(input())</line-22>
<line-23></line-23>
<line-24>primes = rwh_primes2(k)</line-24>
<line-25></line-25>
<line-26>a = 1</line-26>
<line-27>p2 = 2</line-27>
<line-28>for i in primes[::-1]:</line-28>
<line-29> if k%i == 0:</line-29>
<line-30> p2 = i</line-30>
<line-31> break</line-31>
<line-32></line-32>
<line-33>xx = range(k-p2+1, k+1)</line-33>
<line-34>#print(list(xx))</line-34>
<line-35>if p2>240:</line-35>
<line-36> p1 = primes[bisect.bisect_left(primes, int(math.ceil(xx[0]/2)))]</line-36>
<line-37> print(p1+1)</line-37>
<line-38>else:</line-38>
<line-39> ans = k</line-39>
<line-40> p1 = 1</line-40>
<line-41> for x1 in xx:</line-41>
<line-42> for i in primes[::-1]:</line-42>
<line-43></line-43>
<line-44> if i >= x1:</line-44>
<line-45> continue</line-45>
<line-46></line-46>
<line-47> if x1 % i == 0:</line-47>
<line-48> p1 = i</line-48>
<line-49> break</line-49>
<line-51></line-51>
<line-52> print(ans)</line-52>
|
{"code": "<line-2>import bisect</line-2>\n<line-50> ans = min(ans, x1-p1+1)</line-50>", "lines": [2, 50]}
#### 0
|
<line-1>n, p = list(map(int, input().split()))</line-1>
<line-3> s = bin(n)</line-3>
<line-4> if n >= q >= s.count('1'):</line-4>
<line-5> print(q)</line-5>
<line-6> break</line-6>
<line-7> n -= p</line-7>
<line-9> print(-1)</line-9>
|
{"code": "<line-2>for q in range(5757):</line-2>\n<line-8>else:</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>n, k = list(map(int, input().split()))</line-1>
<line-3>if len(s) == 1 and k:</line-3>
<line-4> print(0)</line-4>
<line-5> return</line-5>
<line-6>if s[0] != '1' and k:</line-6>
<line-7> k -= 1</line-7>
<line-8> s[0] = '1'</line-8>
<line-9>for i in range(1, len(s)):</line-9>
<line-10> if s[i] != '0' and k:</line-10>
<line-11> s[i] = '0'</line-11>
<line-12> k -= 1</line-12>
<line-13> if not k:</line-13>
<line-15>print(''.join(s))</line-15>
<line-16></line-16>
|
{"code": "<line-2>s = list(input())</line-2>\n<line-14>\t\tbreak</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>n0, n1, x, y = list(map(int, input().split()))</line-1>
<line-2></line-2>
<line-4> return max(0, n - (m // y - m // (x * y)))</line-4>
<line-5></line-5>
<line-6>lo = -1</line-6>
<line-7>hi = x * y * (n0 + n1)</line-7>
<line-8>while lo + 1 < hi:</line-8>
<line-9> mid = lo + (hi - lo) // 2</line-9>
<line-10> if f(mid, n0, x, y) + f(mid, n1, y, x) <= mid - mid // x - mid // y + mid // (x * y):</line-10>
<line-11> hi = mid</line-11>
<line-12> else:</line-12>
<line-14>print(hi)</line-14>
|
{"code": "<line-3>def f(m, n, x, y):</line-3>\n<line-13> lo = mid</line-13>", "lines": [3, 13]}
#### 0
|
<line-1>#Simple non-optimized class of matrices. Used with small dense matrices.</line-1>
<line-3>import itertools</line-3>
<line-4>import math</line-4>
<line-5></line-5>
<line-6>class NotAMatrixError(Exception):</line-6>
<line-7> pass</line-7>
<line-8></line-8>
<line-9>class MatrixSizeError(Exception):</line-9>
<line-10> def __init__(self, s1, s2):</line-10>
<line-11> print('sizes do not match : ', s1, ', ', s2)</line-11>
<line-12></line-12>
<line-13>class NotSquareError(Exception):</line-13>
<line-14> pass</line-14>
<line-15></line-15>
<line-16>class Matrix(list):</line-16>
<line-17> def __init__(self, L):</line-17>
<line-18> if type(L) == type(self):</line-18>
<line-19> self = L</line-19>
<line-20> return</line-20>
<line-21> n = len(L)</line-21>
<line-22> m = len(L[0])</line-22>
<line-23> for i in range(n):</line-23>
<line-24> if len(L[i]) != m:</line-24>
<line-25> raise NotAMatrixError()</line-25>
<line-26> list.__init__(self, L)</line-26>
<line-27> self.n = n</line-27>
<line-28> self.m = m</line-28>
<line-29> self.degrees = []</line-29>
<line-30> def check_size(self, M, mode):</line-30>
<line-31> n, m = len(M), len(M[0])</line-31>
<line-32> for i in range(n):</line-32>
<line-33> if len(M[i]) != m:</line-33>
<line-34> raise NotAMatrixError()</line-34>
<line-35> </line-35>
<line-36> if mode == 'add' and (self.n != n or self.m != m):</line-36>
<line-37> raise MatrixSizeError((self.n, self.m), (n,m))</line-37>
<line-38> if mode == 'lul' and self.m != n:</line-38>
<line-39> print(self.m, n, self.m != n)</line-39>
<line-40> raise MatrixSizeError((self.n, self.m), (n,m))</line-40>
<line-41> def __add__(self, M):</line-41>
<line-42> self.check_size(M, mode = 'add')</line-42>
<line-43> return Matrix([[self[i][j]+M[i][j] for j in range(self.m)]for i in range(self.n)])</line-43>
<line-44> def __iadd__(self, M):</line-44>
<line-45> self.check_size(M, mode = 'add')</line-45>
<line-46> for i in range(self.n):</line-46>
<line-47> for j in range(self,m):</line-47>
<line-48> self[i][j] += M[i][j]</line-48>
<line-49> def __mul__(self, M):</line-49>
<line-50> self.check_size(M, mode = 'mul')</line-50>
<line-51> l = len(M[0])</line-51>
<line-52> return Matrix([[sum(self[i][k]*M[k][j] for k in range(self.m))</line-52>
<line-53> for j in range(l)] for i in range(self.n)])</line-53>
<line-54> def issquare(self):</line-54>
<line-55> return self.n == self.m</line-55>
<line-56> def primary(self):</line-56>
<line-57> if self.n != self.m:</line-57>
<line-58> raise NotSquareError()</line-58>
<line-59> return Matrix([[int(i==j) for j in range(self.m)] for i in range(self.n)])</line-59>
<line-60> def __pow__(self, n):</line-60>
<line-61> if self.n != self.m:</line-61>
<line-62> raise NotSquareError()</line-62>
<line-63> if n == 0:</line-63>
<line-64> return self.primary()</line-64>
<line-65> elif n == 1:</line-65>
<line-66> return self</line-66>
<line-67> if len(self.degrees) == 0:</line-67>
<line-68> self.degrees.append(self*self)</line-68>
<line-69> for i in range(n.bit_length() - len(self.degrees) - 1):</line-69>
<line-70> self.degrees.append(self.degrees[-1] * self.degrees[-1])</line-70>
<line-71> s = [(n>>i)&1 for i in range(1,n.bit_length())]</line-71>
<line-72> res = functools.reduce(lambda x,y:x*y, itertools.compress(self.degrees, s))</line-72>
<line-73> return res*self if n%2 else res </line-73>
<line-74> def drop_degrees(self):</line-74>
<line-75> self.degrees.clear()</line-75>
<line-76></line-76>
<line-77>class Remainder(int):</line-77>
<line-78> def __new__(self, n, p):</line-78>
<line-79> obj = int.__new__(self, n%p)</line-79>
<line-80> obj.p = p</line-80>
<line-81> return obj</line-81>
<line-82> def __mul__(self, m): return Remainder(int.__mul__(self, m), self.p)</line-82>
<line-83> def __add__(self, m): return Remainder(int.__add__(self, m), self.p)</line-83>
<line-84> def __sub__(self, m): return Remainder(int.__sub__(self, m), self.p)</line-84>
<line-85> def __rmul__(self, m): return Remainder(int.__rmul__(self, m), self.p)</line-85>
<line-86> def __radd__(self, m): return Remainder(int.__radd__(self, m), self.p)</line-86>
<line-87> def __rsub__(self, m): return Remainder(int.__rsub__(self, m), self.p)</line-87>
<line-88> def __neg__(self): return Remainder(int.__neg__(self), self.p)</line-88>
<line-89> def __pow__(self, m): return Remainder(int.__pow__(self, m, self.p), self.p)</line-89>
<line-90></line-90>
<line-91>def solve(n, sx, sy, dx, dy, t):</line-91>
<line-92> o, l, j = Remainder(0, n), Remainder(1, n), Remainder(2, n)</line-92>
<line-93> N = [[j, l, l, o, l, o],</line-93>
<line-94> [l, j, o, l, l, o],</line-94>
<line-95> [l, l, l, o, l, o],</line-95>
<line-96> [l, l, o, l, l, o],</line-96>
<line-97> [o, o, o, o, l, l],</line-97>
<line-98> [o, o, o, o, o, l]]</line-98>
<line-99> M = Matrix(N)</line-99>
<line-100> sx, sy, dx, dy = [Remainder(x, n) for x in [sx, sy, dx, dy]]</line-100>
<line-101> v = Matrix([[sx], [sy], [dx], [dy], [o], [l]])</line-101>
<line-102> return M ** t * v</line-102>
<line-103></line-103>
<line-104>n, sx, sy, dx, dy, t = [int(x) for x in input().split()]</line-104>
<line-106>print(int(ans[0][0] - 1) + 1, int(ans[1][0] - 1) + 1)</line-106>
|
{"code": "<line-2>import functools</line-2>\n<line-105>ans = solve(n, sx, sy, dx, dy, t)</line-105>", "lines": [2, 105]}
#### 0
|
<line-1># You lost the game.</line-1>
<line-3>n = len(s)</line-3>
<line-4>A = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"</line-4>
<line-5>if n < 26:</line-5>
<line-6> print(-1)</line-6>
<line-7>else:</line-7>
<line-8> for i in range(n-25):</line-8>
<line-9> ok = 1</line-9>
<line-10> F = [0 for _ in range(26)]</line-10>
<line-11> for j in range(26):</line-11>
<line-12> if s[i:i+26].count(A[j]) > 1:</line-12>
<line-13> ok = 0</line-13>
<line-14> break</line-14>
<line-15> elif s[i:i+26].count(A[j]) == 0:</line-15>
<line-16> F[j] = 1</line-16>
<line-17> if ok:</line-17>
<line-18> break</line-18>
<line-19> if ok == 0:</line-19>
<line-20> print(-1)</line-20>
<line-21> else:</line-21>
<line-22> j = 0</line-22>
<line-23> for k in range(n):</line-23>
<line-24> if s[k] == "?":</line-24>
<line-25> if k >= i and k < i+26:</line-25>
<line-26> while F[j] == 0:</line-26>
<line-27> j += 1</line-27>
<line-28> print(A[j],end="")</line-28>
<line-29> F[j] = 0</line-29>
<line-30> else:</line-30>
<line-31> print("A",end="")</line-31>
<line-33> print(s[k],end="")</line-33>
<line-34> </line-34>
|
{"code": "<line-2>s = str(input())</line-2>\n<line-32> else:</line-32>", "lines": [2, 32]}
#### 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>class InputHandlerObject(object):</line-8>
<line-9> inputs = []</line-9>
<line-10></line-10>
<line-11> def getInput(self, n = 0):</line-11>
<line-12> res = ""</line-12>
<line-13> inputs = self.inputs</line-13>
<line-14> if not inputs: inputs.extend(input().split(" "))</line-14>
<line-15> if n == 0:</line-15>
<line-16> res = inputs[:]</line-16>
<line-17> inputs[:] = []</line-17>
<line-18> while n > len(inputs):</line-18>
<line-19> inputs.extend(input().split(" "))</line-19>
<line-20> if n > 0:</line-20>
<line-21> res = inputs[:n]</line-21>
<line-22> inputs[:n] = []</line-22>
<line-23> return res</line-23>
<line-24>InputHandler = InputHandlerObject()</line-24>
<line-25>g = InputHandler.getInput</line-25>
<line-26></line-26>
<line-27>############################## SOLUTION ##############################</line-27>
<line-28>n = int(input())</line-28>
<line-29>a = [int(x) for x in g()]</line-29>
<line-30>c100 = a.count(100)</line-30>
<line-31>if sum(a) % 200:</line-31>
<line-32> print("NO")</line-32>
<line-33>elif n % 2 and not c100:</line-33>
<line-34> print("NO")</line-34>
<line-36> print("YES")</line-36>
|
{"code": "<line-2>Codeforces Round 248 Div 2 Problem A</line-2>\n<line-35>else:</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>n, m = list(map(int, input().split()))</line-1>
<line-3>l = []</line-3>
<line-4>do = False</line-4>
<line-5>for i in range(n):</line-5>
<line-6> s = input().strip()</line-6>
<line-7> if s.find('1') != -1 or do:</line-7>
<line-8> do = True</line-8>
<line-9> l.append(s)</line-9>
<line-10>n = len(l)</line-10>
<line-11>if n == 0:</line-11>
<line-12> print(0)</line-12>
<line-13> return</line-13>
<line-14></line-14>
<line-15></line-15>
<line-16>dp = []</line-16>
<line-17>for i in range(n):</line-17>
<line-18> dp.append([None] * 2)</line-18>
<line-19></line-19>
<line-20>for i in range(n):</line-20>
<line-21> R = 0</line-21>
<line-22> for j in range(m):</line-22>
<line-23> if l[i][j] == '1':</line-23>
<line-24> R = j</line-24>
<line-25> L = m - 1</line-25>
<line-26> for j in range(m - 1, -1, -1):</line-26>
<line-27> if l[i][j] == '1':</line-27>
<line-28> L = j</line-28>
<line-29> if i == 0:</line-29>
<line-30> dp[0][0] = R</line-30>
<line-31> dp[0][1] = (m - 1 - L)</line-31>
<line-32> else:</line-32>
<line-33> dp[i][0] = min(dp[i - 1][0] + 2 * R, dp[i - 1][1] + (m - 1)) + 1</line-33>
<line-34> dp[i][1] = min(dp[i - 1][0] + (m - 1), dp[i - 1][1] + 2 * (m - 1 - L)) + 1</line-34>
<line-36>print(dp[-1][0])</line-36>
|
{"code": "<line-2>m += 2</line-2>\n<line-35># print(dp)</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>n = int(rd())</line-5>
<line-6>c = list(map(int, rd().split()))</line-6>
<line-7>a = list([int(x)-1 for x in rd().split()])</line-7>
<line-8></line-8>
<line-9>visited = [-1] * (n)</line-9>
<line-10>res = 0</line-10>
<line-11></line-11>
<line-12>for i in range(n):</line-12>
<line-13> trace = []</line-13>
<line-14> </line-14>
<line-15> t = i</line-15>
<line-16> mn = 1e9</line-16>
<line-17> while visited[t] == -1:</line-17>
<line-18> visited[t] = i</line-18>
<line-19> trace.append(t)</line-19>
<line-20> t = a[t]</line-20>
<line-21> </line-21>
<line-22> if visited[t] != i:</line-22>
<line-23> continue</line-23>
<line-24> </line-24>
<line-25> while len(trace) > 0:</line-25>
<line-26> v = trace.pop()</line-26>
<line-27> mn = min(mn, c[v]) </line-27>
<line-28> </line-28>
<line-29> if t == v: break</line-29>
<line-30> </line-30>
<line-32> </line-32>
<line-33>print(res)</line-33>
|
{"code": "<line-3>rd = lambda : sys.stdin.readline().rstrip()</line-3>\n<line-31> res += mn</line-31>", "lines": [3, 31]}
#### 0
|
<line-1>n, a, b = list(map(int, input().split()))</line-1>
<line-3>while ans < 0:</line-3>
<line-4> ans += n</line-4>
<line-5>ans %= n</line-5>
<line-6>if ans == 0:</line-6>
<line-7> print(n)</line-7>
<line-9> print(ans)</line-9>
|
{"code": "<line-2>ans = a + b</line-2>\n<line-8>else:</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>n = int(sys.stdin.readline())</line-4>
<line-5>if n <= 2:</line-5>
<line-6> print(1)</line-6>
<line-7> return</line-7>
<line-8></line-8>
<line-9>a = [int(s) for s in sys.stdin.readline().split()]</line-9>
<line-10></line-10>
<line-11>st = -1 # index of first positive number in current subset of a</line-11>
<line-12>ed = -1 # index last positive number in current subset of a </line-12>
<line-13> # differation is (a[ed] - a[st])/(ed - st)</line-13>
<line-14>leading_zeros = 0 # -1 before a[st]</line-14>
<line-15>seg_count = 1</line-15>
<line-16></line-16>
<line-17>for (i, v) in enumerate(a):</line-17>
<line-18> if v == -1:</line-18>
<line-19> if st == -1:</line-19>
<line-20> leading_zeros += 1</line-20>
<line-21> else:</line-21>
<line-22> if ed != -1:</line-22>
<line-23> # check if v should be a non-positive number</line-23>
<line-24> if a[ed] + (i-ed) * (a[ed] - a[st])/(ed-st) <= 0:</line-24>
<line-25> st = -1</line-25>
<line-26> ed = -1</line-26>
<line-27> leading_zeros = 1</line-27>
<line-28> seg_count += 1</line-28>
<line-29> else:</line-29>
<line-30> pass</line-30>
<line-31> else:</line-31>
<line-32> pass</line-32>
<line-33> else:</line-33>
<line-34> if st == -1:</line-34>
<line-35> st = i # find first positive number</line-35>
<line-36> else:</line-36>
<line-37> if ed == -1:</line-37>
<line-38> ed = i</line-38>
<line-39> #print(i)</line-39>
<line-40> if (v - a[st]) % (i-st) != 0 or a[st] - (v-a[st])/(i-st) * leading_zeros <= 0:</line-40>
<line-41> # a[st..i] can't be an arithmetic progression</line-41>
<line-42> st = i</line-42>
<line-43> ed = -1</line-43>
<line-44> seg_count += 1</line-44>
<line-45> leading_zeros = 0</line-45>
<line-46> else:</line-46>
<line-47> ed = i</line-47>
<line-48> else:</line-48>
<line-49> if (v-a[ed])%(i-ed) != 0 or (v-a[ed]) * (ed - st) != (a[ed] - a[st]) * (i-ed):</line-49>
<line-50> st = i</line-50>
<line-51> ed = -1</line-51>
<line-52> seg_count += 1</line-52>
<line-53> leading_zeros = 0</line-53>
<line-54> else:</line-54>
<line-55> ed = i #leave ed the first positive number after a[st] is also ok</line-55>
<line-57></line-57>
<line-58>print(seg_count)</line-58>
|
{"code": "<line-2>import math</line-2>\n<line-56> #print( \"[\" +str(st) + \" \" + str(ed) + \"] \" + str(seg_count) + \" \" + str(leading_zeros) )</line-56>", "lines": [2, 56]}
#### 0
|
<line-1>n, k = map(int,input().split())</line-1>
<line-3>maxi = 0</line-3>
<line-4>a = 0</line-4>
<line-5>b = 0</line-5>
<line-6>st = 0</line-6>
<line-7>for i in range(0, n):</line-7>
<line-8> if s[i] == 'a': a += 1</line-8>
<line-9> else: b+=1</line-9>
<line-10> if min(a, b) > k:</line-10>
<line-11> if s[st] == 'a': a-=1</line-11>
<line-12> else: b-=1</line-12>
<line-13> st += 1</line-13>
<line-15>print(maxi)</line-15>
|
{"code": "<line-2>s = input()</line-2>\n<line-14> else: maxi += 1</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>b = [0]</line-3>
<line-4>for i in range(1, n):</line-4>
<line-5> if a[i]*2 <= a[0]:</line-5>
<line-6> b += [i]</line-6>
<line-7>u=0</line-7>
<line-8>v=0</line-8>
<line-9>for i in range(n):</line-9>
<line-10> if i in b:</line-10>
<line-11> u += a[i]</line-11>
<line-12> else:</line-12>
<line-13> v += a[i]</line-13>
<line-14>if u > v:</line-14>
<line-15> print(len(b))</line-15>
<line-16> for x in b:</line-16>
<line-17> print(x+1, end=' ')</line-17>
<line-19> print('0')</line-19>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-18>else:</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>for i in range(n):</line-3>
<line-5>print(tot)</line-5>
|
{"code": "<line-2>tot=0</line-2>\n<line-4> tot+=1/(i+1)</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>nxt = 1</line-3>
<line-4>while n > 0:</line-4>
<line-5> x = nxt</line-5>
<line-6> n -= nxt</line-6>
<line-7> nxt += 1</line-7>
<line-8> if n < nxt:</line-8>
<line-9> x += n</line-9>
<line-10> n = 0</line-10>
<line-11> ans.append(str(x))</line-11>
<line-13>print(" ".join(ans))</line-13>
|
{"code": "<line-2>ans = []</line-2>\n<line-12>print(len(ans))</line-12>", "lines": [2, 12]}
#### 0
|
<line-2>m = int(input())</line-2>
<line-3></line-3>
<line-4>print(m % (1 << n))</line-4>
|
{"code": "<line-1>n = int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>t = []</line-3>
<line-4>vowels = 'aeiouy'</line-4>
<line-5>for c in s:</line-5>
<line-6> if t and t[-1] in vowels and c in vowels:</line-6>
<line-7> continue</line-7>
<line-8> else:</line-8>
<line-10>print(''.join(t))</line-10>
|
{"code": "<line-2>s = input()</line-2>\n<line-9> t.append(c)</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>n, a, b = list(map(int, input().split()))</line-1>
<line-3>s += '*'</line-3>
<line-4>n += 1</line-4>
<line-5>m = []</line-5>
<line-6>i = 0</line-6>
<line-7>i1 = -1</line-7>
<line-8>while i < len(s):</line-8>
<line-9> if s[i] == '*':</line-9>
<line-10> if i - i1 > 1:</line-10>
<line-11> m.append(i - i1 - 1)</line-11>
<line-12> i1 = i</line-12>
<line-13> i += 1</line-13>
<line-14>sm = a + b</line-14>
<line-15>for c in m:</line-15>
<line-16> if c % 2 == 0:</line-16>
<line-17> a = max(0, a - c // 2)</line-17>
<line-18> b = max(0, b - c // 2)</line-18>
<line-19> else:</line-19>
<line-20> if a > b:</line-20>
<line-21> a = max(0, a - (c + 1) // 2)</line-21>
<line-22> b = max(0, b - c // 2)</line-22>
<line-23> else:</line-23>
<line-24> b = max(0, b - (c + 1) // 2)</line-24>
<line-26>print(sm - a - b)</line-26>
|
{"code": "<line-2>s = input()</line-2>\n<line-25> a = max(0, a - c // 2)</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>r=int(input())</line-1>
<line-3> print("NO")</line-3>
<line-4>elif r%2==0:</line-4>
<line-5> print("NO")</line-5>
<line-7> print(1, (r-3)//2)</line-7>
|
{"code": "<line-2>if r<=4:</line-2>\n<line-6>else :</line-6>", "lines": [2, 6]}
#### 0
|
<line-1></line-1>
<line-2></line-2>
<line-3>n = int(input())</line-3>
<line-4></line-4>
<line-6></line-6>
<line-7>if n < 2 or (n == 2 and tab[0] == tab[1]):</line-7>
<line-8> print(-1)</line-8>
<line-9>else:</line-9>
<line-11> print(tab.index(min(tab)) + 1)</line-11>
<line-12></line-12>
|
{"code": "<line-5>tab = [int(x) for x in input().split()]</line-5>\n<line-10> print(1)</line-10>", "lines": [5, 10]}
#### 0
|
<line-1>import getpass</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>def ria():</line-5>
<line-6> return [int(i) for i in input().split()]</line-6>
<line-7></line-7>
<line-8></line-8>
<line-9>if getpass.getuser() != 'frohenk':</line-9>
<line-10> filename = 'half'</line-10>
<line-11> # sys.stdin = open('input.txt')</line-11>
<line-12> # sys.stdout = open('output.txt', 'w')</line-12>
<line-13>else:</line-13>
<line-14> sys.stdin = open('input.txt')</line-14>
<line-15> # sys.stdin.close()</line-15>
<line-16></line-16>
<line-17>n = ria()[0]</line-17>
<line-19>print('1 '*n)</line-19>
|
{"code": "<line-2>import sys</line-2>\n<line-18>print(n)</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>def main():</line-1>
<line-3> l = list(map(int, input().split()))</line-3>
<line-4> seive = [False, True] * max(l)</line-4>
<line-5> a = len(seive)</line-5>
<line-6> for i in range(3, int(a ** .5) + 1, 2):</line-6>
<line-7> if seive[i]:</line-7>
<line-8> for j in range(i * i, a, i):</line-8>
<line-9> seive[j] = False</line-9>
<line-10> i = l.count(1)</line-10>
<line-11> if i:</line-11>
<line-12> res = [1] * i</line-12>
<line-13> for a in l:</line-13>
<line-14> if a > 1 and seive[a + 1]:</line-14>
<line-15> res.append(a)</line-15>
<line-16> break</line-16>
<line-17> if len(res) > 1:</line-17>
<line-18> print(len(res))</line-18>
<line-19> print(*res)</line-19>
<line-20> return</line-20>
<line-21> l0, l1 = [], []</line-21>
<line-22> for a in l:</line-22>
<line-23> if a != 1:</line-23>
<line-24> if a & 1:</line-24>
<line-25> for b in l0:</line-25>
<line-26> if seive[a + b]:</line-26>
<line-27> print(2)</line-27>
<line-28> print(a, b)</line-28>
<line-29> return</line-29>
<line-30> l1.append(a)</line-30>
<line-31> else:</line-31>
<line-32> for b in l1:</line-32>
<line-33> if seive[a + b]:</line-33>
<line-34> print(2)</line-34>
<line-35> print(a, b)</line-35>
<line-36> return</line-36>
<line-37> l0.append(a)</line-37>
<line-38> print(1)</line-38>
<line-39> print(l[0])</line-39>
<line-40></line-40>
<line-41></line-41>
<line-42>def __starting_point():</line-42>
<line-44></line-44>
<line-45>__starting_point()</line-45>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-43> main()</line-43>", "lines": [2, 43]}
#### 0
|
<line-1>from collections import Counter, defaultdict</line-1>
<line-3>import sys</line-3>
<line-4></line-4>
<line-5>def main():</line-5>
<line-6> n = int(input())</line-6>
<line-7> ans = 1</line-7>
<line-8> for k in range(1, 10):</line-8>
<line-9> v = ((1 << k) - 1) * (1 << (k - 1))</line-9>
<line-10> if n % v == 0:</line-10>
<line-11> ans = v</line-11>
<line-12></line-12>
<line-14></line-14>
<line-15>main()</line-15>
|
{"code": "<line-2>import itertools</line-2>\n<line-13> print(ans)</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>#!/usr/bin/env python3</line-1>
<line-2></line-2>
<line-3></line-3>
<line-4></line-4>
<line-6> res = left + right</line-6>
<line-7> if res >= modulo:</line-7>
<line-8> res -= modulo</line-8>
<line-9> return res</line-9>
<line-10></line-10>
<line-11>def counter(a, m, d):</line-11>
<line-12> res = [0, ] * (2*m)</line-12>
<line-13> res[0] = 1</line-13>
<line-14> shift = 1</line-14>
<line-15> for pos in range(len(a), 0, -1):</line-15>
<line-16> ptype = pos & 1</line-16>
<line-17> cur = int(a[pos-1])</line-17>
<line-18> tres = [0, ] * (2*m)</line-18>
<line-19> for i in range(10):</line-19>
<line-20> if ptype==1 and i == d:</line-20>
<line-21> continue</line-21>
<line-22> if ptype==0 and i != d:</line-22>
<line-23> continue</line-23>
<line-24> k = (i * shift) % m</line-24>
<line-25> for j in range(m):</line-25>
<line-26> k2 = k*2</line-26>
<line-27> j2 = j*2</line-27>
<line-28> if i < cur:</line-28>
<line-29> tres[k2+0] = addmod(tres[k2+0], addmod(res[j2+0], res[j2+1]))</line-29>
<line-30> elif i == cur:</line-30>
<line-31> tres[k2+0] = addmod(tres[k2+0], res[j2+0])</line-31>
<line-32> tres[k2+1] = addmod(tres[k2+1], res[j2+1])</line-32>
<line-33> else:</line-33>
<line-34> tres[k2+1] = addmod(tres[k2+1], addmod(res[j2+0], res[j2+1]))</line-34>
<line-35> k = k+1 if k+1<m else 0</line-35>
<line-36> res = tres</line-36>
<line-37> shift = (shift * 10) % m</line-37>
<line-38> return res[0]</line-38>
<line-39></line-39>
<line-40></line-40>
<line-41>def solver(ifs):</line-41>
<line-42> m, d = list(map(int, ifs.readline().split()))</line-42>
<line-43> a = ifs.readline().strip()</line-43>
<line-44> b = ifs.readline().strip()</line-44>
<line-45> res = counter(b, m, d)</line-45>
<line-46> if a != '0':</line-46>
<line-47> a = str(int(a) - 1)</line-47>
<line-48> if len(a) < len(b):</line-48>
<line-49> a = '0' + a</line-49>
<line-50> modulo = 1000000007</line-50>
<line-51> res = addmod(res, modulo - counter(a, m, d))</line-51>
<line-52> print(res)</line-52>
<line-53></line-53>
<line-54>def main():</line-54>
<line-55> import sys</line-55>
<line-56> if sys.version_info.major == 3:</line-56>
<line-57> from io import StringIO as StreamIO</line-57>
<line-58> else:</line-58>
<line-59> from io import BytesIO as StreamIO</line-59>
<line-60> </line-60>
<line-61> with StreamIO(sys.stdin.read()) as ifs, StreamIO() as ofs:</line-61>
<line-62> _stdout = sys.stdout</line-62>
<line-63> sys.stdout = ofs</line-63>
<line-64> solver(ifs)</line-64>
<line-65> sys.stdout = _stdout</line-65>
<line-66> sys.stdout.write(ofs.getvalue())</line-66>
<line-67> return 0</line-67>
<line-68></line-68>
<line-69>def __starting_point():</line-69>
<line-71></line-71>
<line-72>__starting_point()</line-72>
|
{"code": "<line-5>def addmod(left, right, modulo=1000000007):</line-5>\n<line-70> main()</line-70>", "lines": [5, 70]}
#### 0
|
<line-1>def main():</line-1>
<line-3> </line-3>
<line-4> n, m = [int(i) for i in input().split()]</line-4>
<line-5> children = deque([0, int(v), i + 1] for i, v in enumerate(input().split()))</line-5>
<line-6> </line-6>
<line-7> while len(children) > 1:</line-7>
<line-8> tmp = children.popleft()</line-8>
<line-9> tmp[0] += m</line-9>
<line-10> if tmp[1] > tmp[0]:</line-10>
<line-11> children.append(tmp)</line-11>
<line-12> </line-12>
<line-14></line-14>
<line-15></line-15>
<line-16>main()</line-16>
|
{"code": "<line-2> from collections import deque</line-2>\n<line-13> print(children.popleft()[2])</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>ans+=n//100</line-3>
<line-4>n%=100</line-4>
<line-5>ans+=n//20</line-5>
<line-6>n%=20</line-6>
<line-7>ans+=n//10</line-7>
<line-8>n%=10</line-8>
<line-9>ans+=n//5</line-9>
<line-10>n%=5</line-10>
<line-12>print(ans)</line-12>
|
{"code": "<line-2>ans=0</line-2>\n<line-11>ans+=n</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>mod=10**9+7</line-1>
<line-3></line-3>
<line-4>A=[0]*(n+1)</line-4>
<line-5>B=[0]*(n+1)</line-5>
<line-6>C=[0]*(n+1)</line-6>
<line-7>F=[0]*(n+1)</line-7>
<line-8>G=[0]*(n+1)</line-8>
<line-9></line-9>
<line-10>F[0]=G[0]=1</line-10>
<line-11>for i in range(1,n+1):</line-11>
<line-12> G[i]=F[i]=F[i-1]*i%mod</line-12>
<line-13> G[i]=pow(F[i],(mod-2),mod)</line-13>
<line-14></line-14>
<line-15>for i in range(0,n):</line-15>
<line-16> if i*2>n:</line-16>
<line-17> break</line-17>
<line-18> B[i]=(F[n-i]*G[i]*G[n-i*2])%mod</line-18>
<line-19>for i in range(0,n//2+1):</line-19>
<line-20> for j in range(0,n//2+1):</line-20>
<line-21> A[i+j]=(A[i+j]+B[i]*B[j])%mod</line-21>
<line-22>for i in range(0,n+1):</line-22>
<line-23> A[i]=A[i]*F[n-i]%mod</line-23>
<line-24>for i in range(0,n+1):</line-24>
<line-25> for j in range(0,i+1):</line-25>
<line-27>print(C[k]%mod)</line-27>
|
{"code": "<line-2>n,k=list(map(int,input().split()))</line-2>\n<line-26>\t\tC[j]=(C[j]+A[i]*F[i]*G[j]*G[i-j]*(1-(i-j)%2*2))%mod</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>n,k = list(map(int, input().split()))</line-1>
<line-3></line-3>
<line-4>SSSSSSSSSS = input()</line-4>
<line-5></line-5>
<line-6>INF = 1000*1000*1000+123</line-6>
<line-7>RRRR = [];</line-7>
<line-8>WWWWWWW = [];</line-8>
<line-9>OOOOOOOOO = [];</line-9>
<line-10></line-10>
<line-11>for i in range(n):</line-11>
<line-12> if SSSSSSSSSS[i] == 'R':</line-12>
<line-13> RRRR.append(b[i])</line-13>
<line-14> elif SSSSSSSSSS[i] == 'W':</line-14>
<line-15> WWWWWWW.append(b[i])</line-15>
<line-16> else:</line-16>
<line-17> OOOOOOOOO.append(b[i])</line-17>
<line-18></line-18>
<line-19></line-19>
<line-20></line-20>
<line-21>WWWWWWW.sort()</line-21>
<line-22></line-22>
<line-23>RRRR.sort()</line-23>
<line-24>WWWWWWW.reverse()</line-24>
<line-25>RRRR.reverse()</line-25>
<line-26>OOOOOOOOO.sort()</line-26>
<line-27>OOOOOOOOO.reverse()</line-27>
<line-28></line-28>
<line-29>if k == 1:</line-29>
<line-30> print(-1)</line-30>
<line-31> return</line-31>
<line-32></line-32>
<line-33></line-33>
<line-34>def cccmcmc(A, B):</line-34>
<line-35> qanakA = len(A);</line-35>
<line-36> qanakB = len(B);</line-36>
<line-37></line-37>
<line-38> pA = [0 for i in range(qanakA)]</line-38>
<line-39> pB = [0 for i in range(qanakB)]</line-39>
<line-40> pB[0] = B[0]</line-40>
<line-41> pA[0] = A[0]</line-41>
<line-42></line-42>
<line-43> for i in range(1,qanakA):</line-43>
<line-44> pA[i] = pA[i-1] + A[i];</line-44>
<line-45> for i in range(1,qanakB):</line-45>
<line-46> pB[i] = pB[i-1] + B[i];</line-46>
<line-47></line-47>
<line-48> res = -1</line-48>
<line-49></line-49>
<line-50> for i in range(1,min(qanakA+1,k)):</line-50>
<line-51> aic = pA[i-1]</line-51>
<line-52> bepetk = k-i</line-52>
<line-53> if bepetk <= 0 or bepetk > qanakB: continue</line-53>
<line-54> bic = pB[bepetk-1]</line-54>
<line-55> res = max(res,aic+bic)</line-55>
<line-56> return res</line-56>
<line-57></line-57>
<line-58></line-58>
<line-59>res = -1</line-59>
<line-60></line-60>
<line-61>if len(WWWWWWW) > 0 and len(OOOOOOOOO)> 0:</line-61>
<line-62> res = max(res, cccmcmc(WWWWWWW, OOOOOOOOO))</line-62>
<line-63>if len(RRRR) > 0 and len(OOOOOOOOO)> 0:</line-63>
<line-65></line-65>
<line-66>print(res)</line-66>
|
{"code": "<line-2>b = list(map(int,input().split()))</line-2>\n<line-64> res = max(res, cccmcmc(RRRR, OOOOOOOOO))</line-64>", "lines": [2, 64]}
#### 0
|
<line-1>#!/usr/bin/env python3</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>def __starting_point():</line-5>
<line-6> p, q = list(map(int, input().split()))</line-6>
<line-7> n = int(input())</line-7>
<line-8> l = list(map(int, input().split()))</line-8>
<line-9></line-9>
<line-10> f = Fraction(l[-1], 1)</line-10>
<line-11></line-11>
<line-12> for x in l[-2::-1]:</line-12>
<line-13> f = 1 / f</line-13>
<line-14> f += x</line-14>
<line-15></line-15>
<line-17></line-17>
<line-18></line-18>
<line-19></line-19>
<line-20>__starting_point()</line-20>
|
{"code": "<line-3>from fractions import Fraction</line-3>\n<line-16> print([\"NO\", \"YES\"][f == Fraction(p, q)])</line-16>", "lines": [3, 16]}
#### 0
|
<line-1>t = input()</line-1>
<line-3>n = 2 * k - len(t)</line-3>
<line-4>if n == 2:</line-4>
<line-5> if t[1] != '+': t = t[1: ] + '|'</line-5>
<line-6> else: t = t[: k - 1] + t[k: ] + '|'</line-6>
<line-7>elif n == -2: t = '|' + t[: -1]</line-7>
<line-9>print(t)</line-9>
|
{"code": "<line-2>k = t.find('=')</line-2>\n<line-8>elif n != 0: t = 'Impossible'</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>import numpy as np</line-1>
<line-2></line-2>
<line-3></line-3>
<line-5> if k % 2 == 1:</line-5>
<line-6> return 0</line-6>
<line-7> k //= 2</line-7>
<line-8></line-8>
<line-9> MOD = 10 ** 9 + 7</line-9>
<line-10></line-10>
<line-11> dp = np.zeros((1, k + 1), dtype=np.int64)</line-11>
<line-12> dp[0, 0] = 1</line-12>
<line-13> for i in range(1, n + 1):</line-13>
<line-14> max_d = min(i + 1, n - i + 1, k + 1)</line-14>
<line-15> ndp = np.zeros((max_d, k + 1), dtype=np.int64)</line-15>
<line-16> for d, ks in enumerate(dp):</line-16>
<line-17> base = ks[:k - d + 1]</line-17>
<line-18> if d > 0:</line-18>
<line-19> ndp[d - 1, d:] += base * d ** 2</line-19>
<line-20> if max_d > d:</line-20>
<line-21> ndp[d, d:] += base * (2 * d + 1)</line-21>
<line-22> if max_d > d + 1:</line-22>
<line-23> ndp[d + 1, d:] += base</line-23>
<line-24> dp = ndp % MOD</line-24>
<line-25></line-25>
<line-26> return dp[0, k]</line-26>
<line-27></line-27>
<line-28></line-28>
<line-30>print((solve(n, k)))</line-30>
|
{"code": "<line-4>def solve(n, k):</line-4>\n<line-29>n, k = list(map(int, input().split()))</line-29>", "lines": [4, 29]}
#### 0
|
<line-1>N = int(input())</line-1>
<line-3></line-3>
<line-4>odd = []</line-4>
<line-5>for (x, y) in P:</line-5>
<line-6> dist = abs(x) + abs(y)</line-6>
<line-7> odd.append(dist % 2 != 0)</line-7>
<line-8></line-8>
<line-9>valid = True</line-9>
<line-10>even = False</line-10>
<line-11>if all(odd):</line-11>
<line-12> pass</line-12>
<line-13>elif not any(odd):</line-13>
<line-14> even = True</line-14>
<line-15>else:</line-15>
<line-16> valid =False</line-16>
<line-17></line-17>
<line-18>if valid:</line-18>
<line-19></line-19>
<line-20> M = 31</line-20>
<line-21> if even:</line-21>
<line-22> print((M+1))</line-22>
<line-23> print((*([1 << m for m in range(M)] + [1])))</line-23>
<line-24> else:</line-24>
<line-25> print(M)</line-25>
<line-26> print((*[1 << m for m in range(M)]))</line-26>
<line-27></line-27>
<line-28> for (x, y) in P:</line-28>
<line-29> u = x + y</line-29>
<line-30> v = x - y</line-30>
<line-31> if even:</line-31>
<line-32> u += 1</line-32>
<line-33> v += 1</line-33>
<line-34> if u >= 0 and v >= 0:</line-34>
<line-35> A = 'R'</line-35>
<line-36> B = 'U'</line-36>
<line-37> C = 'D'</line-37>
<line-38> D = 'L'</line-38>
<line-39> elif u >= 0 and v < 0:</line-39>
<line-40> v *= -1</line-40>
<line-41> A = 'U'</line-41>
<line-42> B = 'R'</line-42>
<line-43> C = 'L'</line-43>
<line-44> D = 'D'</line-44>
<line-45> elif u < 0 and v >= 0:</line-45>
<line-46> u *= -1</line-46>
<line-47> A = 'D'</line-47>
<line-48> B = 'L'</line-48>
<line-49> C = 'R'</line-49>
<line-50> D = 'U'</line-50>
<line-51> elif u < 0 and v < 0:</line-51>
<line-52> u *= -1</line-52>
<line-53> v *= -1</line-53>
<line-54> A = 'L'</line-54>
<line-55> B = 'D'</line-55>
<line-56> C = 'U'</line-56>
<line-57> D = 'R'</line-57>
<line-58></line-58>
<line-59> ans = ''</line-59>
<line-60> wa = ((1 << M) - 1 - u) // 2</line-60>
<line-61> sa = ((1 << M) - 1 - v) // 2</line-61>
<line-62> for i in range(M):</line-62>
<line-63> check = str(wa >> i & 1) + str(sa >> i & 1)</line-63>
<line-64> if check == '00':</line-64>
<line-65> ans += A</line-65>
<line-66> elif check == '01':</line-66>
<line-67> ans += B</line-67>
<line-68> elif check == '10':</line-68>
<line-69> ans += C</line-69>
<line-70> elif check == '11':</line-70>
<line-71> ans += D</line-71>
<line-72> if even:</line-72>
<line-73> ans += 'L'</line-73>
<line-74> print(ans)</line-74>
<line-76> print((-1))</line-76>
|
{"code": "<line-2>P = [tuple(map(int, input().split())) for _ in range(N)]</line-2>\n<line-75>else:</line-75>", "lines": [2, 75]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.