question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-2></line-2>
<line-3>for _ in range(n):</line-3>
<line-4> a, b, c = list(map(int, input().split()))</line-4>
<line-5></line-5>
<line-6> print(min((a+b+c)//2, a+b, a+c, b+c))</line-6>
|
{"code": "<line-1>n = int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>import os</line-1>
<line-3></line-3>
<line-4># input = BytesIO(os.read(0, os.fstat(0).st_size)).readline</line-4>
<line-5>for i in range(int(input())):</line-5>
<line-6> a, b, c, r = list(map(int, input().split()))</line-6>
<line-7> a, b = min(a, b), max(a, b)</line-7>
<line-8> left = max(c - r, a)</line-8>
<line-9> right = min(c + r, b)</line-9>
<line-10> if right >= a and left <= right:</line-10>
<line-11> print(b - a - (right - left))</line-11>
<line-13> print(b - a)</line-13>
|
{"code": "<line-2>from io import BytesIO</line-2>\n<line-12> else:</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>s = []</line-1>
<line-3> k = 0</line-3>
<line-4> for l in range(1, 10):</line-4>
<line-5> k *= 10</line-5>
<line-6> k += i</line-6>
<line-7> s.append(k)</line-7>
<line-8>s.sort()</line-8>
<line-9>q = int(input())</line-9>
<line-10>while q:</line-10>
<line-11> n = int(input())</line-11>
<line-12> l = 0</line-12>
<line-13> r = len(s)</line-13>
<line-14> while l + 1 < r:</line-14>
<line-15> m = (l + r) // 2</line-15>
<line-16> if s[m] <= n:</line-16>
<line-17> l = m</line-17>
<line-18> else:</line-18>
<line-19> r = m</line-19>
<line-21> q -= 1</line-21>
|
{"code": "<line-2>for i in range(1, 10):</line-2>\n<line-20> print(r)</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> n, m = [int(x) for x in input().split()]</line-4>
<line-5> grid = [[int(x) for x in input().split()] for _ in range(n)]</line-5>
<line-6></line-6>
<line-7> rows = sum(1 for x in grid if all(y == 0 for y in x))</line-7>
<line-8> cols = sum(1 for j in range(m) if all(grid[i][j] == 0 for i in range(n)))</line-8>
<line-9></line-9>
<line-11></line-11>
<line-12> print("Ashish" if res % 2 else "Vivek")</line-12>
|
{"code": "<line-3>for _ in range(t):</line-3>\n<line-10> res = min(rows, cols)</line-10>", "lines": [3, 10]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-3>q = int(input())</line-3>
<line-4>for rwerew in range(q):</line-4>
<line-5> n = int(input())</line-5>
<line-6> p = list(map(int,input().split()))</line-6>
<line-7> c = list(map(int,input().split()))</line-7>
<line-8> for i in range(n):</line-8>
<line-9> p[i] -= 1</line-9>
<line-10> przyn = [0] * n</line-10>
<line-11> grupa = []</line-11>
<line-12> i = 0</line-12>
<line-13> while i < n:</line-13>
<line-14> if przyn[i] == 1:</line-14>
<line-15> i += 1</line-15>
<line-16> else:</line-16>
<line-17> nowa_grupa = [i]</line-17>
<line-18> j = p[i]</line-18>
<line-19> przyn[i] = 1</line-19>
<line-20> while j != i:</line-20>
<line-21> przyn[j] = 1</line-21>
<line-22> nowa_grupa.append(j)</line-22>
<line-23> j = p[j]</line-23>
<line-24> grupa.append(nowa_grupa)</line-24>
<line-25> grupacol = []</line-25>
<line-26> for i in grupa:</line-26>
<line-27> cyk = []</line-27>
<line-28> for j in i:</line-28>
<line-29> cyk.append(c[j])</line-29>
<line-30> grupacol.append(cyk)</line-30>
<line-31> #print(grupacol)</line-31>
<line-32> mini = 234283742834</line-32>
<line-33> for cykl in grupacol:</line-33>
<line-34> dziel = []</line-34>
<line-35> d = 1</line-35>
<line-36> while d**2 <= len(cykl):</line-36>
<line-37> if len(cykl)%d == 0:</line-37>
<line-38> dziel.append(d)</line-38>
<line-39> d += 1</line-39>
<line-40> dodat = []</line-40>
<line-41> for d in dziel:</line-41>
<line-42> dodat.append(len(cykl)/d)</line-42>
<line-43> dziel_ost = list(map(int,dziel + dodat))</line-43>
<line-44> #print(dziel_ost, len(cykl))</line-44>
<line-45> for dzielnik in dziel_ost:</line-45>
<line-46> for i in range(dzielnik):</line-46>
<line-47> indeks = i</line-47>
<line-48> secik = set()</line-48>
<line-49> chuj = True</line-49>
<line-50> while indeks < len(cykl):</line-50>
<line-51> secik.add(cykl[indeks])</line-51>
<line-52> indeks += dzielnik</line-52>
<line-53> if len(secik) > 1:</line-53>
<line-54> chuj = False</line-54>
<line-55> break</line-55>
<line-56> if chuj:</line-56>
<line-58> print(mini)</line-58>
<line-59> </line-59>
|
{"code": "<line-2>input = stdin.readline</line-2>\n<line-57>\t\t\t\t\tmini = min(mini, dzielnik)</line-57>", "lines": [2, 57]}
#### 0
|
<line-1>import math</line-1>
<line-3>for test in range(t):</line-3>
<line-4> n,k = map(int,input().split())</line-4>
<line-5> A = list(map(int,input().split()))</line-5>
<line-6> A.sort()</line-6>
<line-7> ans = 0</line-7>
<line-8> for i in range(1,n):</line-8>
<line-9> if(A[i]>k):</line-9>
<line-10> ans = 0</line-10>
<line-11> break</line-11>
<line-12> rem = k-A[i]</line-12>
<line-14> print(ans)</line-14>
|
{"code": "<line-2>t = int(input())</line-2>\n<line-13> ans+=rem//A[0]</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> n = int(input())</line-4>
<line-5></line-5>
<line-6> lri = [None for _ in range(n)]</line-6>
<line-7></line-7>
<line-8> for _ in range(n):</line-8>
<line-9> li, ri = list(map(int, input().split()))</line-9>
<line-10> lri[_] = (li, ri, _)</line-10>
<line-11></line-11>
<line-12> lri.sort()</line-12>
<line-13></line-13>
<line-14> t = [None for _ in range(n)]</line-14>
<line-15></line-15>
<line-16> ct, t[lri[0][2]], eg = 1, 1, lri[0][1]</line-16>
<line-17></line-17>
<line-18> for i in range(1, n):</line-18>
<line-19> if lri[i][0] <= eg:</line-19>
<line-20> t[lri[i][2]] = ct</line-20>
<line-21> eg = max(eg, lri[i][1])</line-21>
<line-22> else:</line-22>
<line-23> ct = 3 - ct</line-23>
<line-24> t[lri[i][2]] = ct</line-24>
<line-25> eg = lri[i][1]</line-25>
<line-26></line-26>
<line-27> if all(ti == 1 for ti in t):</line-27>
<line-28> print(-1)</line-28>
<line-30> print(*t)</line-30>
|
{"code": "<line-3>for ti in range(t):</line-3>\n<line-29>\telse:</line-29>", "lines": [3, 29]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> a, b, c, d = [int(i) for i in input().split(" ")]</line-3>
<line-4> sgn = (a+b)%2</line-4>
<line-5> small = False</line-5>
<line-6> large = False</line-6>
<line-7> if a == 0 and d == 0:</line-7>
<line-8> small = True</line-8>
<line-9> if b == 0 and c == 0:</line-9>
<line-10> large = True</line-10>
<line-11> okay = [True] * 4</line-11>
<line-12> if sgn == 0:</line-12>
<line-13> okay[0] = False</line-13>
<line-14> okay[1] = False</line-14>
<line-15> else:</line-15>
<line-16> okay[2] = False</line-16>
<line-17> okay[3] = False</line-17>
<line-18> if small:</line-18>
<line-19> okay[0] = False</line-19>
<line-20> okay[3] = False</line-20>
<line-21> if large:</line-21>
<line-22> okay[1] = False</line-22>
<line-24> print(" ".join(["Ya" if okay[i] else "Tidak" for i in range(4)]))</line-24>
|
{"code": "<line-2>for _ in range(t):</line-2>\n<line-23> okay[2] = False</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> li=list(map(int,input().split()))</line-3>
<line-4> ans=0</line-4>
<line-5> for i in range(n):</line-5>
<line-6> if li[i]>=i:</line-6>
<line-7> ans+=1</line-7>
<line-8> else:</line-8>
<line-9> break</line-9>
<line-10> for i in range(n):</line-10>
<line-11> if li[n-1-i]>=i:</line-11>
<line-12> ans+=1</line-12>
<line-13> else:</line-13>
<line-14> break</line-14>
<line-15> if ans>n:</line-15>
<line-16> print("Yes")</line-16>
<line-18> print("No")</line-18>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-17> else:</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from collections import defaultdict</line-3>
<line-4>from collections import deque</line-4>
<line-5>from itertools import combinations</line-5>
<line-6>from itertools import permutations</line-6>
<line-7>input = lambda : sys.stdin.readline().rstrip()</line-7>
<line-8>read = lambda : list(map(int, input().split()))</line-8>
<line-9>go = lambda : 1/0</line-9>
<line-10>def write(*args, sep="\n"):</line-10>
<line-11> for i in args:</line-11>
<line-12> sys.stdout.write("{}{}".format(i, sep))</line-12>
<line-13>INF = float('inf')</line-13>
<line-14>MOD = int(1e9 + 7)</line-14>
<line-15>YES = "YES"</line-15>
<line-16>NO = -1</line-16>
<line-17></line-17>
<line-18>for _ in range(int(input())):</line-18>
<line-19> try:</line-19>
<line-20> n, m = read()</line-20>
<line-21> arr = read()</line-21>
<line-22> x = [0] * 65</line-22>
<line-23> </line-23>
<line-24> if sum(arr) < n:</line-24>
<line-25> print(NO)</line-25>
<line-26> go()</line-26>
<line-27> </line-27>
<line-28> for i in arr:</line-28>
<line-29> x[int(math.log2(i))] += 1</line-29>
<line-30> </line-30>
<line-31> ans = 0</line-31>
<line-32> for i in range(65):</line-32>
<line-33> if (1 << i) & n:</line-33>
<line-34> if x[i] != 0:</line-34>
<line-35> x[i] -= 1</line-35>
<line-36> continue </line-36>
<line-37></line-37>
<line-38> total = 0</line-38>
<line-39> for j in range(i):</line-39>
<line-40> total += (1 << j) * x[j]</line-40>
<line-41> </line-41>
<line-42> if total >= (1 << i):</line-42>
<line-43> temp = 1 << i </line-43>
<line-44> for j in reversed(range(i)):</line-44>
<line-45> while temp - (1 << j) >= 0 and x[j] > 0:</line-45>
<line-46> temp -= 1 << j </line-46>
<line-47> x[j] -= 1</line-47>
<line-48> continue </line-48>
<line-49> </line-49>
<line-50> j = i</line-50>
<line-51> while j < 65 and x[j] == 0:</line-51>
<line-52> j += 1</line-52>
<line-53> if j == 65:</line-53>
<line-54> print(NO)</line-54>
<line-55> go() </line-55>
<line-56> else:</line-56>
<line-57> x[j] -= 1</line-57>
<line-58> for k in range(i, j):</line-58>
<line-59> x[k] += 1</line-59>
<line-60> ans += (j - i)</line-60>
<line-61> </line-61>
<line-62> print(ans)</line-62>
<line-63></line-63>
<line-64></line-64>
<line-65> except ZeroDivisionError:</line-65>
<line-66> continue</line-66>
<line-67></line-67>
<line-68> except Exception as e:</line-68>
<line-70> continue</line-70>
|
{"code": "<line-2>import math</line-2>\n<line-69> print(e)</line-69>", "lines": [2, 69]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> arr = list(map(int, input().split()))</line-3>
<line-4></line-4>
<line-5> peaks = [0 for i in range(n)]</line-5>
<line-6> for i in range(1, n - 1):</line-6>
<line-7> if arr[i] > arr[i - 1] and arr[i] > arr[i + 1]:</line-7>
<line-8> peaks[i] = 1</line-8>
<line-9></line-9>
<line-10> cnt = 0</line-10>
<line-11> max_peaks = 0</line-11>
<line-12> answer = 0</line-12>
<line-13></line-13>
<line-14> for i in range(k - 1):</line-14>
<line-15> cnt += peaks[i]</line-15>
<line-16> max_peaks += peaks[i]</line-16>
<line-17></line-17>
<line-18> for i in range(k - 1, n - 1):</line-18>
<line-19> cnt -= peaks[i - k + 2]</line-19>
<line-20> cnt += peaks[i]</line-20>
<line-21> if cnt > max_peaks:</line-21>
<line-22> max_peaks = cnt</line-22>
<line-24></line-24>
<line-25> print(max_peaks + 1, answer + 1)</line-25>
|
{"code": "<line-2> n, k = tuple(map(int, input().split()))</line-2>\n<line-23> answer = i - k + 2</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>#!/usr/bin/env python</line-1>
<line-3># Copyright (C) dirlt</line-3>
<line-4></line-4>
<line-5>from sys import stdin</line-5>
<line-6></line-6>
<line-7></line-7>
<line-8>def run(n, m, pixels):</line-8>
<line-9> ans = 1 << 30</line-9>
<line-10></line-10>
<line-11> acc = [[0] * (m + 1) for _ in range(n + 1)]</line-11>
<line-12> for i in range(n):</line-12>
<line-13> for j in range(m):</line-13>
<line-14> acc[i + 1][j + 1] = acc[i + 1][j] + int(pixels[i][j])</line-14>
<line-15> for j in range(m):</line-15>
<line-16> acc[i + 1][j + 1] += acc[i][j + 1]</line-16>
<line-17> # print(acc)</line-17>
<line-18></line-18>
<line-19> for k in range(2, max(n, m) + 1):</line-19>
<line-20> r, c = (n + k - 1) // k, (m + k - 1) // k</line-20>
<line-21> res = 0</line-21>
<line-22> for i in range(r):</line-22>
<line-23> for j in range(c):</line-23>
<line-24> x, y = i * k, j * k</line-24>
<line-25> x2, y2 = min(x + k - 1, n - 1), min(y + k - 1, m - 1)</line-25>
<line-26> zero = acc[x2 + 1][y2 + 1] - acc[x][y2 + 1] - acc[x2 + 1][y] + acc[x][y]</line-26>
<line-27> # print(x, y, k, zero, k * k - zero)</line-27>
<line-28> res += min(zero, k * k - zero)</line-28>
<line-29> # print(k, res)</line-29>
<line-30> ans = min(ans, res)</line-30>
<line-31> print(ans)</line-31>
<line-32></line-32>
<line-33></line-33>
<line-34>def main():</line-34>
<line-35> n, m = [int(x) for x in stdin.readline().split()]</line-35>
<line-36> pixels = []</line-36>
<line-37> for i in range(n):</line-37>
<line-38> pixels.append(stdin.readline().strip())</line-38>
<line-39> run(n, m, pixels)</line-39>
<line-40></line-40>
<line-41></line-41>
<line-42>def __starting_point():</line-42>
<line-43> import os</line-43>
<line-44></line-44>
<line-45> if os.path.exists('tmp.in'):</line-45>
<line-46> stdin = open('tmp.in')</line-46>
<line-48></line-48>
<line-49>__starting_point()</line-49>
|
{"code": "<line-2># coding:utf-8</line-2>\n<line-47> main()</line-47>", "lines": [2, 47]}
#### 0
|
<line-1>import math</line-1>
<line-2></line-2>
<line-4> if a[0] != b[0]:</line-4>
<line-5> return -1 if a[0] < b[0] else 1</line-5>
<line-6> if a[1] != b[1]:</line-6>
<line-7> return -1 if a[1] < b[1] else 1</line-7>
<line-8> return 0</line-8>
<line-9></line-9>
<line-10>def turn(a, b, c):</line-10>
<line-11> return (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0])</line-11>
<line-12> </line-12>
<line-13>def dist2(a, b):</line-13>
<line-14> return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2</line-14>
<line-15></line-15>
<line-16>def solve(n):</line-16>
<line-17> a = [list(map(int, input())) for _ in range(n)]</line-17>
<line-18> points = []</line-18>
<line-19> for i in range(n):</line-19>
<line-20> for j in range(n):</line-20>
<line-21> if a[i][j] == 1:</line-21>
<line-22> curPoints = []</line-22>
<line-23> for dx in range(0, 2):</line-23>
<line-24> for dy in range(0, 2):</line-24>
<line-25> ok = True</line-25>
<line-26> for ddx in range(0, 2):</line-26>
<line-27> for ddy in range(0, 2):</line-27>
<line-28> x, y = i - 1 + dx + ddx, j - 1 + dy + ddy</line-28>
<line-29> if 0 <= x < n and 0 <= y < n and a[x][y] == 0:</line-29>
<line-30> ok = False</line-30>
<line-31> if ok:</line-31>
<line-32> curPoints.append((i + dx, j + dy))</line-32>
<line-33> points.append(curPoints[0])</line-33>
<line-34> points = list(set(points))</line-34>
<line-35> for i in range(1, len(points)):</line-35>
<line-36> if lexComp(points[0], points[i]) > 0:</line-36>
<line-37> points[0], points[i] = points[i], points[0]</line-37>
<line-38> points[1:] = sorted(points[1:], key=lambda p: (math.atan2(p[1] - points[0][1], p[0] - points[0][0]), dist2(p, points[0])))</line-38>
<line-39> hull = []</line-39>
<line-40> for p in points:</line-40>
<line-41> while len(hull) >= 2 and turn(hull[-2], hull[-1], p) <= 0:</line-41>
<line-42> hull.pop()</line-42>
<line-43> hull.append(p)</line-43>
<line-44> hull = [(p[1], n - p[0]) for p in hull]</line-44>
<line-45> hull = hull[::-1]</line-45>
<line-46> start = 0</line-46>
<line-47> for i in range(1, len(hull)):</line-47>
<line-48> if lexComp(hull[i], hull[start]) < 0:</line-48>
<line-49> start = i</line-49>
<line-50> newHull = hull[start:]</line-50>
<line-51> newHull.extend(hull[:start])</line-51>
<line-52> hull = newHull</line-52>
<line-53> print(len(hull))</line-53>
<line-54> for p in hull:</line-54>
<line-55> print(p[0], p[1])</line-55>
<line-56> </line-56>
<line-57>while True:</line-57>
<line-58> n = int(input())</line-58>
<line-59> if n == 0:</line-59>
<line-61> solve(n)</line-61>
|
{"code": "<line-3>def lexComp(a, b):</line-3>\n<line-60> break</line-60>", "lines": [3, 60]}
#### 0
|
<line-1>import math</line-1>
<line-3>import heapq</line-3>
<line-4>from collections import deque</line-4>
<line-5>def na():</line-5>
<line-6> n = int(input())</line-6>
<line-7> b = [int(x) for x in input().split()]</line-7>
<line-8> return n,b</line-8>
<line-9> </line-9>
<line-10> </line-10>
<line-11>def nab():</line-11>
<line-12> n = int(input())</line-12>
<line-13> b = [int(x) for x in input().split()]</line-13>
<line-14> c = [int(x) for x in input().split()]</line-14>
<line-15> return n,b,c</line-15>
<line-16> </line-16>
<line-17> </line-17>
<line-18>def dv():</line-18>
<line-19> n, m = list(map(int, input().split()))</line-19>
<line-20> return n,m</line-20>
<line-21> </line-21>
<line-22> </line-22>
<line-23>def dva():</line-23>
<line-24> n, m = list(map(int, input().split()))</line-24>
<line-25> a = [int(x) for x in input().split()]</line-25>
<line-26> b = [int(x) for x in input().split()]</line-26>
<line-27> return n,m,b</line-27>
<line-28> </line-28>
<line-29> </line-29>
<line-30>def eratosthenes(n): </line-30>
<line-31> sieve = list(range(n + 1))</line-31>
<line-32> for i in sieve:</line-32>
<line-33> if i > 1:</line-33>
<line-34> for j in range(i + i, len(sieve), i):</line-34>
<line-35> sieve[j] = 0</line-35>
<line-36> return sorted(set(sieve))</line-36>
<line-37> </line-37>
<line-38> </line-38>
<line-39>def lol(lst,k):</line-39>
<line-40> k=k%len(lst)</line-40>
<line-41> ret=[0]*len(lst)</line-41>
<line-42> for i in range(len(lst)):</line-42>
<line-43> if i+k<len(lst) and i+k>=0:</line-43>
<line-44> ret[i]=lst[i+k]</line-44>
<line-45> if i+k>=len(lst):</line-45>
<line-46> ret[i]=lst[i+k-len(lst)]</line-46>
<line-47> if i+k<0:</line-47>
<line-48> ret[i]=lst[i+k+len(lst)]</line-48>
<line-49> return(ret)</line-49>
<line-50>def nm():</line-50>
<line-51> n = int(input())</line-51>
<line-52> b = [int(x) for x in input().split()]</line-52>
<line-53> m = int(input())</line-53>
<line-54> c = [int(x) for x in input().split()]</line-54>
<line-55> return n,b,m,c</line-55>
<line-56> </line-56>
<line-57> </line-57>
<line-58>def dvs():</line-58>
<line-59> n = int(input())</line-59>
<line-60> m = int(input())</line-60>
<line-61> return n, m </line-61>
<line-62> </line-62>
<line-63>def fact(a, b):</line-63>
<line-64> c = []</line-64>
<line-65> ans = 0</line-65>
<line-66> f = int(math.sqrt(a))</line-66>
<line-67> for i in range(1, f + 1):</line-67>
<line-68> if a % i == 0:</line-68>
<line-69> c.append(i)</line-69>
<line-70> l = len(c)</line-70>
<line-71> for i in range(l):</line-71>
<line-72> c.append(a // c[i])</line-72>
<line-73> for i in range(len(c)):</line-73>
<line-74> if c[i] <= b:</line-74>
<line-75> ans += 1</line-75>
<line-76> if a / f == f and b >= f:</line-76>
<line-77> return ans - 1</line-77>
<line-78> return ans</line-78>
<line-79> </line-79>
<line-80></line-80>
<line-81>t = int(input())</line-81>
<line-82>for i in range(t):</line-82>
<line-83> a ,b = list(map(int, input().split()))</line-83>
<line-84> if a == b:</line-84>
<line-85> print(0)</line-85>
<line-86> else:</line-86>
<line-87> d = abs(a - b)</line-87>
<line-88> k1 = d//5</line-88>
<line-89> d -= k1 *5 </line-89>
<line-90> k2 = d // 2</line-90>
<line-92> print(d + k1 + k2)</line-92>
|
{"code": "<line-2>from decimal import Decimal</line-2>\n<line-91>\t\td -= k2 * 2</line-91>", "lines": [2, 91]}
#### 0
|
<line-1>import sys</line-1>
<line-3>import bisect</line-3>
<line-4></line-4>
<line-5>t=int(input())</line-5>
<line-6></line-6>
<line-7>for testcases in range(t):</line-7>
<line-8> n=int(input())</line-8>
<line-9> A=list(map(int,input().split()))</line-9>
<line-10> m=int(input())</line-10>
<line-11> PS=[tuple(map(int,input().split())) for i in range(m)]</line-11>
<line-12></line-12>
<line-13> PS.sort()</line-13>
<line-14> K=[PS[-1]]</line-14>
<line-15></line-15>
<line-16> for a,b in PS[::-1][1:]:</line-16>
<line-17> if b<=K[-1][1]:</line-17>
<line-18> continue</line-18>
<line-19> else:</line-19>
<line-20> K.append((a,b))</line-20>
<line-21></line-21>
<line-22> K.reverse()</line-22>
<line-23></line-23>
<line-24> ANS=1</line-24>
<line-25> count=0</line-25>
<line-26> countmax=n+1</line-26>
<line-27> LEN=len(K)</line-27>
<line-28> for a in A:</line-28>
<line-29> x=bisect.bisect_left(K,(a,0))</line-29>
<line-30> if x==LEN:</line-30>
<line-31> print(-1)</line-31>
<line-32> break</line-32>
<line-33> elif K[x][1]>=count+1 and countmax>=count+1:</line-33>
<line-34> count+=1</line-34>
<line-35> countmax=min(countmax,K[x][1])</line-35>
<line-36> else:</line-36>
<line-37> ANS+=1</line-37>
<line-38> count=1</line-38>
<line-39> countmax=K[x][1]</line-39>
<line-40></line-40>
<line-41> #print(a,count,countmax,ANS)</line-41>
<line-43> print(ANS)</line-43>
<line-44> </line-44>
<line-45> </line-45>
<line-46> </line-46>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-42> else:</line-42>", "lines": [2, 42]}
#### 0
|
<line-1>class BIT():</line-1>
<line-3> self.BIT=[0]*(n+1)</line-3>
<line-4> self.num=n</line-4>
<line-5></line-5>
<line-6> def query(self,idx):</line-6>
<line-7> res_sum = 0</line-7>
<line-8> while idx > 0:</line-8>
<line-9> res_sum += self.BIT[idx]</line-9>
<line-10> idx -= idx&(-idx)</line-10>
<line-11> return res_sum</line-11>
<line-12></line-12>
<line-13> #Ai += x O(logN)</line-13>
<line-14> def update(self,idx,x):</line-14>
<line-15> while idx <= self.num:</line-15>
<line-16> self.BIT[idx] += x</line-16>
<line-17> idx += idx&(-idx)</line-17>
<line-18> return</line-18>
<line-19></line-19>
<line-20>import sys,heapq,random</line-20>
<line-21></line-21>
<line-22>input=sys.stdin.readline</line-22>
<line-23></line-23>
<line-24>n=int(input())</line-24>
<line-25>spell=[tuple(map(int,input().split())) for i in range(n)]</line-25>
<line-26></line-26>
<line-27></line-27>
<line-28>S=set([])</line-28>
<line-29>for i in range(n):</line-29>
<line-30> S.add(abs(spell[i][1]))</line-30>
<line-31>S=list(S)</line-31>
<line-32>S.sort(reverse=True)</line-32>
<line-33>comp={i:e+1 for e,i in enumerate(S)}</line-33>
<line-34>N=len(S)</line-34>
<line-35></line-35>
<line-36>x_exist=BIT(N)</line-36>
<line-37>y_exist=BIT(N)</line-37>
<line-38>power=BIT(N)</line-38>
<line-39></line-39>
<line-40>X,Y,S=0,0,0</line-40>
<line-41>Xmax=[]</line-41>
<line-42>Ymin=[]</line-42>
<line-43>x_data=[0]*(N+1)</line-43>
<line-44>y_data=[0]*(N+1)</line-44>
<line-45></line-45>
<line-46>for i in range(n):</line-46>
<line-47> t,d=spell[i]</line-47>
<line-48> S+=d</line-48>
<line-49> if d<0:</line-49>
<line-50> id=comp[-d]</line-50>
<line-51> if t==0:</line-51>
<line-52> X-=1</line-52>
<line-53> x_exist.update(id,-1)</line-53>
<line-54> power.update(id,d)</line-54>
<line-55> x_data[id]-=1</line-55>
<line-56> else:</line-56>
<line-57> Y-=1</line-57>
<line-58> y_exist.update(id,-1)</line-58>
<line-59> power.update(id,d)</line-59>
<line-60> y_data[id]-=1</line-60>
<line-61> else:</line-61>
<line-62> id=comp[d]</line-62>
<line-63> if t==0:</line-63>
<line-64> X+=1</line-64>
<line-65> x_exist.update(id,1)</line-65>
<line-66> power.update(id,d)</line-66>
<line-67> heapq.heappush(Xmax,-d)</line-67>
<line-68> x_data[id]+=1</line-68>
<line-69> else:</line-69>
<line-70> Y+=1</line-70>
<line-71> y_exist.update(id,1)</line-71>
<line-72> power.update(id,d)</line-72>
<line-73> heapq.heappush(Ymin,d)</line-73>
<line-74> y_data[id]+=1</line-74>
<line-75> if X==0:</line-75>
<line-76> if Y==0:</line-76>
<line-77> print(0)</line-77>
<line-78> else:</line-78>
<line-79> while not y_data[comp[Ymin[0]]]:</line-79>
<line-80> heapq.heappop(Ymin)</line-80>
<line-81> print(2*S-Ymin[0])</line-81>
<line-82> else:</line-82>
<line-83> if Y==0:</line-83>
<line-84> print(S)</line-84>
<line-85> else:</line-85>
<line-86> start=0</line-86>
<line-87> end=N</line-87>
<line-88> while end-start>1:</line-88>
<line-89> test=(end+start)//2</line-89>
<line-90> if x_exist.query(test)+y_exist.query(test)<=Y:</line-90>
<line-91> start=test</line-91>
<line-92> else:</line-92>
<line-93> end=test</line-93>
<line-94> if y_exist.query(start)!=Y:</line-94>
<line-95> print(S+power.query(start))</line-95>
<line-96> else:</line-96>
<line-97> while not y_data[comp[Ymin[0]]]:</line-97>
<line-98> heapq.heappop(Ymin)</line-98>
<line-99> while not x_data[comp[-Xmax[0]]]:</line-99>
<line-101> print(S+power.query(start)-Ymin[0]-Xmax[0])</line-101>
|
{"code": "<line-2> def __init__(self,n):</line-2>\n<line-100> heapq.heappop(Xmax)</line-100>", "lines": [2, 100]}
#### 0
|
<line-1>for nt in range(int(input())):</line-1>
<line-3> l=list(map(int,input().split()))</line-3>
<line-4> s=sum(l)</line-4>
<line-5> e=l[0]</line-5>
<line-6> for i in range(1,n):</line-6>
<line-7> e=e^l[i]</line-7>
<line-8> if s==2*e:</line-8>
<line-9> print(0)</line-9>
<line-10> print ()</line-10>
<line-11> else:</line-11>
<line-13> print(e,s+e)</line-13>
|
{"code": "<line-2>\tn=int(input())</line-2>\n<line-12>\t\tprint(2)</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-3></line-3>
<line-4>tests = int(input())</line-4>
<line-5>for test in range(tests):</line-5>
<line-6> n, m = list(map(int, input().split()))</line-6>
<line-7> a = [[0] * m for _ in range(n)]</line-7>
<line-8> r = [[int(i) for i in input().split()] for _ in range(n)]</line-8>
<line-9> c = [[int(i) for i in input().split()] for _ in range(m)]</line-9>
<line-10> z = [[-1, -1] for _ in range(n * m + 1)]</line-10>
<line-11> </line-11>
<line-12> for i in range(n):</line-12>
<line-13> for j in range(m):</line-13>
<line-14> z[r[i][j]][0] = j</line-14>
<line-15> for i in range(m):</line-15>
<line-16> for j in range(n):</line-16>
<line-17> z[c[i][j]][1] = j</line-17>
<line-18></line-18>
<line-19> for i in range(1, n * m + 1):</line-19>
<line-20> a[z[i][1]][z[i][0]] = i</line-20>
<line-21></line-21>
<line-23> print(' '.join([str(j) for j in i]))</line-23>
|
{"code": "<line-2>input = stdin.readline</line-2>\n<line-22> for i in a:</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>__MULTITEST = True</line-1>
<line-2></line-2>
<line-4>def solve():</line-4>
<line-5> n, x = map(int, input().split())</line-5>
<line-6> a = list(map(int, input().split()))</line-6>
<line-7> a.sort()</line-7>
<line-8></line-8>
<line-9> group = 0</line-9>
<line-10> ptr = n-1</line-10>
<line-11> members = 0</line-11>
<line-12></line-12>
<line-13> currentMin = int(1e10)</line-13>
<line-14> while ptr > -1:</line-14>
<line-15> currentMin = min(currentMin, a[ptr])</line-15>
<line-16> members += 1</line-16>
<line-17></line-17>
<line-18> if currentMin * members >= x:</line-18>
<line-19> group += 1</line-19>
<line-20> members = 0</line-20>
<line-21> currentMin = int(1e10)</line-21>
<line-22> </line-22>
<line-23> ptr -= 1</line-23>
<line-24> </line-24>
<line-25> print(group)</line-25>
<line-26></line-26>
<line-27>## main</line-27>
<line-28>def __starting_point():</line-28>
<line-29> t = (int(input()) if __MULTITEST else 1)</line-29>
<line-30> for tt in range(t):</line-30>
<line-32>__starting_point()</line-32>
|
{"code": "<line-3>## solve</line-3>\n<line-31> solve();</line-31>", "lines": [3, 31]}
#### 0
|
<line-1>import sys</line-1>
<line-3>t = int(input())</line-3>
<line-4>for _ in range(t):</line-4>
<line-5> n = int(input())</line-5>
<line-6> ab = [list(map(int,input().split())) for i in range(n-1)]</line-6>
<line-7> graph = [[] for i in range(n+1)]</line-7>
<line-8> deg = [0]*(n+1)</line-8>
<line-9> for a,b in ab:</line-9>
<line-10> graph[a].append(b)</line-10>
<line-11> graph[b].append(a)</line-11>
<line-12> deg[a] += 1</line-12>
<line-13> deg[b] += 1</line-13>
<line-14> pnt = [max(deg[i]-1,1) for i in range(n+1)]</line-14>
<line-15> root = 1</line-15>
<line-16> stack = [root]</line-16>
<line-17> dist = [0]*(n+1)</line-17>
<line-18> dist[root] = pnt[root]</line-18>
<line-19> while stack:</line-19>
<line-20> x = stack.pop()</line-20>
<line-21> for y in graph[x]:</line-21>
<line-22> if dist[y] == 0:</line-22>
<line-23> dist[y] = dist[x]+pnt[y]</line-23>
<line-24> stack.append(y)</line-24>
<line-25> far = dist.index(max(dist))</line-25>
<line-26> root = far</line-26>
<line-27> stack = [root]</line-27>
<line-28> dist = [0]*(n+1)</line-28>
<line-29> dist[root] = pnt[root]</line-29>
<line-30> while stack:</line-30>
<line-31> x = stack.pop()</line-31>
<line-32> for y in graph[x]:</line-32>
<line-33> if dist[y] == 0:</line-33>
<line-34> dist[y] = dist[x]+pnt[y]</line-34>
<line-36> print(max(dist))</line-36>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-35> stack.append(y)</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>t=int(input())</line-4>
<line-5></line-5>
<line-6>def calc(x):</line-6>
<line-7> return x*(x+1)//2</line-7>
<line-8></line-8>
<line-9>for test in range(t):</line-9>
<line-10> n,m=list(map(int,input().split()))</line-10>
<line-11></line-11>
<line-12> ANS=calc(n)</line-12>
<line-13></line-13>
<line-14> k=n-m</line-14>
<line-15> q,mod=divmod(k,m+1)</line-15>
<line-16></line-16>
<line-18></line-18>
<line-19> print(ANS)</line-19>
<line-20> </line-20>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-17> ANS-=calc(q+1)*mod+calc(q)*(m+1-mod)</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> ar = list(map(int, input().split()))</line-3>
<line-5> print(abs(ar[n] - ar[n - 1]))</line-5>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-4> ar.sort()</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>from heapq import heapify, heappush, heappop</line-1>
<line-3>input = sys.stdin.readline</line-3>
<line-4></line-4>
<line-5>def solve():</line-5>
<line-6> N, Q = list(map(int, input().split()))</line-6>
<line-7> events = []</line-7>
<line-8> for i in range(N):</line-8>
<line-9> S, T, X = list(map(int, input().split()))</line-9>
<line-10> events.append((S-X-0.5, 1, X))</line-10>
<line-11> events.append((T-X-0.5, 0, X))</line-11>
<line-12> for i in range(Q):</line-12>
<line-13> D = int(input())</line-13>
<line-14> events.append((D, 2, i))</line-14>
<line-15></line-15>
<line-16> events.sort()</line-16>
<line-17></line-17>
<line-18> anss = [-1] * Q</line-18>
<line-19> PQ = []</line-19>
<line-20> isClosed = dict()</line-20>
<line-21> for tm, tp, x in events:</line-21>
<line-22> if tp == 0:</line-22>
<line-23> isClosed[x] = 0</line-23>
<line-24> elif tp == 1:</line-24>
<line-25> isClosed[x] = 1</line-25>
<line-26> heappush(PQ, x)</line-26>
<line-27> else:</line-27>
<line-28> while PQ:</line-28>
<line-29> if isClosed[PQ[0]] == 1:</line-29>
<line-30> anss[x] = PQ[0]</line-30>
<line-31> break</line-31>
<line-32> heappop(PQ)</line-32>
<line-33></line-33>
<line-35></line-35>
<line-36></line-36>
<line-37>solve()</line-37>
|
{"code": "<line-2>import sys</line-2>\n<line-34> print(('\\n'.join(map(str, anss))))</line-34>", "lines": [2, 34]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>class UnionFind():</line-4>
<line-5> def __init__(self, n):</line-5>
<line-6> self.n = n</line-6>
<line-7> self.parents = [-1] * n</line-7>
<line-8></line-8>
<line-9> def find(self, x):</line-9>
<line-10> if self.parents[x] < 0:</line-10>
<line-11> return x</line-11>
<line-12> else:</line-12>
<line-13> self.parents[x] = self.find(self.parents[x])</line-13>
<line-14> return self.parents[x]</line-14>
<line-15></line-15>
<line-16> def union(self, x, y):</line-16>
<line-17> x = self.find(x)</line-17>
<line-18> y = self.find(y)</line-18>
<line-19></line-19>
<line-20> if x == y:</line-20>
<line-21> return</line-21>
<line-22></line-22>
<line-23> if self.parents[x] > self.parents[y]:</line-23>
<line-24> x, y = y, x</line-24>
<line-25></line-25>
<line-26> self.parents[x] += self.parents[y]</line-26>
<line-27> self.parents[y] = x</line-27>
<line-28></line-28>
<line-29> def size(self, x):</line-29>
<line-30> return -self.parents[self.find(x)]</line-30>
<line-31></line-31>
<line-32> def same(self, x, y):</line-32>
<line-33> return self.find(x) == self.find(y)</line-33>
<line-34></line-34>
<line-35> def members(self, x):</line-35>
<line-36> root = self.find(x)</line-36>
<line-37> return [i for i in range(self.n) if self.find(i) == root]</line-37>
<line-38></line-38>
<line-39> def roots(self):</line-39>
<line-40> return [i for i, x in enumerate(self.parents) if x < 0]</line-40>
<line-41></line-41>
<line-42> def group_count(self):</line-42>
<line-43> return len(self.roots())</line-43>
<line-44></line-44>
<line-45> def all_group_members(self):</line-45>
<line-46> return {r: self.members(r) for r in self.roots()}</line-46>
<line-47></line-47>
<line-48> def __str__(self):</line-48>
<line-49> return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())</line-49>
<line-50></line-50>
<line-51>n, m = map(int, input().split())</line-51>
<line-52></line-52>
<line-53>ans = [-1]*n</line-53>
<line-54></line-54>
<line-55>uf = UnionFind(n)</line-55>
<line-56>g = [[] for i in range(n)]</line-56>
<line-57></line-57>
<line-58>for i in range(m):</line-58>
<line-59> u, v, c = map(int, input().split())</line-59>
<line-60> if not uf.same(u-1, v-1):</line-60>
<line-61> uf.union(u-1, v-1)</line-61>
<line-62> g[u-1].append((v-1, c))</line-62>
<line-63> g[v-1].append((u-1, c))</line-63>
<line-64></line-64>
<line-65>def dfs(i):</line-65>
<line-66> for to, c in g[i]:</line-66>
<line-67> if ans[to]==-1:</line-67>
<line-68> if ans[i] == c:</line-68>
<line-69> if c == 1:</line-69>
<line-70> ans[to] = c+1</line-70>
<line-71> else:</line-71>
<line-72> ans[to] = c-1</line-72>
<line-73> else:</line-73>
<line-74> ans[to] = c</line-74>
<line-75> dfs(to)</line-75>
<line-76></line-76>
<line-77>ans = [-1]*n</line-77>
<line-78>ans[0] = 1</line-78>
<line-79>dfs(0)</line-79>
<line-80></line-80>
<line-81>if -1 in ans:</line-81>
<line-82> print('No')</line-82>
<line-83> return</line-83>
<line-84></line-84>
<line-86></line-86>
<line-87>print(*ans, sep='\n')</line-87>
|
{"code": "<line-2>sys.setrecursionlimit(10**6)</line-2>\n<line-85>ans = [a for a in ans]</line-85>", "lines": [2, 85]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>s = [ord(i)-97 for i in s]</line-3>
<line-4></line-4>
<line-5>dic = {}</line-5>
<line-6>for i in range(26):</line-6>
<line-7> dic[i] = []</line-7>
<line-8></line-8>
<line-9>for i in range(n):</line-9>
<line-10> dic[s[i]].append(i)</line-10>
<line-11></line-11>
<line-12>for i in range(26):</line-12>
<line-13> dic[i].append(float('inf'))</line-13>
<line-14></line-14>
<line-15>from bisect import bisect_left</line-15>
<line-16>q = int(input())</line-16>
<line-17>for i in range(q):</line-17>
<line-18> x, y, z = input().split()</line-18>
<line-19> if x == '1':</line-19>
<line-20> y, z = int(y) - 1, ord(z) - 97</line-20>
<line-21> p = bisect_left(dic[s[y]], y)</line-21>
<line-22> dic[s[y]].pop(p)</line-22>
<line-23> dic[z].insert(bisect_left(dic[z], y), y)</line-23>
<line-24> s[y] = z</line-24>
<line-25> else:</line-25>
<line-26> res = 0</line-26>
<line-27> y, z = int(y) - 1, int(z) - 1</line-27>
<line-28> for i in range(26):</line-28>
<line-29> p = dic[i][bisect_left(dic[i], y)]</line-29>
<line-30> if p <= z:</line-30>
<line-32> print(res)</line-32>
|
{"code": "<line-2>s = list(input())</line-2>\n<line-31> res += 1</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3></line-3>
<line-4>X=[]</line-4>
<line-5>b=a[0]</line-5>
<line-6>for i in range(1,n) :</line-6>
<line-7> b^=a[i]</line-7>
<line-8></line-8>
<line-9>for i in range(n) :</line-9>
<line-10> x=b^a[i]</line-10>
<line-11> X.append(x)</line-11>
<line-12></line-12>
<line-14> print(i,end=" ")</line-14>
|
{"code": "<line-2>a=list(map(int,input().split()))</line-2>\n<line-13>for i in X :</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>import sys</line-1>
<line-3>sys.setrecursionlimit(10**5)</line-3>
<line-4></line-4>
<line-5>N, Q = map(int, input().split())</line-5>
<line-6></line-6>
<line-7>path = [[] for _ in range(N)]</line-7>
<line-8></line-8>
<line-9>for _ in range(N-1) :</line-9>
<line-10> a, b, c, d = (int(i) for i in input().split())</line-10>
<line-11> path[a-1].append((b-1, c-1, d))</line-11>
<line-12> path[b-1].append((a-1, c-1, d))</line-12>
<line-13></line-13>
<line-14># doublingに必要なKを求める</line-14>
<line-15>for K in range(18) :</line-15>
<line-16> if 2 ** K >= N :</line-16>
<line-17> break</line-17>
<line-18></line-18>
<line-19># dfs</line-19>
<line-20>parent = [[-1] * N for _ in range(K)]</line-20>
<line-21>rank = [-1 for _ in range(N)]</line-21>
<line-22></line-22>
<line-23>rank[0] = 0</line-23>
<line-24>queue = [0]</line-24>
<line-25></line-25>
<line-26>while queue :</line-26>
<line-27> cur = queue.pop()</line-27>
<line-28> for nex, _, _ in path[cur] :</line-28>
<line-29> if rank[nex] < 0 :</line-29>
<line-30> queue.append(nex)</line-30>
<line-31> parent[0][nex] = cur</line-31>
<line-32> rank[nex] = rank[cur] + 1</line-32>
<line-33></line-33>
<line-34># doubling </line-34>
<line-35>for i in range(1, K) :</line-35>
<line-36> for j in range(N) :</line-36>
<line-37> if parent[i-1][j] > 0 :</line-37>
<line-38> parent[i][j] = parent[i-1][parent[i-1][j]]</line-38>
<line-39></line-39>
<line-40># lca</line-40>
<line-41>def lca(a, b) :</line-41>
<line-42> if rank[a] > rank[b] :</line-42>
<line-43> a, b = b, a</line-43>
<line-44></line-44>
<line-45> diff = rank[b] - rank[a]</line-45>
<line-46> i = 0</line-46>
<line-47> while diff > 0 :</line-47>
<line-48> if diff & 1 :</line-48>
<line-49> b = parent[i][b]</line-49>
<line-50> diff >>= 1</line-50>
<line-51> i += 1</line-51>
<line-52> </line-52>
<line-53> if a == b :</line-53>
<line-54> return a</line-54>
<line-55></line-55>
<line-56> for i in range(K-1, -1, -1) :</line-56>
<line-57> if parent[i][a] != parent[i][b] :</line-57>
<line-58> a = parent[i][a]</line-58>
<line-59> b = parent[i][b]</line-59>
<line-60></line-60>
<line-61> return parent[0][a]</line-61>
<line-62></line-62>
<line-63># Queryの先読み</line-63>
<line-64>schedule = [[] for _ in range(N)]</line-64>
<line-65>for i in range(Q) : </line-65>
<line-66> x, y, u, v = map(int, input().split())</line-66>
<line-67> x, u, v = x-1, u-1, v-1</line-67>
<line-68> l = lca(u, v)</line-68>
<line-69> schedule[u].append((i, 1, x, y))</line-69>
<line-70> schedule[v].append((i, 1, x, y))</line-70>
<line-71> schedule[l].append((i, -2, x, y))</line-71>
<line-72></line-72>
<line-73>ret = [0] * Q</line-73>
<line-74>C = [0] * (N-1)</line-74>
<line-75>D = [0] * (N-1)</line-75>
<line-76></line-76>
<line-77>def dfs(cur, pre, tot) :</line-77>
<line-78> for i, t, c, d in schedule[cur] :</line-78>
<line-79> ret[i] += t * (tot - D[c] + C[c] * d)</line-79>
<line-80> </line-80>
<line-81> for nex, c, d in path[cur] :</line-81>
<line-82> if nex == pre :</line-82>
<line-83> continue</line-83>
<line-84> C[c] += 1</line-84>
<line-85> D[c] += d</line-85>
<line-86> dfs(nex, cur, tot + d)</line-86>
<line-87> C[c] -= 1</line-87>
<line-88> D[c] -= d</line-88>
<line-89></line-89>
<line-90>dfs(0, -1, 0)</line-90>
<line-91> </line-91>
<line-93> print(ret[i])</line-93>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-92>for i in range(Q) :</line-92>", "lines": [2, 92]}
#### 0
|
<line-1>import bisect</line-1>
<line-3>sys.setrecursionlimit(10**7)</line-3>
<line-4></line-4>
<line-5>def dfs(v):</line-5>
<line-6> pos=bisect.bisect_left(dp,arr[v])</line-6>
<line-7> changes.append((pos,dp[pos]))</line-7>
<line-8> dp[pos]=arr[v]</line-8>
<line-9> ans[v]=bisect.bisect_left(dp,10**18)</line-9>
<line-10> for u in g[v]:</line-10>
<line-11> if checked[u]==0:</line-11>
<line-12> checked[u]=1</line-12>
<line-13> dfs(u)</line-13>
<line-14> pos,val=changes.pop()</line-14>
<line-15> dp[pos]=val</line-15>
<line-16></line-16>
<line-17></line-17>
<line-18>n=int(input())</line-18>
<line-19>arr=[0]+list(map(int,input().split()))</line-19>
<line-20>g=[[] for _ in range(n+1)]</line-20>
<line-21>for _ in range(n-1):</line-21>
<line-22> a,b=map(int,input().split())</line-22>
<line-23> g[a].append(b)</line-23>
<line-24> g[b].append(a)</line-24>
<line-25>ans=[0]*(n+1)</line-25>
<line-26>checked=[0]*(n+1)</line-26>
<line-27>checked[1]=1</line-27>
<line-28>dp=[10**18 for _ in range(n+1)]</line-28>
<line-29>changes=[]</line-29>
<line-30>dfs(1)</line-30>
<line-32> print(ans[i])</line-32>
|
{"code": "<line-2>import sys</line-2>\n<line-31>for i in range(1,n+1):</line-31>", "lines": [2, 31]}
#### 0
|
<line-2>n = int(input())</line-2>
<line-3>print(m-n) if m>n else print(m+n)</line-3>
|
{"code": "<line-1>m = int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> result = 1</line-3>
<line-4> while exponent > 0:</line-4>
<line-5> if(exponent %2 == 1):</line-5>
<line-6> result = (result * base) % modulus</line-6>
<line-7> exponent = exponent//2</line-7>
<line-8> base = (base * base)%modulus</line-8>
<line-9> return result</line-9>
<line-10>def passesMillerRabinTest(n, a):</line-10>
<line-11> s = 0</line-11>
<line-12> d = n-1</line-12>
<line-13> while(d%2 == 0):</line-13>
<line-14> s += 1</line-14>
<line-15> d >>= 1</line-15>
<line-16> x = modular_pow(a, d, n)</line-16>
<line-17> if(x == 1 or x == n-1):</line-17>
<line-18> return True</line-18>
<line-19> for ss in range(s - 1):</line-19>
<line-20> x = (x*x)%n</line-20>
<line-21> if(x == 1):</line-21>
<line-22> return False</line-22>
<line-23> if(x == n-1):</line-23>
<line-24> return True</line-24>
<line-25> return False</line-25>
<line-26>primeList = (2, 3,5,7,11,13,17,19, 23,29, 31,37)</line-26>
<line-27>def isPrime(n):</line-27>
<line-28> for p in primeList:</line-28>
<line-29> if n%p == 0:</line-29>
<line-30> return n == p</line-30>
<line-31> for p in primeList:</line-31>
<line-32> if passesMillerRabinTest(n, p) == False:</line-32>
<line-33> return False</line-33>
<line-34> return True</line-34>
<line-35> </line-35>
<line-36>t = int(input())</line-36>
<line-37>for tt in range(t):</line-37>
<line-38> n = int(input())</line-38>
<line-39> if(n == 2):</line-39>
<line-40> print(2)</line-40>
<line-41> continue</line-41>
<line-42> if n%2 == 0:</line-42>
<line-43> n -= 1</line-43>
<line-44> while True:</line-44>
<line-45> if(isPrime(n)):</line-45>
<line-46> print(n)</line-46>
<line-48> n -= 2</line-48>
|
{"code": "<line-2>def modular_pow(base, exponent, modulus):</line-2>\n<line-47> break</line-47>", "lines": [2, 47]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> sum1=(m*(m+1))//2</line-3>
<line-4> sum2=(m*(m-1))//2</line-4>
<line-5> ct=0</line-5>
<line-6> for i in range(n):</line-6>
<line-7> for j in range(n):</line-7>
<line-8> if i<j and k[i]>k[j]:</line-8>
<line-9> ct+=sum1</line-9>
<line-10> elif j<i and k[i]>k[j]:</line-10>
<line-11> ct+=sum2</line-11>
<line-12> return ct</line-12>
<line-13></line-13>
<line-14>test=int(input())</line-14>
<line-15>for _ in range(test):</line-15>
<line-16> n,m=map(int,input().split())</line-16>
<line-18> print(count(k,n,m))</line-18>
|
{"code": "<line-2>def count(k,n,m):</line-2>\n<line-17> k=list(map(int,input().split()))</line-17>", "lines": [2, 17]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> x = 0</line-3>
<line-4> # print(l)</line-4>
<line-5> for i in range(1, len(l)):</line-5>
<line-6> temp = []</line-6>
<line-7> for j in range(i):</line-7>
<line-8> v = getbig(l[i], l[j], fs)</line-8>
<line-9> if v > 1:</line-9>
<line-10> temp.append(v)</line-10>
<line-11> if flag:</line-11>
<line-12> x += 2**v - 2</line-12>
<line-13> else:</line-13>
<line-14> x -= 2**v - 2</line-14>
<line-15> x += offset(temp, not flag)</line-15>
<line-16> return x</line-16>
<line-17> </line-17>
<line-18>def getbig(v1, v2, factors):</line-18>
<line-19> x = 1</line-19>
<line-20> for f in factors:</line-20>
<line-21> while v1%f == 0 and v2%f == 0:</line-21>
<line-22> v1//=f</line-22>
<line-23> v2//=f</line-23>
<line-24> x*=f</line-24>
<line-25> return x</line-25>
<line-26> </line-26>
<line-27>def prime_factors(n):</line-27>
<line-28> i = 2</line-28>
<line-29> factors = set()</line-29>
<line-30> while i * i <= n:</line-30>
<line-31> if n % i:</line-31>
<line-32> i += 1</line-32>
<line-33> else:</line-33>
<line-34> n //= i</line-34>
<line-35> factors.add(i)</line-35>
<line-36> if n > 1:</line-36>
<line-37> factors.add(n)</line-37>
<line-38> return factors</line-38>
<line-39> </line-39>
<line-40>n,m = map(int, input().split())</line-40>
<line-41>if n == 1:</line-41>
<line-42> print(1)</line-42>
<line-43>else:</line-43>
<line-44> fs = prime_factors(n)</line-44>
<line-45> fs.discard(n)</line-45>
<line-46> ans = 2**n-2</line-46>
<line-47> temp = []</line-47>
<line-48> for v in fs:</line-48>
<line-49> v = n//v</line-49>
<line-50> temp.append(v)</line-50>
<line-51> ans -= 2**v - 2</line-51>
<line-52> # print(ans)</line-52>
<line-53> ans += offset(temp, True)</line-53>
<line-55> print(ans%m)</line-55>
|
{"code": "<line-2>def offset(l, flag):</line-2>\n<line-54> # print(fs)</line-54>", "lines": [2, 54]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> if N%2==0:</line-3>
<line-4> print(N//2+1)</line-4>
<line-6> print((N-1)//2+1)</line-6>
|
{"code": "<line-2> N=int(input())</line-2>\n<line-5> else:</line-5>", "lines": [2, 5]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>n, k1, *l = map(int, input().split())</line-3>
<line-4>v_l, b_l = l[:n], l[n:]</line-4>
<line-5></line-5>
<line-6>b_inv = {key:[] for key in range(2*k1)}</line-6>
<line-7>for i in range(n):</line-7>
<line-8> b_l[i] -= 1</line-8>
<line-9> b_inv[b_l[i]].append(i)</line-9>
<line-10></line-10>
<line-11>dp = [[0 for _ in range(n)] for _ in range(n)]</line-11>
<line-12>for k in range(1, n):</line-12>
<line-13> for j in range(n-2, -1, -1):</line-13>
<line-14> if j+k >= n:</line-14>
<line-15> continue</line-15>
<line-16> </line-16>
<line-17> dp[j][j+k] = max(dp[j][j+k], dp[j][j+k-1])</line-17>
<line-18> if b_l[j+k] >= k1:</line-18>
<line-19> left = bisect.bisect_right(b_inv[b_l[j+k]-k1], j)</line-19>
<line-20> </line-20>
<line-21> if b_l[j+k] >= k1:</line-21>
<line-22> for i in b_inv[b_l[j+k]-k1][left:]:</line-22>
<line-23> if i > j+k:</line-23>
<line-24> break</line-24>
<line-25> if i > j:</line-25>
<line-26> dp[j][j+k] = max(dp[j][j+k], dp[j][i-1]+dp[i][j+k])</line-26>
<line-27> </line-27>
<line-28> if b_l[j+k]-k1 == b_l[j]:</line-28>
<line-29> if j+k-1 < n:</line-29>
<line-30> dp[j][j+k] = max(dp[j][j+k], v_l[j+k]+v_l[j]+dp[j+1][j+k-1])</line-30>
<line-31> else:</line-31>
<line-33> </line-33>
<line-34></line-34>
<line-35>print(dp[0][-1])</line-35>
|
{"code": "<line-2>import bisect</line-2>\n<line-32> dp[j][j+k] = max(dp[j][j+k], v_l[j+k]+v_l[j])</line-32>", "lines": [2, 32]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(t):</line-3>
<line-4> n=input()</line-4>
<line-5> if(n=='b' or n=='B'):</line-5>
<line-6> print('BattleShip')</line-6>
<line-7> elif(n=='c' or n=='C'):</line-7>
<line-8> print('Cruiser')</line-8>
<line-9> elif(n=='d' or n=='D'):</line-9>
<line-10> print('Destroyer')</line-10>
<line-12> print('Frigate')</line-12>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-11> else:</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>from math import *</line-1>
<line-3>import sys</line-3>
<line-4>input=sys.stdin.readline</line-4>
<line-5>t=int(input())</line-5>
<line-6>while(t):</line-6>
<line-7> t-=1</line-7>
<line-8> n=int(input())</line-8>
<line-9> a=list(map(int,input().split()))</line-9>
<line-10> p,q=map(int,input().split())</line-10>
<line-11> s=0</line-11>
<line-12> a.sort()</line-12>
<line-13> for i in range(n//2):</line-13>
<line-14> x=a[i]</line-14>
<line-15> x1=a[n-i-1]</line-15>
<line-16> if(x==p or x1==p):</line-16>
<line-17> s1=abs(x-x1)</line-17>
<line-18> s2=q</line-18>
<line-19> s+=abs(atan2(s1,s2))</line-19>
<line-20> elif(x<p and x1>p):</line-20>
<line-21> s1=abs(p-x)</line-21>
<line-22> ex=atan2(s1,q)</line-22>
<line-23> s1=abs(p-x1)</line-23>
<line-24> ex1=atan2(s1,q)</line-24>
<line-25> ex+=ex1</line-25>
<line-26> s+=abs(ex)</line-26>
<line-27> else:</line-27>
<line-28> if(p<x):</line-28>
<line-29> s1=abs(p-x)</line-29>
<line-30> ex=atan2(s1,q)</line-30>
<line-31> s1=abs(p-x1)</line-31>
<line-32> ex1=atan2(s1,q)</line-32>
<line-33> ex=ex1-ex</line-33>
<line-34> s+=abs(ex)</line-34>
<line-35> else:</line-35>
<line-36> s1=abs(p-x)</line-36>
<line-37> ex=atan2(s1,q)</line-37>
<line-38> s1=abs(p-x1)</line-38>
<line-39> ex1=atan2(s1,q)</line-39>
<line-40> ex=ex-ex1</line-40>
<line-42> print(s)</line-42>
|
{"code": "<line-2>from collections import *</line-2>\n<line-41> s+=abs(ex) </line-41>", "lines": [2, 41]}
#### 0
|
<line-1>import sys</line-1>
<line-3>def get_ints(): return list(map(int, sys.stdin.readline().strip().split()))</line-3>
<line-4>def input(): return sys.stdin.readline().strip()</line-4>
<line-5>import sys</line-5>
<line-6>sys.setrecursionlimit(10**9)</line-6>
<line-7>from math import sqrt,ceil,floor</line-7>
<line-8>n=int(input())</line-8>
<line-9>co=0</line-9>
<line-10>ans=0</line-10>
<line-11>for i in range(1,n):</line-11>
<line-12> ans+=n//i</line-12>
<line-13> if n%i==0:</line-13>
<line-15>print(ans)</line-15>
<line-16></line-16>
|
{"code": "<line-2>def get_array(): return list(map(int , sys.stdin.readline().strip().split()))</line-2>\n<line-14> ans-=1</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>f = 5003*[0]</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>def qPow(a, b):</line-5>
<line-6> nonlocal modn</line-6>
<line-7> res = 1</line-7>
<line-8> while b > 0:</line-8>
<line-9> if (b & 1) == 1:</line-9>
<line-10> res = res * a % modn</line-10>
<line-11> a = a * a % modn</line-11>
<line-12> b = b >> 1</line-12>
<line-13> return res</line-13>
<line-14></line-14>
<line-15></line-15>
<line-16>def getF():</line-16>
<line-17> nonlocal f</line-17>
<line-18> f[0] = 1</line-18>
<line-19> for i in range(1, 5001):</line-19>
<line-20> f[i] = f[i-1] * i</line-20>
<line-21></line-21>
<line-22></line-22>
<line-23>def __starting_point():</line-23>
<line-24> getF()</line-24>
<line-25> T = int(input())</line-25>
<line-26> while T > 0:</line-26>
<line-27> T = T - 1</line-27>
<line-28> n, k = list(map(int,input().split()))</line-28>
<line-29> lis = list(map(int, input().split()))</line-29>
<line-30> lis = sorted(lis)</line-30>
<line-31> res = 1</line-31>
<line-32> for i in range(n):</line-32>
<line-33> zhi = f[n-1]//f[k-1]//f[n-k]</line-33>
<line-34> if i >= k-1:</line-34>
<line-35> zhi = zhi - f[i]//f[k-1]//f[i+1-k]</line-35>
<line-36> if n-i-1 >= k-1:</line-36>
<line-37> zhi = zhi - f[n-i-1]//f[k-1]//f[n-i-k]</line-37>
<line-38> zhi = zhi % (modn-1)</line-38>
<line-39> # print(zhi)</line-39>
<line-40> res = res * qPow(lis[i], zhi) % modn</line-40>
<line-42></line-42>
<line-43>__starting_point()</line-43>
|
{"code": "<line-2>modn = 1000000007</line-2>\n<line-41> print(res)</line-41>", "lines": [2, 41]}
#### 0
|
<line-1>arr = list(input())</line-1>
<line-3>ans = list()</line-3>
<line-4>#for i in arr:</line-4>
<line-5> #ans.append(ord(i)-96)</line-5>
<line-6>li = ['b','d','f','h','j','l','n','p','r','t','v','x','z']</line-6>
<line-7>s = set(arr)</line-7>
<line-8>temp = s.intersection(li)</line-8>
<line-9>for _ in range(int(input())):</line-9>
<line-10> x,y = list(map(int,input().split()))</line-10>
<line-11> li = list(temp)</line-11>
<line-12> #s = set()</line-12>
<line-13> c=0</line-13>
<line-14> for i in range(x-1,y):</line-14>
<line-15> if arr[i] in li:</line-15>
<line-16> c+=1 </line-16>
<line-17> li.remove(arr[i])</line-17>
<line-18> if len(li)==0:</line-18>
<line-20> print(c)</line-20>
|
{"code": "<line-2>n = len(arr)</line-2>\n<line-19> break</line-19>", "lines": [2, 19]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> a,b,c=map(int,input().split())</line-3>
<line-4> p=(c//a)*a+b</line-4>
<line-5> if p<=c:</line-5>
<line-6> print(p)</line-6>
<line-8> print(((c//a)-1)*a+b)</line-8>
|
{"code": "<line-2>for t in range(int(input())):</line-2>\n<line-7> else:</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>#include<sdg.h></line-1>
<line-3> s=input()</line-3>
<line-4> n=len(s)</line-4>
<line-5> if n==1:</line-5>
<line-6> if s[0].isalpha(): print("-32")</line-6>
<line-7> else: print(0)</line-7>
<line-8> else:</line-8>
<line-9> num,ch=0,0</line-9>
<line-10> p,q=0,0</line-10>
<line-11> c=1</line-11>
<line-12> x=s[0]</line-12>
<line-13> ans=""</line-13>
<line-14> for i in range(1,n):</line-14>
<line-15> if s[i-1]==s[i]:</line-15>
<line-16> c+=1</line-16>
<line-17> if i==n-1:</line-17>
<line-18> ans+=s[i-1]</line-18>
<line-19> ch+=1</line-19>
<line-20> if c>1:</line-20>
<line-21> ans+=str(c)</line-21>
<line-22> num+=1</line-22>
<line-23> c=1</line-23>
<line-24> else:</line-24>
<line-25> ans+=s[i-1]</line-25>
<line-26> ch+=1</line-26>
<line-27> if c>1:</line-27>
<line-28> ans+=str(c)</line-28>
<line-29> num+=1</line-29>
<line-30> c=1</line-30>
<line-31> if i==n-1:</line-31>
<line-32> ans+=s[i]</line-32>
<line-33> ch+=1</line-33>
<line-34> #print(ans,num,ch)</line-34>
<line-36> print(sol)</line-36>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-35> sol=(n*8)-((num*32)+(ch*8))</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>def update(index, value, bi_tree):</line-1>
<line-3> bi_tree[index] += value</line-3>
<line-4> index += index & -index</line-4>
<line-5></line-5>
<line-6></line-6>
<line-7>def get_sum(index, bi_tree):</line-7>
<line-8> ans = 0</line-8>
<line-9> while index > 0:</line-9>
<line-10> ans += bi_tree[index]</line-10>
<line-11> index -= index & -index</line-11>
<line-12></line-12>
<line-13> return ans</line-13>
<line-14></line-14>
<line-15></line-15>
<line-16>def get_range_sum(left, right, bi_tree):</line-16>
<line-17> ans = get_sum(right, bi_tree) - get_sum(left - 1, bi_tree)</line-17>
<line-18> return ans</line-18>
<line-19></line-19>
<line-20></line-20>
<line-21>def solve(x):</line-21>
<line-22> s = set()</line-22>
<line-23> res = 1</line-23>
<line-24> i = 2</line-24>
<line-25> while (i * i <= x):</line-25>
<line-26> count = 0</line-26>
<line-27> while (x % i == 0):</line-27>
<line-28> x = x // i</line-28>
<line-29> count += 1</line-29>
<line-30> if (count % 2):</line-30>
<line-31> s.add(i)</line-31>
<line-32> i += 1</line-32>
<line-33> if (x > 0):</line-33>
<line-34> s.add(x)</line-34>
<line-35> return s</line-35>
<line-36></line-36>
<line-37></line-37>
<line-38>n = int(input())</line-38>
<line-39>l = [0] + [int(i) for i in input().split()]</line-39>
<line-40>bit = [[0 for i in range(n + 1)] for i in range(101)]</line-40>
<line-41></line-41>
<line-42>for i in range(1, n + 1):</line-42>
<line-43> s = solve(l[i])</line-43>
<line-44> for j in s:</line-44>
<line-45> update(i, 1, bit[j])</line-45>
<line-46></line-46>
<line-47>q = int(input())</line-47>
<line-48>for i in range(q):</line-48>
<line-49> k, a, b = [int(i) for i in input().split()]</line-49>
<line-50> if (k == 1):</line-50>
<line-51> f = 1</line-51>
<line-52> for i in range(2, 100):</line-52>
<line-53> res = get_range_sum(a, b, bit[i])</line-53>
<line-54> if (res % 2):</line-54>
<line-55> f = 0</line-55>
<line-56> break</line-56>
<line-57> if (f):</line-57>
<line-58> print("YES")</line-58>
<line-59> else:</line-59>
<line-60> print("NO")</line-60>
<line-61> else:</line-61>
<line-62> s = solve(b)</line-62>
<line-64> update(a, 1, bit[j])</line-64>
|
{"code": "<line-2> while index < len(bi_tree):</line-2>\n<line-63> for j in s:</line-63>", "lines": [2, 63]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-2></line-2>
<line-4>from collections import deque,defaultdict</line-4>
<line-5>from math import ceil,floor,inf,sqrt,factorial,gcd,log</line-5>
<line-6>from copy import deepcopy</line-6>
<line-7>ii1=lambda:int(stdin.readline().strip())</line-7>
<line-8>is1=lambda:stdin.readline().strip()</line-8>
<line-9>iia=lambda:list(map(int,stdin.readline().strip().split()))</line-9>
<line-10>isa=lambda:stdin.readline().strip().split()</line-10>
<line-11>mod=1000000007</line-11>
<line-12></line-12>
<line-13>for _ in range(ii1()):</line-13>
<line-14> n,l=iia()</line-14>
<line-15> if n==1:</line-15>
<line-16> print(l)</line-16>
<line-17> elif n==2:</line-17>
<line-18> print(int(log2(10))+1)</line-18>
<line-20> print(ceil(l/(n+1)))</line-20>
|
{"code": "<line-3>from sys import stdin,stdout</line-3>\n<line-19> else:</line-19>", "lines": [3, 19]}
#### 0
|
<line-1>import math</line-1>
<line-3> n=int(input())</line-3>
<line-4> s=int(math.sqrt(n))</line-4>
<line-5> ans=0</line-5>
<line-6> for i in range(1,s+1):</line-6>
<line-7> ans+=(n//i)</line-7>
<line-8> ans=ans*2-(s*s)</line-8>
<line-10> print(str(ans//g)+"/"+str(n*n//g)) </line-10>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-9> g=math.gcd(n*n,ans)</line-9>", "lines": [2, 9]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>import numpy as np</line-3>
<line-4>import sys</line-4>
<line-5></line-5>
<line-6>def findSeq(n, s, k, m, M):</line-6>
<line-7> midInd = n // 2</line-7>
<line-8> seqs = []</line-8>
<line-9> for ind in range(midInd + 2, midInd - 3, -1):</line-9>
<line-10> if ind >= n or ind < 0:</line-10>
<line-11> continue </line-11>
<line-12> seq = genBestSeq(n, ind, m, M, s)</line-12>
<line-13> if seq is not -1 and testSeq(k, seq):</line-13>
<line-14> seqs.append(list(seq))</line-14>
<line-15> if len(seqs) == 0:</line-15>
<line-16> return -1</line-16>
<line-17> return min(seqs)</line-17>
<line-18></line-18>
<line-19>#def findSeq(n, s, k, m, M):</line-19>
<line-20># midInd = n // 2</line-20>
<line-21># if k <= midInd: #and (n % 2 == 1 or s < m * midInd + M * (n - midInd)):</line-21>
<line-22># return genBestSeq(n, midInd + 1, m, M, s) </line-22>
<line-23># elif k > midInd + 1 and n % 2 == 1:</line-23>
<line-24># return -1</line-24>
<line-25># return genBestSeq(n, midInd, m, M, s)</line-25>
<line-26></line-26>
<line-27>def genBestSeq(n, diffInd, m, M, s):</line-27>
<line-28> #inc = M - m - 1</line-28>
<line-29> arr = np.full((n,), m)</line-29>
<line-30> arr[diffInd:] += 1</line-30>
<line-31> #remainder = s - np.sum(arr)</line-31>
<line-32> #if remainder < 0:</line-32>
<line-33> # return -1</line-33>
<line-34></line-34>
<line-35> #nFull, remainder = divmod(remainder, inc)</line-35>
<line-36> #if nFull > n or (nFull == n and remainder > 0):</line-36>
<line-37> # return -1</line-37>
<line-38></line-38>
<line-39> #addingInd = n - nFull -1</line-39>
<line-40> #arr[addingInd + 1:] += inc</line-40>
<line-41> #arr[addingInd] += remainder</line-41>
<line-42> #return arr</line-42>
<line-43> s = s - np.sum(arr)</line-43>
<line-44> if s < 0:</line-44>
<line-45> return -1</line-45>
<line-46> inc = M - m - 1</line-46>
<line-47> ind = n - 1</line-47>
<line-48> while (ind >= 0):</line-48>
<line-49> z = min(inc, s)</line-49>
<line-50> arr[ind] += z</line-50>
<line-51> s -= z</line-51>
<line-52> ind -= 1</line-52>
<line-53> if s != 0:</line-53>
<line-54> return -1</line-54>
<line-55> return arr</line-55>
<line-56></line-56>
<line-57>def testSeq(k, seq):</line-57>
<line-58> seq = sorted(seq)</line-58>
<line-59> n = len(seq)</line-59>
<line-60> if n % 2 == 1:</line-60>
<line-61> median = seq[n // 2]</line-61>
<line-62> else:</line-62>
<line-63> median = (seq[n // 2 - 1] + seq[n // 2]) / 2</line-63>
<line-64> seq.pop(n % k)</line-64>
<line-65> seq.pop(k - 1)</line-65>
<line-66> return (median != seq[(n - 2) // 2]) </line-66>
<line-67> </line-67>
<line-68></line-68>
<line-69>def __starting_point():</line-69>
<line-70> nCases = int(input())</line-70>
<line-71> answers = []</line-71>
<line-72> #ks = []</line-72>
<line-73> for i in range(nCases):</line-73>
<line-74> #nums = [int(val) for val in input().split()]</line-74>
<line-75> #ks.append(nums[2])</line-75>
<line-76> #answers.append(findSeq(*nums))</line-76>
<line-77> answers.append(findSeq(*(int(val) for val in input().split())))</line-77>
<line-78> ans = answers[-1]</line-78>
<line-79> if not isinstance(ans, int):</line-79>
<line-80> print(*ans, sep=' ')</line-80>
<line-81> else:</line-81>
<line-82> print(ans)</line-82>
<line-83> #for i, ans in enumerate(answers):</line-83>
<line-84></line-84>
<line-85> #for ans in answers:</line-85>
<line-86> # if isinstance(ans, np.ndarray):</line-86>
<line-87> # print(*ans, sep=' ')</line-87>
<line-88> # else:</line-88>
<line-90></line-90>
<line-91>__starting_point()</line-91>
|
{"code": "<line-2># cook your dish here</line-2>\n<line-89> # print(ans)</line-89>", "lines": [2, 89]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>counts=dict()</line-3>
<line-4>z=0</line-4>
<line-5>upper=None</line-5>
<line-6>for i in range(0,n):</line-6>
<line-7> a,h= [int(num) for num in input().split()]</line-7>
<line-8> counts[a]=h</line-8>
<line-9>for key,count in counts.items():</line-9>
<line-10> c=0</line-10>
<line-11> x=key-count</line-11>
<line-12> y=key+count</line-12>
<line-13> c1=0</line-13>
<line-14> c2=0</line-14>
<line-15> for j in counts.keys():</line-15>
<line-16> if j==key:</line-16>
<line-17> continue</line-17>
<line-18> else:</line-18>
<line-19> if x<=j<=key:</line-19>
<line-20> c1=0</line-20>
<line-21> break</line-21>
<line-22> else:</line-22>
<line-23> c1=1</line-23>
<line-24> for j in counts.keys():</line-24>
<line-25> if j==key:</line-25>
<line-26> continue</line-26>
<line-27> else:</line-27>
<line-28> if key<=j<=y:</line-28>
<line-29> c2=0</line-29>
<line-30> break</line-30>
<line-31> else:</line-31>
<line-32> c2=1</line-32>
<line-33> if c2==0 and c1==1:</line-33>
<line-34> if upper is None:</line-34>
<line-35> z=z+c1</line-35>
<line-36> upper=key</line-36>
<line-37> else:</line-37>
<line-38> if x>=upper:</line-38>
<line-39> z=z+c1</line-39>
<line-40> upper=key</line-40>
<line-41> else:</line-41>
<line-42> z=z+c2</line-42>
<line-43> upper=key</line-43>
<line-44> elif c2==1 and c1==0:</line-44>
<line-45> if upper is None:</line-45>
<line-46> z=z+c2</line-46>
<line-47> upper=y</line-47>
<line-48> else:</line-48>
<line-49> if upper<=key:</line-49>
<line-50> z=z+c2</line-50>
<line-51> upper=y</line-51>
<line-52> else:</line-52>
<line-53> z=z+c1</line-53>
<line-54> upper=y</line-54>
<line-55> elif c2==1 and c1==1:</line-55>
<line-56> if upper is None:</line-56>
<line-57> z=z+c1</line-57>
<line-58> upper=key</line-58>
<line-59> else:</line-59>
<line-60> if x>=upper:</line-60>
<line-61> z=z+c1</line-61>
<line-62> upper=key</line-62>
<line-63> else:</line-63>
<line-64> if upper<=key:</line-64>
<line-65> z=z+c2</line-65>
<line-66> upper=y</line-66>
<line-67> else:</line-67>
<line-68> z=z+0</line-68>
<line-69> upper=y</line-69>
<line-70> else:</line-70>
<line-71> z=z+0</line-71>
<line-72> upper=key</line-72>
<line-73>if len(counts)==1:</line-73>
<line-74> print(1)</line-74>
<line-76> print(z)</line-76>
|
{"code": "<line-2>n=int(input())</line-2>\n<line-75>else:</line-75>", "lines": [2, 75]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>num=[1,1]</line-3>
<line-4>for i in range(2,n+1):</line-4>
<line-6>print(num[n])</line-6>
|
{"code": "<line-2>modulo=15746</line-2>\n<line-5> num.append((num[i-1]+num[i-2])%modulo)</line-5>", "lines": [2, 5]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> m,n=list(map(int,input().split()))</line-3>
<line-4> a=[int(i) for i in input().split()]</line-4>
<line-5> l=-1</line-5>
<line-6> for i in range(n-1,-1,-1):</line-6>
<line-7> if a[i]==m:</line-7>
<line-8> l=i</line-8>
<line-9> break</line-9>
<line-10> f=-1</line-10>
<line-11> for i in range(0,n):</line-11>
<line-12> if a[i]==m:</line-12>
<line-13> f=i</line-13>
<line-15> print(l-f)</line-15>
<line-16> </line-16>
<line-17> </line-17>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-14> break</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>def detect_triangle(adj): </line-1>
<line-3> for y in adj[x]:</line-3>
<line-4> if not set(adj[x]).isdisjoint(adj[y]):</line-4>
<line-5> return True</line-5>
<line-6></line-6>
<line-7> </line-7>
<line-8>for _ in range(int(input())):</line-8>
<line-9> n,m=list(map(int,input().split()))</line-9>
<line-10> graph=[[] for i in range(n)]</line-10>
<line-11> for i in range(m):</line-11>
<line-12> u,v=list(map(int,input().split()))</line-12>
<line-13> graph[u-1].append(v-1)</line-13>
<line-14> graph[v-1].append(u-1)</line-14>
<line-15> h=[] </line-15>
<line-16> for i in range(len(graph)):</line-16>
<line-17> h.append(len(graph[i]))</line-17>
<line-18> h1=max(h) </line-18>
<line-19> if h1>=3:</line-19>
<line-20> print(h1)</line-20>
<line-21> continue</line-21>
<line-22> if detect_triangle(graph):</line-22>
<line-23> print(3)</line-23>
<line-25> print(h1) # cook your dish here</line-25>
|
{"code": "<line-2> for x in range(len(adj)):</line-2>\n<line-24> continue</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>def C(n):</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>def sol():</line-5>
<line-6> equal, mini = False, min(N,M)</line-6>
<line-7> total_ways = 2*C(N * M)</line-7>
<line-8> if N==M:</line-8>
<line-9> equal = True</line-9>
<line-10> ways = 0</line-10>
<line-11> if not equal:</line-11>
<line-12> ways = (N*C(M)+M*C(N))</line-12>
<line-13> diag = 0</line-13>
<line-14> for i in range(2, mini+1):</line-14>
<line-15> diag += 2*C(i)</line-15>
<line-16> for i in range(mini+1,max(N,M)):</line-16>
<line-17> diag += C(mini)</line-17>
<line-18> diag *= 2</line-18>
<line-19> ways += diag</line-19>
<line-20> ways *= 2</line-20>
<line-21> else:</line-21>
<line-22> ways = (N*C(M)+M*C(N))</line-22>
<line-23> diag = 0</line-23>
<line-24> for i in range(2, mini):</line-24>
<line-25> diag += 2*C(i)</line-25>
<line-26> diag += C(mini)</line-26>
<line-27> diag *= 2</line-27>
<line-28> ways += diag</line-28>
<line-29> ways *=2</line-29>
<line-30> safe = total_ways - ways</line-30>
<line-31> l, r, t, d = Y-1, M-Y, X-1, N-X</line-31>
<line-32> safe_add, to_remove = 0, 0</line-32>
<line-33></line-33>
<line-34> for i in range(1,N+1):</line-34>
<line-35> for j in range(1, M+1):</line-35>
<line-36> if i==X or j==Y or abs(i-X)==abs(j-Y):</line-36>
<line-37> continue</line-37>
<line-38> else:</line-38>
<line-39> to_remove += 1</line-39>
<line-40></line-40>
<line-41> if l>0 and r>0 and t>0 and d>0:</line-41>
<line-42> dtl, dtr, dbl, dbr = min(l,t), min(r,t), min(l,d), min(r,d)</line-42>
<line-43> safe_add += dtl*dbr*2 + dtr*dbl*2</line-43>
<line-44> safe_add += t*d*2</line-44>
<line-45> safe_add += l*r*2</line-45>
<line-46> elif l>0 and r>0:</line-46>
<line-47> safe_add += l*r*2</line-47>
<line-48> elif t>0 and d>0:</line-48>
<line-49> safe_add += t*d*2</line-49>
<line-50></line-50>
<line-51> safe += safe_add - to_remove*2</line-51>
<line-52></line-52>
<line-53> return safe</line-53>
<line-54></line-54>
<line-55></line-55>
<line-56>T = int(input())</line-56>
<line-57>for _ in range(T):</line-57>
<line-59> print(sol())</line-59>
|
{"code": "<line-2> return n*(n-1)//2</line-2>\n<line-58> N, M, X, Y = [int(x) for x in input().split()]</line-58>", "lines": [2, 58]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(t):</line-3>
<line-5> print(k//n)</line-5>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-4> (n,k)=tuple(map(int,input().split()))</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>n,k=[int(x) for x in input().split()]</line-1>
<line-3>ans=0</line-3>
<line-4>for i in range(n-1):</line-4>
<line-5> for j in range(i+1,n):</line-5>
<line-6> if(abs(a[i]-a[j])>=k):</line-6>
<line-8>print(ans)</line-8>
|
{"code": "<line-2>a=[int(x) for x in input().split()]</line-2>\n<line-7> ans+=1</line-7>", "lines": [2, 7]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(n):</line-3>
<line-4> S, SG, FG, D, T = map(int, input().split())</line-4>
<line-5> speed = (D*180)/T + S</line-5>
<line-6> if abs(SG-speed) == abs(FG-speed):</line-6>
<line-7> print('DRAW')</line-7>
<line-8> elif abs(SG-speed) > abs(FG-speed):</line-8>
<line-9> print('FATHER')</line-9>
<line-11> print('SEBI')</line-11>
|
{"code": "<line-2>n=int(input())</line-2>\n<line-10> else:</line-10>", "lines": [2, 10]}
#### 0
|
<line-1># By Prathmesh Maurya</line-1>
<line-3>while(t!=0):</line-3>
<line-4> t-=1</line-4>
<line-5> n=eval(input())</line-5>
<line-6> if n%2 == 0:</line-6>
<line-7> print(n*4)</line-7>
<line-8> elif n%4==3:</line-8>
<line-9> print(n)</line-9>
<line-11> print(n*2)</line-11>
|
{"code": "<line-2>t=eval(input())</line-2>\n<line-10> else:</line-10>", "lines": [2, 10]}
#### 0
|
<line-1> </line-1>
<line-2>for __ in range(int(input())):</line-2>
<line-4> arr=list(map(int,input().split()))</line-4>
<line-5> s=set(arr)</line-5>
<line-6> mex=-1</line-6>
<line-7> ele=1</line-7>
<line-8> for i in range(1,n+1):</line-8>
<line-9> if i not in s:</line-9>
<line-10> mex = i</line-10>
<line-11> break</line-11>
<line-12> if m>mex:</line-12>
<line-13> print(-1)</line-13>
<line-14> elif m==mex:</line-14>
<line-15> print(n)</line-15>
<line-16> else:</line-16>
<line-18> print(n-c)</line-18>
<line-19> </line-19>
<line-20> </line-20>
<line-21> </line-21>
|
{"code": "<line-3> n,m=map(int,input().split())</line-3>\n<line-17> c=arr.count(m)</line-17>", "lines": [3, 17]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> c = list(map(int, input().split()))</line-3>
<line-4> d = {}</line-4>
<line-5> d[0] = -1</line-5>
<line-6> parity = 0</line-6>
<line-7> ans = 0</line-7>
<line-8> for i in range(n):</line-8>
<line-9> parity ^= 1 << (c[i]-1)</line-9>
<line-10> for t in range(30):</line-10>
<line-11> x = parity^(1<<t)</line-11>
<line-12> if(x in d.keys()):</line-12>
<line-13> ans = max(ans, i - d[x])</line-13>
<line-14> if parity not in d.keys():</line-14>
<line-16> print(ans//2)</line-16>
|
{"code": "<line-2> n = int(input())</line-2>\n<line-15> d[parity] = i</line-15>", "lines": [2, 15]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>import math</line-3>
<line-4></line-4>
<line-5>def main(grid):</line-5>
<line-6> ans=0</line-6>
<line-7> for i in range(len(grid)):</line-7>
<line-8> for j in range(len(grid[0])):</line-8>
<line-9> first_point=grid[i][j]</line-9>
<line-10> for k in range(j+1,len(grid[0])):</line-10>
<line-11> second_point=grid[i][k]</line-11>
<line-12> if first_point==second_point:</line-12>
<line-13> dist=k-j</line-13>
<line-14> if i+dist<len(grid):</line-14>
<line-15> thrid_point=grid[i+dist][j]</line-15>
<line-16> fourth_point=grid[i+dist][k] </line-16>
<line-17> if second_point==thrid_point and second_point==fourth_point:</line-17>
<line-18> ans+=1</line-18>
<line-19> return ans</line-19>
<line-20> </line-20>
<line-21>test=int(input())</line-21>
<line-22>for _ in range(test):</line-22>
<line-23> n,m=input().split()</line-23>
<line-24> n=int(n)</line-24>
<line-25> arr=[]</line-25>
<line-26> for b in range(n):</line-26>
<line-28> print(main(arr))</line-28>
|
{"code": "<line-2>import sys</line-2>\n<line-27> arr.append(list(input()))</line-27>", "lines": [2, 27]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> tr=int(input())</line-3>
<line-4> trl=list(map(int,input().split()))</line-4>
<line-5> dr = int(input())</line-5>
<line-6> drl = list(map(int, input().split()))</line-6>
<line-7> ts = int(input())</line-7>
<line-8> tsl = list(map(int, input().split()))</line-8>
<line-9> ds = int(input())</line-9>
<line-10> dsl = list(map(int, input().split()))</line-10>
<line-11> for item in tsl:</line-11>
<line-12> if item in trl:</line-12>
<line-13> res=1</line-13>
<line-14> continue</line-14>
<line-15> else:</line-15>
<line-16> res=0</line-16>
<line-17> break</line-17>
<line-18> for item1 in dsl:</line-18>
<line-19> if item1 in drl:</line-19>
<line-20> res1=1</line-20>
<line-21> continue</line-21>
<line-22> else:</line-22>
<line-23> res1=0</line-23>
<line-24> break</line-24>
<line-25> if res==1 and res1==1:</line-25>
<line-26> print("yes")</line-26>
<line-28> print("no")</line-28>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-27> else:</line-27>", "lines": [2, 27]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> str_2=""</line-3>
<line-4> lst=[]</line-4>
<line-5> for i in range(L//4):</line-5>
<line-6> str_1 = "abcdefghijklmnop"</line-6>
<line-7> S_1=S[(i*4):(4*(i+1))]</line-7>
<line-8> for j in range(4):</line-8>
<line-9> if(S_1[j]=="1"):</line-9>
<line-10> str_1=str_1[len(str_1)//2:len(str_1)]</line-10>
<line-11> else:</line-11>
<line-12> str_1 = str_1[0:len(str_1) // 2]</line-12>
<line-13> str_2=str_2+str_1</line-13>
<line-14> print(str_2)</line-14>
<line-15></line-15>
<line-16>T=int(input())</line-16>
<line-17>for i in range(T):</line-17>
<line-18> L=int(input())</line-18>
<line-20> decode(L,S)</line-20>
|
{"code": "<line-2>def decode(L,S):</line-2>\n<line-19> S=input()</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> array = []</line-3>
<line-4> tot = []</line-4>
<line-5> for _ in range(n):</line-5>
<line-6> temp = list(map(int,input().split()))</line-6>
<line-7> aa = temp[0]</line-7>
<line-8> del(temp[0])</line-8>
<line-9> temp.sort()</line-9>
<line-10> temp.insert(0,aa)</line-10>
<line-11> array.append(temp)</line-11>
<line-12> dic = {}</line-12>
<line-13> array.sort(reverse=True)</line-13>
<line-14> for i in array:</line-14>
<line-15> del(i[0])</line-15>
<line-16> for i in range(1,k+1):</line-16>
<line-17> dic[i] = False</line-17>
<line-18> count = 0</line-18>
<line-19> for i in array:</line-19>
<line-20> count += 1</line-20>
<line-21> # print(count,tot)</line-21>
<line-22> for j in i:</line-22>
<line-23> if(dic[j]==True):</line-23>
<line-24> pass</line-24>
<line-25> else:</line-25>
<line-26> tot.append(j)</line-26>
<line-27> dic[j]=True</line-27>
<line-28> if(len(tot)==k):</line-28>
<line-29> break</line-29>
<line-30> if(len(tot)!=k):</line-30>
<line-31> print("sad")</line-31>
<line-32> elif(count!=n):</line-32>
<line-33> print("some")</line-33>
<line-35> print("all")</line-35>
|
{"code": "<line-2> n,k = list(map(int,input().split()))</line-2>\n<line-34> else:</line-34>", "lines": [2, 34]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(test):</line-3>
<line-4> n=int(input())</line-4>
<line-5> n=list(bin(n))</line-5>
<line-7> print(ans-1)</line-7>
|
{"code": "<line-2>test=int(input())</line-2>\n<line-6> ans=n.count('1')</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>def g(a,b):</line-5>
<line-6> if (a > b):</line-6>
<line-7> tmp = a</line-7>
<line-8> a = b</line-8>
<line-9> b = tmp</line-9>
<line-10> if (b == a):</line-10>
<line-11> return 0</line-11>
<line-12> if (b % a == 0):</line-12>
<line-13> return int(b/a)-1</line-13>
<line-14> r = g(b%a,a)</line-14>
<line-15> q = int(b/a)</line-15>
<line-16> if (r >= q):</line-16>
<line-17> return q-1</line-17>
<line-18> else:</line-18>
<line-19> return q</line-19>
<line-20></line-20>
<line-21>def mex(x):</line-21>
<line-22> n = len(list(x.keys()))</line-22>
<line-23> for i in range(n):</line-23>
<line-24> if (i not in x):</line-24>
<line-25> return i</line-25>
<line-26> return i</line-26>
<line-27></line-27>
<line-28>def g2(a,b):</line-28>
<line-29> if (a == b):</line-29>
<line-30> return 0</line-30>
<line-31> if (a > b):</line-31>
<line-32> tmp = a</line-32>
<line-33> a = b</line-33>
<line-34> b = tmp</line-34>
<line-35> if (b % a == 0):</line-35>
<line-36> return int(b/a)-1</line-36>
<line-37> q = int(b/a)</line-37>
<line-38> x = {}</line-38>
<line-39> r = b % a</line-39>
<line-40> for i in range(q):</line-40>
<line-41> x[g2(r+i*a,a)] = True</line-41>
<line-42> return mex(x)</line-42>
<line-43></line-43>
<line-44>#print(str(g(6,33))+" "+str(g2(6,33)))</line-44>
<line-45></line-45>
<line-46>while (t):</line-46>
<line-47></line-47>
<line-48> n = int(input())</line-48>
<line-49> x = 0</line-49>
<line-50> while (n):</line-50>
<line-51> line = input().split()</line-51>
<line-52> a = int(line[0])</line-52>
<line-53> b = int(line[1])</line-53>
<line-54> x ^= g(a,b)</line-54>
<line-55> n -= 1</line-55>
<line-56> if (x):</line-56>
<line-57> sys.stdout.write("YES\n")</line-57>
<line-58> else:</line-58>
<line-59> sys.stdout.write("NO\n")</line-59>
<line-61> t -= 1</line-61>
|
{"code": "<line-3>t = int(input())</line-3>\n<line-60> #print(str(g(a,b)) + \" \" + str(g2(a,b)))</line-60>", "lines": [3, 60]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n=int(input())</line-3>
<line-4> p=1</line-4>
<line-5> l=n-1</line-5>
<line-6> for j in range(n):</line-6>
<line-7> for k in range(l):</line-7>
<line-8> print(" ",end='')</line-8>
<line-9> for k in range(p):</line-9>
<line-10> print("*",end='')</line-10>
<line-11> print()</line-11>
<line-12> for k in range(l):</line-12>
<line-13> print(" ",end='')</line-13>
<line-14> for k in range(p):</line-14>
<line-15> print("*",end='')</line-15>
<line-16> print()</line-16>
<line-18> l-=1</line-18>
<line-19> </line-19>
|
{"code": "<line-2>for i in range(int(input())):</line-2>\n<line-17> p+=2</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>import sys</line-1>
<line-2> </line-2>
<line-4>s=sys.stdin.readline().split()</line-4>
<line-5>sky=list(map(int,s))</line-5>
<line-6>sky.reverse()</line-6>
<line-7>cuts=0</line-7>
<line-8>change=0</line-8>
<line-9>t=False</line-9>
<line-10>i=1</line-10>
<line-11> </line-11>
<line-12>while i<len(sky):</line-12>
<line-13> if sky[i]<=sky[i-1]:</line-13>
<line-14> for j in range(i-1,-1,-1):</line-14>
<line-15> </line-15>
<line-16> if sky[j]<=sky[i]-(i-j):</line-16>
<line-17> break</line-17>
<line-18> else:</line-18>
<line-19> change+=sky[j]-(sky[i]-(i-j))</line-19>
<line-20> </line-20>
<line-21> if change>=sky[i]:</line-21>
<line-22> change=sky[i]</line-22>
<line-23> t=True</line-23>
<line-24> break</line-24>
<line-25> </line-25>
<line-26> cuts+=change</line-26>
<line-27> </line-27>
<line-28> if t:</line-28>
<line-29> del sky[i]</line-29>
<line-30> t=False</line-30>
<line-31> i-=1</line-31>
<line-32> </line-32>
<line-33> else:</line-33>
<line-34> for j in range(i-1,-1,-1):</line-34>
<line-35> if sky[j]<sky[i]-(i-j):</line-35>
<line-36> break</line-36>
<line-37> else:</line-37>
<line-38> sky[j]=sky[i]-(i-j)</line-38>
<line-39> i+=1</line-39>
<line-40> </line-40>
<line-42> </line-42>
<line-43>print(cuts)</line-43>
|
{"code": "<line-3>num=int(sys.stdin.readline())</line-3>\n<line-41> change=0</line-41>", "lines": [3, 41]}
#### 0
|
<line-1></line-1>
<line-2>def main():</line-2>
<line-4> while (t):</line-4>
<line-5> m, n = map(int, input().split())</line-5>
<line-6> a , b= bin(m)[2:],bin(n)[2:]</line-6>
<line-7> #print(a,b)</line-7>
<line-8> max = m^n</line-8>
<line-9> if len(a)>len(b):</line-9>
<line-10> diff =len(a)-len(b)</line-10>
<line-11> b= ("0"*diff)+b</line-11>
<line-12> #print(b)</line-12>
<line-13> elif len(a)<len(b):</line-13>
<line-14> diff =len(b)-len(a)</line-14>
<line-15> a= ("0"*diff)+a</line-15>
<line-16> #print(a)</line-16>
<line-17> ll = len(b)</line-17>
<line-18> count= 0</line-18>
<line-19> for i in range(ll-1):</line-19>
<line-20> s= b[ll-1] + b</line-20>
<line-21> s= s[:ll]</line-21>
<line-22></line-22>
<line-23> tt= m^ int(s,2)</line-23>
<line-24> #print(m,s,tt)</line-24>
<line-25> if tt>max:</line-25>
<line-26> max =tt</line-26>
<line-27> count= i+1</line-27>
<line-28> b=s</line-28>
<line-29></line-29>
<line-30> print(count,max)</line-30>
<line-31> t-=1</line-31>
<line-32></line-32>
<line-33>def __starting_point():</line-33>
<line-35>__starting_point()</line-35>
|
{"code": "<line-3> t = int(input())</line-3>\n<line-34> main()</line-34>", "lines": [3, 34]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4> s = [x for x in input()]</line-4>
<line-5> </line-5>
<line-6> freq = {}</line-6>
<line-7> </line-7>
<line-8> for i in s:</line-8>
<line-9> if i in freq:</line-9>
<line-10> freq[i] += 1</line-10>
<line-11> else:</line-11>
<line-12> freq[i] = 1</line-12>
<line-13> </line-13>
<line-14> flag = 0</line-14>
<line-15> </line-15>
<line-16> for keys, values in freq.items():</line-16>
<line-17> if(values >= 2):</line-17>
<line-18> flag = 1</line-18>
<line-19> break</line-19>
<line-20> </line-20>
<line-21> if(flag == 0):</line-21>
<line-22> print("no")</line-22>
<line-24> print("yes")</line-24>
|
{"code": "<line-3>for _ in range(t):</line-3>\n<line-23> else:</line-23>", "lines": [3, 23]}
#### 0
|
<line-1>def main():</line-1>
<line-3> for t in range(T):</line-3>
<line-4> N,K = map(int, input().split())</line-4>
<line-5> W = list(map(int, input().split()))</line-5>
<line-6> W.sort()</line-6>
<line-7> if 2*K > N:</line-7>
<line-8> K = N - K</line-8>
<line-9> kid = sum(W[:K])</line-9>
<line-10> dad = sum(W[K:])</line-10>
<line-11></line-11>
<line-12> diff = dad - kid</line-12>
<line-13></line-13>
<line-14> print(diff)</line-14>
<line-15></line-15>
<line-16></line-16>
<line-17>def __starting_point():</line-17>
<line-19>__starting_point()</line-19>
|
{"code": "<line-2> T = int(input())</line-2>\n<line-18> main()</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>def eq_solve(v0, v1, u0, u1):</line-1>
<line-3> num = u1 - v1</line-3>
<line-4> if den != 0:</line-4>
<line-5> return num / den</line-5>
<line-6> return 1</line-6>
<line-7> </line-7>
<line-8>def solve(p, q, r, a, b, c, rs):</line-8>
<line-9> if p == a and q == b and r == c:</line-9>
<line-10> return rs</line-10>
<line-11> if rs >= 2:</line-11>
<line-12> return 3</line-12>
<line-13> res = 3</line-13>
<line-14> adds = [a - p, b - q, c - r]</line-14>
<line-15> muls = []</line-15>
<line-16> if p != 0:</line-16>
<line-17> muls.append(a / p)</line-17>
<line-18> if q != 0:</line-18>
<line-19> muls.append(b / q)</line-19>
<line-20> if r != 0:</line-20>
<line-21> muls.append(c / r)</line-21>
<line-22> muls.append(eq_solve(p, a, q, b))</line-22>
<line-23> muls.append(eq_solve(p, a, r, c))</line-23>
<line-24> muls.append(eq_solve(q, b, r, c))</line-24>
<line-25> msks = 2 ** 3</line-25>
<line-26> for msk in range(msks):</line-26>
<line-27> for add in adds:</line-27>
<line-28> np = p</line-28>
<line-29> nq = q</line-29>
<line-30> nr = r</line-30>
<line-31> if (msk & 1) > 0:</line-31>
<line-32> np += add</line-32>
<line-33> if (msk & 2) > 0:</line-33>
<line-34> nq += add</line-34>
<line-35> if (msk & 4) > 0:</line-35>
<line-36> nr += add</line-36>
<line-37> res = min(res, solve(np, nq, nr, a, b, c, rs + 1))</line-37>
<line-38> for mul in muls:</line-38>
<line-39> np = p</line-39>
<line-40> nq = q</line-40>
<line-41> nr = r</line-41>
<line-42> if (msk & 1) > 0:</line-42>
<line-43> np *= mul</line-43>
<line-44> if (msk & 2) > 0:</line-44>
<line-45> nq *= mul</line-45>
<line-46> if (msk & 4) > 0:</line-46>
<line-47> nr *= mul</line-47>
<line-48> res = min(res, solve(np, nq, nr, a, b, c, rs + 1))</line-48>
<line-49> return res</line-49>
<line-50> </line-50>
<line-51> </line-51>
<line-52> </line-52>
<line-53>t = int(input())</line-53>
<line-54> </line-54>
<line-55>while t > 0:</line-55>
<line-56> p, q, r = map(int, input().split())</line-56>
<line-57> a, b, c = map(int, input().split())</line-57>
<line-58> z = solve(p, q, r, a, b, c, 0)</line-58>
<line-60> t -= 1 </line-60>
|
{"code": "<line-2> den = u0 - v0</line-2>\n<line-59> print(z)</line-59>", "lines": [2, 59]}
#### 0
|
<line-1>from math import log10</line-1>
<line-3>def solve(n,k):</line-3>
<line-4> </line-4>
<line-5> mod=10**k</line-5>
<line-6> x=Decimal(n)</line-6>
<line-7> y=x*(x.log10())%1</line-7>
<line-8> p=str(pow(10,y))</line-8>
<line-9> c=0</line-9>
<line-10> first=''</line-10>
<line-11> for v in p:</line-11>
<line-12> if c==k:</line-12>
<line-13> break</line-13>
<line-14> if v==".":</line-14>
<line-15> continue</line-15>
<line-16> first+=v</line-16>
<line-17> c+=1</line-17>
<line-18> last=str(pow(n,n,mod)).zfill(k)</line-18>
<line-19> return (first,last)</line-19>
<line-20>queries=[]</line-20>
<line-21>for _ in range(int(input())):</line-21>
<line-22> n,k=list(map(int,input().split( )))</line-22>
<line-23> queries.append((n,k))</line-23>
<line-25> print("%s %s"%(solve(n,k)))</line-25>
<line-26> </line-26>
<line-27> </line-27>
|
{"code": "<line-2>from decimal import Decimal</line-2>\n<line-24>for n,k in queries:</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>t = eval(input())</line-1>
<line-2></line-2>
<line-4> n = eval(input())</line-4>
<line-5> a = list(map(int, input().split()))</line-5>
<line-6> cnt = 2</line-6>
<line-7> cnt1 = 2</line-7>
<line-8> ll = len(a)</line-8>
<line-9> if ll < 3:</line-9>
<line-10> cnt1 = ll</line-10>
<line-11> else:</line-11>
<line-12> for j in range(2,ll):</line-12>
<line-13> if a[j-1] + a[j-2] == a[j]:</line-13>
<line-14> cnt += 1</line-14>
<line-15> cnt1 = max(cnt1, cnt)</line-15>
<line-16> else:</line-16>
<line-17> cnt1 = max(cnt1, cnt)</line-17>
<line-19> print(cnt1) </line-19>
|
{"code": "<line-3>for i in range(t):</line-3>\n<line-18> cnt = 2</line-18>", "lines": [3, 18]}
#### 0
|
<line-1></line-1>
<line-2></line-2>
<line-3>z = int(input())</line-3>
<line-5>while i < z:</line-5>
<line-6> n = int(input())</line-6>
<line-7> p = int(n**(0.5))</line-7>
<line-8> if p*(p+1) < n:</line-8>
<line-9> p += 1</line-9>
<line-10> # print("P", p)</line-10>
<line-11> x, y = 0, 0</line-11>
<line-12> q = 0</line-12>
<line-13> flag = True</line-13>
<line-14> if p*(p+1) == n:</line-14>
<line-15> # print("Even steps, nice")</line-15>
<line-16> q = p</line-16>
<line-17> else:</line-17>
<line-18> # remaining steps</line-18>
<line-19> q = p-1</line-19>
<line-20> flag = False</line-20>
<line-21> if q%2 :</line-21>
<line-22> # odd</line-22>
<line-23> x -= ((q+1)//2)</line-23>
<line-24> y += ((q+1)//2)</line-24>
<line-25> else :</line-25>
<line-26> x += (q//2)</line-26>
<line-27> y -= (q//2)</line-27>
<line-28> if flag:</line-28>
<line-29> print(x, y)</line-29>
<line-30> else:</line-30>
<line-31> # remaining steps</line-31>
<line-32> l = q*(q+1)</line-32>
<line-33> t = p*(p+1)</line-33>
<line-34> diff = t-l</line-34>
<line-35> </line-35>
<line-36></line-36>
<line-37> # print(x, y)</line-37>
<line-38> if x < 0:</line-38>
<line-39> # left</line-39>
<line-40> if n-l >= diff//2:</line-40>
<line-41> y *= (-1)</line-41>
<line-42> l += (diff//2)</line-42>
<line-43> x += (n-l)</line-43>
<line-44> else :</line-44>
<line-45> y -= (n-l)</line-45>
<line-46> </line-46>
<line-47> else:</line-47>
<line-48> # right</line-48>
<line-49> if n-l >= diff//2:</line-49>
<line-50> y *= (-1)</line-50>
<line-51> y += 1</line-51>
<line-52> l += (diff//2)</line-52>
<line-53> x -= (n-l)</line-53>
<line-54> else :</line-54>
<line-55> y += (n-l)</line-55>
<line-56> # print("Remaining steps: ", n-l)</line-56>
<line-58> i+=1 </line-58>
|
{"code": "<line-4>i = 0</line-4>\n<line-57> print(x, y)</line-57>", "lines": [4, 57]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n,m=[int(x)for x in input().rstrip().split()]</line-3>
<line-4> s=[]</line-4>
<line-5> for p in range(n):</line-5>
<line-6> s.append(10)</line-6>
<line-7> for c in range(m):</line-7>
<line-8> i,j,k=[int(x)for x in input().rstrip().split()]</line-8>
<line-9> for q in range(i-1,j):</line-9>
<line-11> print(sum(s)//n)</line-11>
<line-12> </line-12>
<line-13> </line-13>
<line-14> </line-14>
<line-15> </line-15>
|
{"code": "<line-2>for t in range(int(input())):</line-2>\n<line-10> s[q]=s[q]*k</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>from queue import PriorityQueue</line-1>
<line-3>rr=[]</line-3>
<line-4>cc=[]</line-4>
<line-5>speed={'S':3,'O':2,'F':1}</line-5>
<line-6>visited=set()</line-6>
<line-7>dp=[]</line-7>
<line-8></line-8>
<line-9>def qwerty(cur,x,y,f):</line-9>
<line-10> if f==0:</line-10>
<line-11> gg=rr[x][1]+y*rr[x][0]</line-11>
<line-12> while gg<cur:</line-12>
<line-13> gg+=(2*(n-1))*rr[x][0]</line-13>
<line-14> return gg-cur+rr[x][0]</line-14>
<line-15> elif f==1:</line-15>
<line-16> gg=rr[x][1]+(2*(n-1)-y)*rr[x][0]</line-16>
<line-17> while gg<cur:</line-17>
<line-18> gg+=(2*(n-1))*rr[x][0]</line-18>
<line-19> return gg-cur+rr[x][0]</line-19>
<line-20> elif f==2:</line-20>
<line-21> gg=cc[y][1]+x*cc[y][0]</line-21>
<line-22> while gg<cur:</line-22>
<line-23> gg+=(2*(m-1))*cc[y][0]</line-23>
<line-24> return gg-cur+cc[y][0] </line-24>
<line-25> elif f==3:</line-25>
<line-26> gg=cc[y][1]+(2*(m-1)-x)*cc[y][0]</line-26>
<line-27> while gg<cur:</line-27>
<line-28> gg+=(2*(m-1))*cc[y][0]</line-28>
<line-29> return gg-cur+cc[y][0]</line-29>
<line-30></line-30>
<line-31></line-31>
<line-32>dirx=[0, 0, 1, -1]</line-32>
<line-33>diry=[1, -1, 0, 0]</line-33>
<line-34></line-34>
<line-35>for i in range(m):</line-35>
<line-36> o=[x for x in input().split()]</line-36>
<line-37> o[0]=speed[o[0]]</line-37>
<line-38> o[1]=int(o[1])</line-38>
<line-39> rr.append(o)</line-39>
<line-40></line-40>
<line-41></line-41>
<line-42>for i in range(n):</line-42>
<line-43> o=[x for x in input().split()]</line-43>
<line-44> o[0]=speed[o[0]]</line-44>
<line-45> o[1]=int(o[1])</line-45>
<line-46> cc.append(o)</line-46>
<line-47></line-47>
<line-48></line-48>
<line-49>sx,sy,stt,dx,dy=list(map(int,input().split()))</line-49>
<line-50>sx-=1</line-50>
<line-51>sy-=1</line-51>
<line-52>dx-=1</line-52>
<line-53>dy-=1</line-53>
<line-54></line-54>
<line-55>for i in range(m):</line-55>
<line-56> dp.append([10**9]*n)</line-56>
<line-57></line-57>
<line-58>dp[sx][sy]=stt</line-58>
<line-59>pq = PriorityQueue()</line-59>
<line-60>pq.put((stt, sx, sy))</line-60>
<line-61>while not pq.empty():</line-61>
<line-62> #print(dp)</line-62>
<line-63> (t,cxx,cyy)=pq.get()</line-63>
<line-64> if (cxx,cyy) in visited:</line-64>
<line-65> continue</line-65>
<line-66> visited.add((cxx,cyy))</line-66>
<line-67> for i in range(len(dirx)):</line-67>
<line-68> nxx=cxx+dirx[i]</line-68>
<line-69> nyy=cyy+diry[i]</line-69>
<line-70> if nxx>=0 and nxx<m and nyy>=0 and nyy<n and (nxx,nyy) not in visited:</line-70>
<line-71> coo=qwerty(dp[cxx][cyy],cxx,cyy,i)</line-71>
<line-72> if coo+dp[cxx][cyy]<dp[nxx][nyy]:</line-72>
<line-73> dp[nxx][nyy]=coo+dp[cxx][cyy]</line-73>
<line-75></line-75>
<line-76>print(dp[dx][dy])</line-76>
<line-77></line-77>
<line-78></line-78>
<line-79></line-79>
<line-80></line-80>
<line-81></line-81>
<line-82></line-82>
<line-83> </line-83>
<line-84></line-84>
<line-85></line-85>
<line-86></line-86>
|
{"code": "<line-2>m,n=list(map(int,input().split()))</line-2>\n<line-74>\t\t\t\t\tpq.put((dp[nxx][nyy],nxx,nyy))</line-74>", "lines": [2, 74]}
#### 0
|
<line-1>import math</line-1>
<line-3>try:</line-3>
<line-4> import psyco</line-4>
<line-5> psyco.full()</line-5>
<line-6>except ImportError:</line-6>
<line-7> pass</line-7>
<line-8> </line-8>
<line-9>def isSharp(ang):</line-9>
<line-10> return ang > math.pi/4 + 0.00001</line-10>
<line-11> </line-11>
<line-12>def unitVector(p2, p1):</line-12>
<line-13> d0 = p2[0] - p1[0]</line-13>
<line-14> d1 = p2[1] - p1[1]</line-14>
<line-15> d = math.sqrt(d0*d0 + d1*d1)</line-15>
<line-16> if d != 0:</line-16>
<line-17> return [d0/d, d1/d]</line-17>
<line-18> return [0, 0]</line-18>
<line-19> </line-19>
<line-20>def compVectors(P):</line-20>
<line-21> V = []</line-21>
<line-22> for i in range(1,len(P)):</line-22>
<line-23> v = unitVector(P[i], P[i-1])</line-23>
<line-24> if v[0] == 0 and v[1] == 0:</line-24>
<line-25> return None</line-25>
<line-26> V.append(v)</line-26>
<line-27> return V</line-27>
<line-28> </line-28>
<line-29>def angle(v2, v1):</line-29>
<line-30> d = v2[0]*v1[0] + v2[1]*v1[1]</line-30>
<line-31> if d > 1:</line-31>
<line-32> d = 1</line-32>
<line-33> if d < -1:</line-33>
<line-34> d = -1</line-34>
<line-35> return math.acos(d)</line-35>
<line-36> </line-36>
<line-37>def compAngles(V):</line-37>
<line-38> A = []</line-38>
<line-39> for i in range(len(V)-1):</line-39>
<line-40> A.append(angle(V[i+1], V[i]))</line-40>
<line-41> return A</line-41>
<line-42> </line-42>
<line-43>def updateAngles(i, P, V, A):</line-43>
<line-44> if i-1 >= 0:</line-44>
<line-45> V[i-1] = unitVector(P[i], P[i-1])</line-45>
<line-46> if i+1 < len(P):</line-46>
<line-47> V[i] = unitVector(P[i+1], P[i])</line-47>
<line-48> if i-2 >= 0:</line-48>
<line-49> A[i-2] = angle(V[i-1], V[i-2])</line-49>
<line-50> if i-1 >= 0 and i+1 < len(P):</line-50>
<line-51> A[i-1] = angle(V[i], V[i-1])</line-51>
<line-52> if i+2 < len(P):</line-52>
<line-53> A[i] = angle(V[i+1], V[i])</line-53>
<line-54> </line-54>
<line-55>def checkMoves(check, P, V, A, filled):</line-55>
<line-56> for i in check:</line-56>
<line-57> if i < 0 or i >= len(P):</line-57>
<line-58> break</line-58>
<line-59> x, y = P[i]</line-59>
<line-60> for j in range(51):</line-60>
<line-61> for k in range(51):</line-61>
<line-62> P[i][0] = j</line-62>
<line-63> P[i][1] = k</line-63>
<line-64> if str(P[i]) in filled:</line-64>
<line-65> continue</line-65>
<line-66> updateAngles(i, P, V, A)</line-66>
<line-67> fixed = True</line-67>
<line-68> if i-2 >= 0:</line-68>
<line-69> if isSharp(A[i-2]):</line-69>
<line-70> fixed = False</line-70>
<line-71> if i-1 >= 0 and i-1 < len(A):</line-71>
<line-72> if isSharp(A[i-1]):</line-72>
<line-73> fixed = False</line-73>
<line-74> if i < len(A):</line-74>
<line-75> if isSharp(A[i]):</line-75>
<line-76> fixed = False</line-76>
<line-77> if fixed:</line-77>
<line-78> return True</line-78>
<line-79> P[i] = [x, y]</line-79>
<line-80> updateAngles(i, P, V, A) </line-80>
<line-81> return False</line-81>
<line-82> </line-82>
<line-83> </line-83>
<line-84>def canFix(first, last, P, V, A, filled):</line-84>
<line-85> d = last - first</line-85>
<line-86> if d > 2:</line-86>
<line-87> return False</line-87>
<line-88> if d == 2:</line-88>
<line-89> check = [first+2]</line-89>
<line-90> if d == 1:</line-90>
<line-91> check = [first+1, first+2]</line-91>
<line-92> if d == 0:</line-92>
<line-93> check = [first, first+1, first+2]</line-93>
<line-94> if checkMoves(check, P, V, A, filled):</line-94>
<line-95> return True</line-95>
<line-96> return False</line-96>
<line-97> </line-97>
<line-98>T=int(input())</line-98>
<line-99>for i in range(T):</line-99>
<line-100> N=int(input())</line-100>
<line-101> P=[]</line-101>
<line-102> V=[]</line-102>
<line-103> filled={}</line-103>
<line-104> for i in range(N):</line-104>
<line-105> P.append(list(map(int,input().split())))</line-105>
<line-106> filled[str(P[i])] = 1</line-106>
<line-107> V = compVectors(P)</line-107>
<line-108> A = compAngles(V)</line-108>
<line-109> blunt = True</line-109>
<line-110> first = -1</line-110>
<line-111> last = -1</line-111>
<line-112> for i in range(len(A)):</line-112>
<line-113> if isSharp(A[i]):</line-113>
<line-114> blunt = False</line-114>
<line-115> last = i</line-115>
<line-116> if first < 0:</line-116>
<line-117> first = i</line-117>
<line-118> if blunt:</line-118>
<line-119> print('yes yes')</line-119>
<line-120> else:</line-120>
<line-121> if canFix(first, last, P, V, A, filled):</line-121>
<line-122> print('no yes')</line-122>
<line-124> print('no no') </line-124>
|
{"code": "<line-2>import copy</line-2>\n<line-123> else:</line-123>", "lines": [2, 123]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> N=int(input())</line-3>
<line-4> ALICE=list(map(int,input().split()))</line-4>
<line-5> BOB=list(map(int,input().split()))</line-5>
<line-6> ALICE[ALICE.index(max(ALICE))]=0</line-6>
<line-7> BOB[BOB.index(max(BOB))]=0</line-7>
<line-8> if sum(ALICE)<sum(BOB):</line-8>
<line-9> print("Alice")</line-9>
<line-10> elif sum(BOB)<sum(ALICE):</line-10>
<line-11> print("Bob")</line-11>
<line-13> print("Draw")</line-13>
|
{"code": "<line-2>for i in range(int(input())):</line-2>\n<line-12> else:</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>def find_combinations(list, sum):</line-1>
<line-3> if sum == 0:</line-3>
<line-4> return [[]]</line-4>
<line-5> return []</line-5>
<line-6> return find_combinations(list[1:], sum) + \</line-6>
<line-7> [[list[0]] + tail for tail in</line-7>
<line-8> find_combinations(list[1:], sum - list[0])]</line-8>
<line-9>for tc in range(int(input())):</line-9>
<line-10> n,k=list(map(int,input().split()))</line-10>
<line-11> a=list(map(int,input().split()))</line-11>
<line-12> a.sort()</line-12>
<line-13> if len(find_combinations(a,k))==0:</line-13>
<line-14> print("NO")</line-14>
<line-16> print("YES")</line-16>
<line-17> </line-17>
|
{"code": "<line-2> if not list:</line-2>\n<line-15> else:</line-15>", "lines": [2, 15]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>L=[]</line-3>
<line-4>for i in range(n):</line-4>
<line-5> s=input()</line-5>
<line-6> L.append(s)</line-6>
<line-7></line-7>
<line-8>cost=[]</line-8>
<line-9>h2=[0]*(m+1)</line-9>
<line-10>cost.append(h2)</line-10>
<line-11>for i in range(n):</line-11>
<line-12> h=[0]</line-12>
<line-13> for j in range(m):</line-13>
<line-14> if(L[i][j]=='0' and (i+j)%2!=0):</line-14>
<line-15> h.append(1)</line-15>
<line-16> elif(L[i][j]=='1' and (i+j)%2==0):</line-16>
<line-17> h.append(1)</line-17>
<line-18> else:</line-18>
<line-19> h.append(0)</line-19>
<line-20> cost.append(h)</line-20>
<line-21></line-21>
<line-22>pre=[]</line-22>
<line-23>h2=[0]*(m+1)</line-23>
<line-24>pre.append(h2)</line-24>
<line-25>for i in range(1,n+1):</line-25>
<line-26> h=[0]</line-26>
<line-27> c=0</line-27>
<line-28> for j in range(1,m+1):</line-28>
<line-29> c+=cost[i][j]</line-29>
<line-30> c2=c</line-30>
<line-31> if(i>0):</line-31>
<line-32> c2+=pre[i-1][j]</line-32>
<line-33> h.append(c2)</line-33>
<line-34> pre.append(h)</line-34>
<line-35></line-35>
<line-36>bs=[0]*((m*n)+10)</line-36>
<line-37></line-37>
<line-38>for i in range(1,n+1):</line-38>
<line-39> for j in range(1,m+1):</line-39>
<line-40> for k in range(1,min(m,n)+1):</line-40>
<line-41> if(i-k>=0 and j-k>=0):</line-41>
<line-42> c=pre[i][j]-pre[i-k][j]-pre[i][j-k]+pre[i-k][j-k]</line-42>
<line-43> c=min(c,(k*k)-c)</line-43>
<line-44> bs[c]=max(bs[c],k)</line-44>
<line-45></line-45>
<line-46>mx=bs[0]</line-46>
<line-47>for i in range(1,len(bs)):</line-47>
<line-48> mx=max(mx,bs[i])</line-48>
<line-49> bs[i]=mx</line-49>
<line-50></line-50>
<line-51>Q=int(input())</line-51>
<line-52>q=[int(x) for x in input().split()]</line-52>
<line-53>for i in range(0,len(q)):</line-53>
<line-55> print(bs[qr])</line-55>
<line-56></line-56>
<line-57></line-57>
|
{"code": "<line-2>n,m=map(int,input().split())</line-2>\n<line-54> qr=min(m*n,q[i])</line-54>", "lines": [2, 54]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> N = int(input())</line-3>
<line-4> l = list(map(int, input().split()))</line-4>
<line-5> for j in range(int(input())):</line-5>
<line-6> q1, q2 = map(int, input().split())</line-6>
<line-8> print(sum(temp))</line-8>
|
{"code": "<line-2>for i in range(int(input())):</line-2>\n<line-7> temp = l[q1 - 1 : q2]</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> c=list(map(int,input().split()))</line-3>
<line-4> count=1</line-4>
<line-5> for i in range(n):</line-5>
<line-6> if i+1<n:</line-6>
<line-7> if c[i]-c[i+1]>=k or c[i+1]-c[i]>=k:</line-7>
<line-8> continue</line-8>
<line-9> else:</line-9>
<line-10> count+=1</line-10>
<line-12> print(count)</line-12>
<line-13> </line-13>
|
{"code": "<line-2> n,k=list(map(int,input().split()))</line-2>\n<line-11> c[i],c[i+1]=c[i+1],c[i]</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>def f(a,y,index,sorted_pos):</line-1>
<line-3> n=len(a)</line-3>
<line-4> low=0</line-4>
<line-5> high=n-1</line-5>
<line-6> L,R=0,0</line-6>
<line-7> l,r=0,0</line-7>
<line-8> while(low<=high):</line-8>
<line-9> mid=(low+high)//2</line-9>
<line-10> #print(low,high,mid)</line-10>
<line-11> if(a[mid]== y):</line-11>
<line-12> break</line-12>
<line-13> elif(mid > index[y]):</line-13>
<line-14> high=mid-1</line-14>
<line-15> L+=1</line-15>
<line-16> #print("L")</line-16>
<line-17> if(a[mid] <y):</line-17>
<line-18> l+=1</line-18>
<line-19> #print(" l ")</line-19>
<line-20> else:</line-20>
<line-21> low=mid+1</line-21>
<line-22> R+=1</line-22>
<line-23> #print("R")</line-23>
<line-24> if(a[mid]>y):</line-24>
<line-25> r+=1</line-25>
<line-26> #print("r")</line-26>
<line-27> x=sorted_pos[y]</line-27>
<line-28> #print(L,R,l,r,x,n-x-1)</line-28>
<line-29> if(R>x or L> n-x-1):</line-29>
<line-30> print("-1")</line-30>
<line-31> else:</line-31>
<line-32> print(max(l,r))</line-32>
<line-33></line-33>
<line-34></line-34>
<line-35>def fun():</line-35>
<line-36> test=int(input())</line-36>
<line-37> for t in range(test):</line-37>
<line-38> n,q=list(map(int,input().split()))</line-38>
<line-39> arr=list(map(int,input().split()))</line-39>
<line-40> index= dict()</line-40>
<line-41> for i in range(n):</line-41>
<line-42> index[arr[i]]=i</line-42>
<line-43> sorted_pos=dict()</line-43>
<line-44> a=sorted(arr)</line-44>
<line-45> for i in range(n):</line-45>
<line-46> sorted_pos[a[i]]=i</line-46>
<line-47> for x in range(q):</line-47>
<line-48> y=int(input())</line-48>
<line-50></line-50>
<line-51>fun()</line-51>
<line-52></line-52>
|
{"code": "<line-2> #print(a,y,index,sorted_pos)</line-2>\n<line-49> f(arr,y,index,sorted_pos)</line-49>", "lines": [2, 49]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> str1=input()</line-3>
<line-4> str2=input()</line-4>
<line-5> res='No'</line-5>
<line-6> for i in str1:</line-6>
<line-7> if i in str2:</line-7>
<line-8> res='Yes'</line-8>
<line-10> print(res)</line-10>
|
{"code": "<line-2>for _ in range (t):</line-2>\n<line-9> break</line-9>", "lines": [2, 9]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>import math</line-3>
<line-4></line-4>
<line-5>def main(arr):</line-5>
<line-6> for i in range(1,len(arr)-1):</line-6>
<line-7> if arr[i]==arr[i-1] and arr[i]==arr[i+1]:</line-7>
<line-8> return "Yes"</line-8>
<line-9> return "No"</line-9>
<line-10></line-10>
<line-11>test=int(input())</line-11>
<line-12>for _ in range(test):</line-12>
<line-13> b=int(input())</line-13>
<line-15> print(main(arr))</line-15>
<line-16></line-16>
<line-17> </line-17>
|
{"code": "<line-2>import sys</line-2>\n<line-14> arr=list(map(int,input().split()))</line-14>", "lines": [2, 14]}
#### 0
|
<line-1></line-1>
<line-2>test=int(input())</line-2>
<line-4> n= int(input())</line-4>
<line-5></line-5>
<line-6> adj=[[] for i in range(n+1)]</line-6>
<line-7></line-7>
<line-8> for _ in range(n-1):</line-8>
<line-9> a,b=list(map(int,input().split()))</line-9>
<line-10> adj[a].append(b)</line-10>
<line-11> adj[b].append(a)</line-11>
<line-12> </line-12>
<line-13></line-13>
<line-14> #print(adj)</line-14>
<line-15> root=1</line-15>
<line-16> q,s=[root],set([root])</line-16>
<line-17></line-17>
<line-18> for x in q:</line-18>
<line-19> adj[x]= [p for p in adj[x] if p not in s]</line-19>
<line-20> q.extend(adj[x])</line-20>
<line-21> s.update(adj[x])</line-21>
<line-22></line-22>
<line-23> #print(adj)</line-23>
<line-24> ans=True</line-24>
<line-25> if(n<4):</line-25>
<line-26> ans=False</line-26>
<line-27> for i in range(n+1):</line-27>
<line-28> if(len(adj[i]) %3!=0):</line-28>
<line-29> ans=False</line-29>
<line-30> if(ans):</line-30>
<line-31> print("YES")</line-31>
<line-32> for i in range(n+1):</line-32>
<line-33> while(len(adj[i])):</line-33>
<line-34> print(i,adj[i][0],adj[i][1],adj[i][2])</line-34>
<line-35> adj[i].pop(0)</line-35>
<line-36> adj[i].pop(0)</line-36>
<line-37> adj[i].pop(0)</line-37>
<line-39> print("NO")</line-39>
|
{"code": "<line-3>for t in range(test):</line-3>\n<line-38> else:</line-38>", "lines": [3, 38]}
#### 0
|
<line-1>from math import sqrt</line-1>
<line-2></line-2>
<line-4> n = int(input())</line-4>
<line-5></line-5>
<line-6> x = int(sqrt(2 * n))</line-6>
<line-7></line-7>
<line-8> while x * (x+1) // 2 <= n:</line-8>
<line-9> x += 1</line-9>
<line-10></line-10>
<line-11> while x * (x+1) // 2 > n:</line-11>
<line-12> x -= 1</line-12>
<line-13></line-13>
<line-15></line-15>
<line-16> print(n)</line-16>
|
{"code": "<line-3>for _ in range(int(input())):</line-3>\n<line-14> n -= x * (x+1) // 2</line-14>", "lines": [3, 14]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>from math import sqrt, ceil,factorial</line-3>
<line-4>import sys</line-4>
<line-5>import copy</line-5>
<line-6>def get_array(): return list(map(int, sys.stdin.readline().strip().split()))</line-6>
<line-7>def get_ints(): return map(int, sys.stdin.readline().strip().split())</line-7>
<line-8>def input(): return sys.stdin.readline().strip()</line-8>
<line-9></line-9>
<line-10>for _ in range(int(input())):</line-10>
<line-11></line-11>
<line-12> s=input()</line-12>
<line-13> if len(s)>6:</line-13>
<line-14> ans=0</line-14>
<line-15> rem=len(s)-6</line-15>
<line-16> ans+=factorial(len(s))</line-16>
<line-17> ans-=2*(factorial(len(s)-2))</line-17>
<line-18> ans+=factorial(rem+2)</line-18>
<line-19> print(ans)</line-19>
<line-20></line-20>
<line-21> else:</line-21>
<line-22> if 'k' in s and 'r' in s and 'a' in s and 's' in s and 'h' in s and 'i' in s:</line-22>
<line-23> ans = 0</line-23>
<line-24> rem = len(s) - 6</line-24>
<line-25> ans += factorial(len(s))</line-25>
<line-26> ans -= 2 * (factorial(len(s) - 2))</line-26>
<line-27> ans += factorial(rem + 2)</line-27>
<line-28> print(ans)</line-28>
<line-29> else:</line-29>
<line-30> if 'k' in s and 'a' in s and 'r' in s:</line-30>
<line-31> ans=0</line-31>
<line-32> rem=len(s)-3</line-32>
<line-33> ans+=factorial(len(s))</line-33>
<line-34> ans-=factorial(rem+1)</line-34>
<line-35> print(ans)</line-35>
<line-36> continue</line-36>
<line-37> if 's' in s and 'h' in s and 'i' in s:</line-37>
<line-38> ans = 0</line-38>
<line-39> rem = len(s) - 3</line-39>
<line-40> ans += factorial(len(s))</line-40>
<line-41> ans -= factorial(rem + 1)</line-41>
<line-42> print(ans)</line-42>
<line-44></line-44>
<line-45> print(factorial(len(s)))</line-45>
<line-46></line-46>
|
{"code": "<line-2>from collections import deque, defaultdict</line-2>\n<line-43> continue</line-43>", "lines": [2, 43]}
#### 0
|
<line-1>#! /usr/bin/env python</line-1>
<line-2></line-2>
<line-4>from functools import reduce</line-4>
<line-5></line-5>
<line-6>def gcd(a,b):</line-6>
<line-7> while b!=0:</line-7>
<line-8> a,b=b,a%b</line-8>
<line-9> return a</line-9>
<line-10> </line-10>
<line-11>def gcdl(l):</line-11>
<line-12> return reduce(gcd, l[1:],l[0])</line-12>
<line-13></line-13>
<line-14>def __starting_point():</line-14>
<line-15> T=int(stdin.readline())</line-15>
<line-16> for case in range(T):</line-16>
<line-17> numbers=list(map(int, stdin.readline().split()[1:]))</line-17>
<line-18> g=gcdl(numbers)</line-18>
<line-19> </line-19>
<line-20> numbers=[n/g for n in numbers]</line-20>
<line-22></line-22>
<line-23>__starting_point()</line-23>
|
{"code": "<line-3>from sys import stdin</line-3>\n<line-21>\t\tprint(\" \".join([str(x) for x in numbers]))</line-21>", "lines": [3, 21]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> while g>0:</line-3>
<line-4> if a<o:</line-4>
<line-5> a+=1</line-5>
<line-6> g-=1</line-6>
<line-7> elif o<a:</line-7>
<line-8> o+=1</line-8>
<line-9> g-=1</line-9>
<line-10> else:</line-10>
<line-12> print(abs(a-o))</line-12>
|
{"code": "<line-2> a,o,g=map(int,input().split())</line-2>\n<line-11> break</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> if n==1:</line-3>
<line-4> print(0)</line-4>
<line-5> elif n==2:</line-5>
<line-6> print(m)</line-6>
<line-8> print(m*2+n-3)</line-8>
|
{"code": "<line-2> n,m=map(int, input().split())</line-2>\n<line-7> else:</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>for t in range(int(input())):</line-1>
<line-3> a=list(map(int,input().split()))</line-3>
<line-4> s=0</line-4>
<line-5> l=[]</line-5>
<line-6> for i in range(n):</line-6>
<line-7> if (a[i]<0):</line-7>
<line-8> e=i</line-8>
<line-9> ss=sum(a[s:e])</line-9>
<line-10> l.append((ss,e-s,n-s))</line-10>
<line-11> s=i+1</line-11>
<line-12> e=n</line-12>
<line-13> ss=sum(a[s:e])</line-13>
<line-14> l.append((ss,e-s,n-s))</line-14>
<line-15> x=max(l)</line-15>
<line-16> s=n-x[2]</line-16>
<line-17> e=x[1]+s</line-17>
<line-18> for i in range(s,e):</line-18>
<line-20> print("")</line-20>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-19> print(a[i], end=' ')</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> if not len(st):print(1)</line-3>
<line-4> else:</line-4>
<line-5> cu=mx=1</line-5>
<line-6> for j in range(1,len(st)):</line-6>
<line-7> if st[j]==st[j-1]:cu+=1</line-7>
<line-9> print(max(mx+1,cu+1))</line-9>
|
{"code": "<line-2> st=input().replace(\"=\",\"\")</line-2>\n<line-8> else:mx=max(mx,cu);cu=1</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> n = len(S)</line-3>
<line-5> print(2 ** n - 2 ** a)</line-5>
|
{"code": "<line-2> S = input()</line-2>\n<line-4> a = n - S.count('a')</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>knows=input()</line-1>
<line-3>while n!=0:</line-3>
<line-4> n=n-1</line-4>
<line-5> word=input()</line-5>
<line-6> for x in word:</line-6>
<line-7> ctr=0</line-7>
<line-8> for y in knows:</line-8>
<line-9> if x==y:ctr=ctr+1;break</line-9>
<line-11> else: print('Yes')</line-11>
|
{"code": "<line-2>n=eval(input())</line-2>\n<line-10> if ctr==0:print('No');break</line-10>", "lines": [2, 10]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n,b=map(int,input().split())</line-3>
<line-5> print(ans)</line-5>
|
{"code": "<line-2>for i in range(int(input())):</line-2>\n<line-4> ans=round(n/(2*b))*(n-b*round((n/(2*b))));</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> pref = [0]*n</line-3>
<line-4> pref[0]=a[0]</line-4>
<line-5> suff = [0]*n</line-5>
<line-6> suff[-1]=a[-1]</line-6>
<line-7> for i in range (1,n):</line-7>
<line-8> pref[i] = pref[i-1]|a[i]</line-8>
<line-9> suff[n-i-1] = suff[n-i]|a[n-i-1]</line-9>
<line-10> if suff[1]==k:</line-10>
<line-11> return 0</line-11>
<line-12> elif pref[n-2]==k:</line-12>
<line-13> return n-1</line-13>
<line-14> else:</line-14>
<line-15> for i in range (1,n-1):</line-15>
<line-16> if pref[i-1]|suff[i+1] == k:</line-16>
<line-17> return i</line-17>
<line-18> return -1</line-18>
<line-19>while(t):</line-19>
<line-20> t-=1</line-20>
<line-21> n,k=[int(i) for i in input().split()]</line-21>
<line-22> a=[int(i) for i in input().split()]</line-22>
<line-23> ans = []</line-23>
<line-24> arr = [0]*n</line-24>
<line-25> for i in range (n):</line-25>
<line-26> if k|a[i] != k:</line-26>
<line-27> a[i] = a[i-1]|a[(i+1)%(n)]</line-27>
<line-28> ans.append(i+1)</line-28>
<line-29> arr[i]=1</line-29>
<line-30></line-30>
<line-31> x = 0</line-31>
<line-32> count = 0</line-32>
<line-33> for i in range (n):</line-33>
<line-34> x|=a[i]</line-34>
<line-35> </line-35>
<line-36> if x!= k:</line-36>
<line-37> print(-1)</line-37>
<line-38> else:</line-38>
<line-39> y = check()</line-39>
<line-40> if y == -1:</line-40>
<line-41> print(-1)</line-41>
<line-42> else:</line-42>
<line-43> for i in range (y,n+y):</line-43>
<line-44> if arr[i%n]==0:</line-44>
<line-45> arr[i%n]==1</line-45>
<line-47> print(*ans)</line-47>
|
{"code": "<line-2>def check():</line-2>\n<line-46> ans.append((i%n)+1)</line-46>", "lines": [2, 46]}
#### 0
|
<line-1>from sys import stdin, stdout</line-1>
<line-3>from collections import defaultdict as dd, deque</line-3>
<line-4>from heapq import merge, heapify, heappop, heappush, nsmallest</line-4>
<line-5>from bisect import bisect_left as bl, bisect_right as br, bisect</line-5>
<line-6>mod = pow(10, 9) + 7</line-6>
<line-7>mod2 = 998244353</line-7>
<line-8>def inp(): return stdin.readline().strip()</line-8>
<line-9>def out(var, end="\n"): stdout.write(str(var)+"\n")</line-9>
<line-10>def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)</line-10>
<line-11>def lmp(): return list(mp())</line-11>
<line-12>def mp(): return map(int, inp().split())</line-12>
<line-13>def smp(): return map(str, inp().split())</line-13>
<line-14>def l1d(n, val=0): return [val for i in range(n)]</line-14>
<line-15>def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]</line-15>
<line-16>def remadd(x, y): return 1 if x%y else 0</line-16>
<line-17>def ceil(a,b): return (a+b-1)//b</line-17>
<line-18></line-18>
<line-19>def isprime(x):</line-19>
<line-20> if x<=1: return False</line-20>
<line-21> if x in (2, 3): return True</line-21>
<line-22> if x%2 == 0: return False</line-22>
<line-23> for i in range(3, int(sqrt(x))+1, 2):</line-23>
<line-24> if x%i == 0: return False</line-24>
<line-25> return True</line-25>
<line-26></line-26>
<line-27>for _ in range(int(inp())):</line-27>
<line-28> n = int(inp())</line-28>
<line-29> for i in range(n):</line-29>
<line-30> for j in range(n):</line-30>
<line-31> if i==0 or i==n-1 or j==0 or j==n-1 or i==j or i+j==n-1:</line-31>
<line-32> print(1, end="")</line-32>
<line-33> else:</line-33>
<line-35> print()</line-35>
|
{"code": "<line-2>from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log</line-2>\n<line-34> print(\" \", end=\"\")</line-34>", "lines": [2, 34]}
#### 0
|
<line-1># your code goes here</line-1>
<line-3>n = int(stdin.readline())</line-3>
<line-4>while n:</line-4>
<line-5> n -= 1</line-5>
<line-6> k, l, e = map(int, stdin.readline().strip().split(' '))</line-6>
<line-7> a = map(int, stdin.readline().strip().split(' '))</line-7>
<line-8> x = float(l) / float(e + sum(a))</line-8>
<line-9> if x - int(x):</line-9>
<line-10> stdout.write("NO\n")</line-10>
<line-12> stdout.write("YES\n")</line-12>
|
{"code": "<line-2>from sys import stdin, stdout</line-2>\n<line-11> else:</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>import sys</line-1>
<line-3>import math</line-3>
<line-4>from collections import defaultdict as dd</line-4>
<line-5>input=sys.stdin.readline</line-5>
<line-6>##sys.setrecursionlimit(10**7)</line-6>
<line-7>def cin():</line-7>
<line-8> return list(map(int,sin().split()))</line-8>
<line-9>def ain(): </line-9>
<line-10> return list(map(int,sin().split()))</line-10>
<line-11>def sin():</line-11>
<line-12> return input()</line-12>
<line-13>def inin():</line-13>
<line-14> return int(input())</line-14>
<line-15>for _ in range(inin()):</line-15>
<line-16> s=sin().strip();q=inin();a=ain();n=len(s);store=[0]*n;store1=[-1]*n;f=0;d=dd(int)#input wgera</line-16>
<line-17> store[0]=1 if s[0]=='(' else -1</line-17>
<line-18> d[store[0]]=1</line-18>
<line-19> for i in range(1,n):</line-19>
<line-20> if(s[i]=='('):</line-20>
<line-21> store[i]=store[i-1]+1</line-21>
<line-22> d[store[i]]=i+1</line-22>
<line-23> else:</line-23>
<line-24> store[i]=store[i-1]-1</line-24>
<line-25> if(d[store[i-1]]):</line-25>
<line-26> store1[d[store[i-1]]-1]=i+1</line-26>
<line-27> post=[-1]*n;</line-27>
<line-28> if(n==1 or(n==2 and s!="()")):f=1 # corner case</line-28>
<line-29> for i in range(n-2,-1,-1):</line-29>
<line-30> if(s[i]=='('): #dekhna h ki agla agr ( h toh -1 hi rhega wrna wo jo stored tha uppr</line-30>
<line-31> if(store1[i]!=-1):post[i]=store1[i] #wo iska ans ho jayega</line-31>
<line-32> else:post[i]=post[i+1] #jo iske agle ka answer hoga wahi iska hoga</line-32>
<line-33> for i in a:</line-33>
<line-34> if(f):print(-1) #cond ki jaroorat nhi thi pr tasalli (>_<)</line-34>
<line-35> else:print(post[i-1]) #wrna uska ans print kra do</line-35>
<line-36> </line-36>
<line-37> </line-37>
<line-38>##n=m=0</line-38>
<line-39>##s=''</line-39>
<line-40>##t=''</line-40>
<line-41>##dp=[]</line-41>
<line-42>##def solve(inds,indt,k,cont):</line-42>
<line-43>## ans=-999999999999999</line-43>
<line-44>## print(dp)</line-44>
<line-45>## if(k<0):return 0</line-45>
<line-46>## elif(inds>=n and indt>=m):return 0</line-46>
<line-47>## elif(dp[inds][indt][k][cont]!=-1):return dp[inds][indt][k][cont]</line-47>
<line-48>## else:</line-48>
<line-49>## if(indt<m):ans=max(ans,solve(inds,indt+1,k,0))</line-49>
<line-50>## if(inds<n):ans=max(ans,solve(inds+1,indt,k,0))</line-50>
<line-51>## if(s[inds]==t[indt]):</line-51>
<line-52>## ans=max(ans,solve(inds+1,indt+1,k-1,1)+1)</line-52>
<line-53>## if(cont):ans=max(ans,solve(inds+1,indt+1,k,1)+1)</line-53>
<line-54>## dp[inds][indt][k][cont]=ans</line-54>
<line-55>## return ans </line-55>
<line-56></line-56>
<line-57>## n,m,k=cin()</line-57>
<line-58>## s=sin().strip()</line-58>
<line-59>## t=sin().strip()</line-59>
<line-60>## dp=[[[[-1]*2 for i in range(k)] for i in range(m+1)] for i in range(n+1)]</line-60>
<line-61>## c=0</line-61>
<line-62>## for i in dp:</line-62>
<line-63>## for j in i:</line-63>
<line-64>## for l in j:</line-64>
<line-65>## c+=1</line-65>
<line-67>## print(solve(0,0,k,0))</line-67>
|
{"code": "<line-2>import bisect as bi</line-2>\n<line-66>## print(l,c)</line-66>", "lines": [2, 66]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3> t=int(input())</line-3>
<line-4> m=list(map(int,input().split()))</line-4>
<line-5> p,q=0,0</line-5>
<line-6> if t==1:</line-6>
<line-7> if m[0]>=0:</line-7>
<line-8> print('YES')</line-8>
<line-9> else:</line-9>
<line-10> print('NO')</line-10>
<line-11> else:</line-11>
<line-12> for i in m:</line-12>
<line-13> if i<0:</line-13>
<line-14> q+=i</line-14>
<line-15> else:</line-15>
<line-16> p+=i</line-16>
<line-17> if p>=abs(q):</line-17>
<line-18> print('YES')</line-18>
<line-20> print('NO')</line-20>
|
{"code": "<line-2>for i in range(n):</line-2>\n<line-19> else:</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>for z in range(int(input())):</line-1>
<line-3> n = len(s)</line-3>
<line-4> i = 0</line-4>
<line-5> while i<n and s[i]=='1':</line-5>
<line-6> i+=1</line-6>
<line-7> if i==0:</line-7>
<line-8> print(0)</line-8>
<line-9> else:</line-9>
<line-10> k = 0</line-10>
<line-11> while i<n and s[i]=='0':</line-11>
<line-12> i+=1</line-12>
<line-14> print(k)</line-14>
|
{"code": "<line-2> s = input()</line-2>\n<line-13> k+=1</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>import functools</line-1>
<line-2></line-2>
<line-4> if(y == 0):</line-4>
<line-5> return x</line-5>
<line-6> return gcd(y, x%y)</line-6>
<line-7></line-7>
<line-8>for _ in range(int(input())):</line-8>
<line-9> n, m= map(int, input().split())</line-9>
<line-10> p = list(map(int, input().split()))</line-10>
<line-11> </line-11>
<line-12> ans = functools.reduce(lambda x,y: gcd(x, y), p)</line-12>
<line-13> </line-13>
<line-14> if(ans <= n):</line-14>
<line-15> print(n-ans)</line-15>
<line-16> else:</line-16>
<line-17> f = [1]</line-17>
<line-18> for k in range(ans//2, 1, -1):</line-18>
<line-19> if ans %k == 0:</line-19>
<line-20> if k<=n:</line-20>
<line-21> f.append(k)</line-21>
<line-22> </line-22>
<line-23> if ans//k <= n:</line-23>
<line-24> f.append(ans//k)</line-24>
<line-26> print(res)</line-26>
|
{"code": "<line-3>def gcd(x,y):</line-3>\n<line-25> res = n-max(f)</line-25>", "lines": [3, 25]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.