question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1>a,b=list(map(int,input().split()))</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>x,y=list(map(int,input().split()))</line-5>
<line-6>z,w=list(map(int,input().split()))</line-6>
<line-7></line-7>
<line-8></line-8>
<line-9>Team1=False</line-9>
<line-10>Team2=False</line-10>
<line-11>if(a>w and a>y and d>x and d>z):</line-11>
<line-12> Team1=True</line-12>
<line-13></line-13>
<line-14>if(c>w and c>y and b>x and b>z):</line-14>
<line-15> Team1=True</line-15>
<line-16></line-16>
<line-17>if(((x>b and w>c) or (z>b and y>c)) and ((x>d and w>a) or (z>d and y>a))):</line-17>
<line-18> Team2=True</line-18>
<line-19></line-19>
<line-20></line-20>
<line-21>if(Team1):</line-21>
<line-22> print("Team 1")</line-22>
<line-23>elif(Team2):</line-23>
<line-24> print("Team 2")</line-24>
<line-26> print("Draw")</line-26>
|
{"code": "<line-2>c,d=list(map(int,input().split()))</line-2>\n<line-25>else:</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from math import sqrt</line-3>
<line-4>import numpy as np</line-4>
<line-5></line-5>
<line-6>read = sys.stdin.read</line-6>
<line-7>readline = sys.stdin.readline</line-7>
<line-8></line-8>
<line-9></line-9>
<line-10>def main():</line-10>
<line-11> N, K, *xyc = list(map(int, read().split()))</line-11>
<line-12> x = xyc[::3]</line-12>
<line-13> y = xyc[1::3]</line-13>
<line-14> xy = list(zip(x, y))</line-14>
<line-15> c = xyc[2::3]</line-15>
<line-16> left = 0</line-16>
<line-17> right = 10 ** 6</line-17>
<line-18> delta = 0.1 ** 7</line-18>
<line-19> while right - left > delta:</line-19>
<line-20> mid = (left + right) / 2</line-20>
<line-21> intersections = []</line-21>
<line-22> r = [(mid / i) ** 2 for i in c]</line-22>
<line-23> for i, j in combinations(list(range(N)), 2):</line-23>
<line-24> x1, y1 = xy[i]</line-24>
<line-25> x2, y2 = xy[j]</line-25>
<line-26> X = x2 - x1</line-26>
<line-27> Y = y2 - y1</line-27>
<line-28> XY = X ** 2 + Y ** 2</line-28>
<line-29> r1 = r[i]</line-29>
<line-30> r2 = r[j]</line-30>
<line-31></line-31>
<line-32> a = (XY + r1 - r2) / 2</line-32>
<line-33> b = XY * r1 - a ** 2</line-33>
<line-34> if b < delta:</line-34>
<line-35> continue</line-35>
<line-36> b = sqrt(b)</line-36>
<line-37> xi1 = (a * X + Y * b) / XY + x1</line-37>
<line-38> yi1 = (a * Y - X * b) / XY + y1</line-38>
<line-39> xi2 = (a * X - Y * b) / XY + x1</line-39>
<line-40> yi2 = (a * Y + X * b) / XY + y1</line-40>
<line-41> intersections.append((xi1, yi1))</line-41>
<line-42> intersections.append((xi2, yi2))</line-42>
<line-43></line-43>
<line-44> intersections.extend(xy)</line-44>
<line-45> intersections = np.array(intersections, np.float)</line-45>
<line-46> cnt = np.zeros(len(intersections), np.int64)</line-46>
<line-47></line-47>
<line-48> for (i, j), k in zip(xy, r):</line-48>
<line-49> XY = (intersections[:, 0] - i) ** 2 + (intersections[:, 1] - j) ** 2</line-49>
<line-50> cnt[XY < k + delta] += 1</line-50>
<line-51></line-51>
<line-52> if np.any(cnt >= K):</line-52>
<line-53> right = mid</line-53>
<line-54> else:</line-54>
<line-55> left = mid</line-55>
<line-56></line-56>
<line-57> print(right)</line-57>
<line-58></line-58>
<line-59></line-59>
<line-60>def __starting_point():</line-60>
<line-62></line-62>
<line-63>__starting_point()</line-63>
|
{"code": "<line-2>from itertools import combinations</line-2>\n<line-61> main()</line-61>", "lines": [2, 61]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>left=0</line-3>
<line-4>right=0</line-4>
<line-5>left_ques=0</line-5>
<line-6>right_ques=0</line-6>
<line-7>for i in range(n):</line-7>
<line-8> if i<n//2:</line-8>
<line-9> if s[i]=='?':</line-9>
<line-10> left_ques+=1</line-10>
<line-11> else :</line-11>
<line-12> left+=int(s[i])</line-12>
<line-13> else :</line-13>
<line-14> if s[i]=='?':</line-14>
<line-15> right_ques+=1</line-15>
<line-16> else :</line-16>
<line-17> right+=int(s[i])</line-17>
<line-18>x=min(left_ques,right_ques)</line-18>
<line-19>left_ques-=x</line-19>
<line-20>right_ques-=x</line-20>
<line-21>if left_ques==0 and right_ques==0:</line-21>
<line-22> if left==right:</line-22>
<line-23> print("Bicarp")</line-23>
<line-24> else :</line-24>
<line-25> print("Monocarp")</line-25>
<line-26>else :</line-26>
<line-27> if left_ques==0:</line-27>
<line-28> if right_ques%2==0:</line-28>
<line-29> x=9*(right_ques//2)+right</line-29>
<line-30> if x==left:</line-30>
<line-31> print("Bicarp")</line-31>
<line-32> else :</line-32>
<line-33> print("Monocarp")</line-33>
<line-34> else :</line-34>
<line-35> print("Monocarp")</line-35>
<line-36> else :</line-36>
<line-37> if left_ques%2==0:</line-37>
<line-38> x=9*(left_ques//2)+left</line-38>
<line-39> if x==right:</line-39>
<line-40> print("Bicarp")</line-40>
<line-41> else :</line-41>
<line-42> print("Monocarp")</line-42>
<line-44> print("Monocarp")</line-44>
|
{"code": "<line-2>s=input()</line-2>\n<line-43> else :</line-43>", "lines": [2, 43]}
#### 0
|
<line-1># AC</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>class Main:</line-5>
<line-6> def __init__(self):</line-6>
<line-7> self.buff = None</line-7>
<line-8> self.index = 0</line-8>
<line-9></line-9>
<line-10> def __next__(self):</line-10>
<line-11> if self.buff is None or self.index == len(self.buff):</line-11>
<line-12> self.buff = sys.stdin.readline().split()</line-12>
<line-13> self.index = 0</line-13>
<line-14> val = self.buff[self.index]</line-14>
<line-15> self.index += 1</line-15>
<line-16> return val</line-16>
<line-17></line-17>
<line-18> def next_int(self):</line-18>
<line-19> return int(next(self))</line-19>
<line-20></line-20>
<line-21> def cal(self, s):</line-21>
<line-22> if len(s) == 1:</line-22>
<line-23> return s[0]</line-23>
<line-24> if s[0] == 0:</line-24>
<line-25> return self.cal(s[1:])</line-25>
<line-26> v = 1</line-26>
<line-27> for c in s:</line-27>
<line-28> v *= c</line-28>
<line-29> return v</line-29>
<line-30></line-30>
<line-31> def solve(self):</line-31>
<line-32> n = self.next_int()</line-32>
<line-33> t = self.next_int()</line-33>
<line-34> ii = 0</line-34>
<line-35> tt = 10000000</line-35>
<line-36> for i in range(0, n):</line-36>
<line-37> fr = self.next_int()</line-37>
<line-38> d = self.next_int()</line-38>
<line-39> if fr < t:</line-39>
<line-40> fr += (t - fr + d - 1) // d * d</line-40>
<line-41> if fr < tt:</line-41>
<line-42> tt = fr</line-42>
<line-43> ii = i</line-43>
<line-44> print(ii + 1)</line-44>
<line-45></line-45>
<line-46></line-46>
<line-47>def __starting_point():</line-47>
<line-49></line-49>
<line-50>__starting_point()</line-50>
|
{"code": "<line-2>import sys</line-2>\n<line-48> Main().solve()</line-48>", "lines": [2, 48]}
#### 0
|
<line-1>def nck(n, k, cache = {}):</line-1>
<line-3> if k == 0 or k == n: return 1</line-3>
<line-4> if k*2 > n: k = n-k</line-4>
<line-5> if (n, k) in cache: return cache[(n, k)]</line-5>
<line-6></line-6>
<line-7> z = cache[(n, k)] = nck(n-1, k-1) + nck(n-1, k)</line-7>
<line-8> return z</line-8>
<line-9></line-9>
<line-10>def bits(n):</line-10>
<line-11> b = 0</line-11>
<line-12> while n:</line-12>
<line-13> if n&1: b += 1</line-13>
<line-14> n >>= 1</line-14>
<line-15> return b</line-15>
<line-16></line-16>
<line-17>def count(n, k):</line-17>
<line-18> z, b, c = 0, 63, 0</line-18>
<line-19> for b in reversed(range(64)):</line-19>
<line-20> if (n>>b)&1:</line-20>
<line-21> z += nck(b, k-c)</line-21>
<line-22> c += 1</line-22>
<line-23> if not k: break</line-23>
<line-24> return z + (bits(n) == k)</line-24>
<line-25></line-25>
<line-26>def solve(m, k):</line-26>
<line-27> lo, hi = 1, 10**18</line-27>
<line-28> while lo < hi:</line-28>
<line-29> mi = (lo+hi)//2</line-29>
<line-30> if count(2*mi, k) - count(mi, k) < m:</line-30>
<line-31> lo = mi+1</line-31>
<line-32> else:</line-32>
<line-33> hi = mi</line-33>
<line-34> return hi</line-34>
<line-35></line-35>
<line-37>print(solve(m, k))</line-37>
|
{"code": "<line-2> if k > n or k < 0: return 0</line-2>\n<line-36>m, k = [int(x) for x in input().split()]</line-36>", "lines": [2, 36]}
#### 0
|
<line-1>kk=0</line-1>
<line-3>y = input()</line-3>
<line-4>z = [i for i in range(len(y)) if y[i] == '*']</line-4>
<line-5>for i in range(0, 100):</line-5>
<line-6> for j in range(1, 100):</line-6>
<line-7> if i in z and i+j in z and i+2*j in z and i+3*j in z and i+4*j in z:</line-7>
<line-8> kk=1</line-8>
<line-9>if kk==1:</line-9>
<line-10> print("yes")</line-10>
<line-12> print("no")</line-12>
|
{"code": "<line-2>x = int(input())</line-2>\n<line-11>else:</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>#!/usr/bin/env python3</line-1>
<line-3></line-3>
<line-4>def func():</line-4>
<line-5> N = int(input())</line-5>
<line-6> cells = [0] * N</line-6>
<line-7></line-7>
<line-8> if N == 1:</line-8>
<line-9> return 1</line-9>
<line-10></line-10>
<line-11> mx = 0</line-11>
<line-12> for n in range(N):</line-12>
<line-13> cells[n] = list(map(int,input().split()))</line-13>
<line-14> mx = max(mx, sum(cells[n]))</line-14>
<line-15></line-15>
<line-16> ans = None</line-16>
<line-17> for j in range(N):</line-17>
<line-18> for i in range(N):</line-18>
<line-19> if cells[j][i] == 0:</line-19>
<line-20> ans = mx - sum(cells[j])</line-20>
<line-21> cells[j][i] = ans</line-21>
<line-22> if ans <= 0:</line-22>
<line-23> return -1</line-23>
<line-24></line-24>
<line-25> # validation</line-25>
<line-26> for j in range(N):</line-26>
<line-27> if sum(cells[j]) != mx:</line-27>
<line-28> return -1</line-28>
<line-29> for i in range(N):</line-29>
<line-30> if mx != sum([cells[j][i] for j in range(N)]):</line-30>
<line-31> return -1</line-31>
<line-32> if mx != sum([cells[j][j] for j in range(N)]):</line-32>
<line-33> return -1</line-33>
<line-34> if mx != sum([cells[j][N-1-j] for j in range(N)]):</line-34>
<line-35> return -1</line-35>
<line-36> </line-36>
<line-38></line-38>
<line-39>print(func())</line-39>
<line-40></line-40>
|
{"code": "<line-2># -*- coding: utf-8 -*-</line-2>\n<line-37> return ans</line-37>", "lines": [2, 37]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>a = []</line-3>
<line-4>for i in range(n):</line-4>
<line-5> a.append(int(input()))</line-5>
<line-6></line-6>
<line-7>mx = max(a) + m</line-7>
<line-8></line-8>
<line-9></line-9>
<line-10></line-10>
<line-11>while m:</line-11>
<line-12> for i in range(n):</line-12>
<line-13> if a[i] == min(a):</line-13>
<line-14> a[i] += 1</line-14>
<line-15> m -= 1</line-15>
<line-17></line-17>
<line-18>print(max(a), mx)</line-18>
|
{"code": "<line-2>m = int(input())</line-2>\n<line-16> break</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>MOD = 10 ** 9 + 7</line-1>
<line-3>n = int(n)</line-3>
<line-4>m = int(m)</line-4>
<line-5>ans = pow(2 * (n + 1), m, MOD)</line-5>
<line-6>ans = (ans * (n + 1 - m)) % MOD</line-6>
<line-8>print(ans)</line-8>
|
{"code": "<line-2>n, m = input().split(' ')</line-2>\n<line-7>ans = (ans * pow(n + 1, MOD - 2, MOD)) % MOD</line-7>", "lines": [2, 7]}
#### 0
|
<line-1># author: ThePonyCoder</line-1>
<line-3># filename: f.py</line-3>
<line-4># path: C:/Users/User/Desktop/python/Prog/CodeForces/rounds/cf_568/f.py</line-4>
<line-5></line-5>
<line-6>import os</line-6>
<line-7></line-7>
<line-8># import random</line-8>
<line-9></line-9>
<line-10># sys.setrecursionlimit(999999999)</line-10>
<line-11>import string</line-11>
<line-12></line-12>
<line-13>from math import inf</line-13>
<line-14>from functools import lru_cache</line-14>
<line-15></line-15>
<line-16>if os.getcwd() == 'C:\\Users\\User\\Desktop\\python\\Prog\\CodeForces' \</line-16>
<line-17> or os.environ['COMPUTERNAME'] == 'USER145':</line-17>
<line-18> import pdb</line-18>
<line-19> </line-19>
<line-20> import sys</line-20>
<line-21> </line-21>
<line-22> pdb = pdb.Pdb(stdin=sys.stdin, stdout=sys.stdout)</line-22>
<line-23> sys.stdin = open('input.txt', 'r')</line-23>
<line-24> sys.stdout = open('output.txt', 'w')</line-24>
<line-25> from pprint import pprint</line-25>
<line-26> from hypothesis import given, settings</line-26>
<line-27> from hypothesis import strategies as st</line-27>
<line-28></line-28>
<line-29></line-29>
<line-30>def ri():</line-30>
<line-31> return [int(i) for i in input().split()]</line-31>
<line-32></line-32>
<line-33></line-33>
<line-34>def to_bits(l):</line-34>
<line-35> ans = 0</line-35>
<line-36> for i in l:</line-36>
<line-37> ans |= (1 << i - 1)</line-37>
<line-38> return ans</line-38>
<line-39></line-39>
<line-40></line-40>
<line-41>user_masks = [0 for i in range(1 << 10)]</line-41>
<line-42>pizzas = [[] for i in range(1 << 10)]</line-42>
<line-43></line-43>
<line-44></line-44>
<line-45>@lru_cache()</line-45>
<line-46>def count_sat_users(mask):</line-46>
<line-47> ans = 0</line-47>
<line-48> cmask = mask</line-48>
<line-49> while cmask:</line-49>
<line-50> ans += user_masks[cmask]</line-50>
<line-51> cmask = (cmask - 1) & mask</line-51>
<line-52> return ans</line-52>
<line-53></line-53>
<line-54></line-54>
<line-55>def main():</line-55>
<line-56> n, m = ri()</line-56>
<line-57> for _ in range(n):</line-57>
<line-58> k, *a = ri()</line-58>
<line-59> bits = to_bits(a)</line-59>
<line-60> user_masks[bits] += 1</line-60>
<line-61> </line-61>
<line-62> ans = (float(-inf), float(inf), -1, -1)</line-62>
<line-63> </line-63>
<line-64> for i in range(m):</line-64>
<line-65> c, k, *a = ri()</line-65>
<line-66> bits = to_bits(a)</line-66>
<line-67> pizzas[bits].append((c, i + 1, bits)) # цена, номер, маска</line-67>
<line-68> pizzas[bits].sort()</line-68>
<line-69> while len(pizzas[bits]) > 2:</line-69>
<line-70> pizzas[bits].pop()</line-70>
<line-71> # pprint(pizzas)</line-71>
<line-72> </line-72>
<line-73> for mask_F in range(1 << 9):</line-73>
<line-74> for mask_S in range(1 << 9):</line-74>
<line-75> if len(pizzas[mask_F]) and len(pizzas[mask_S]) \</line-75>
<line-76> and mask_F != mask_S:</line-76>
<line-77> </line-77>
<line-78> mask = mask_F | mask_S</line-78>
<line-79> </line-79>
<line-80> satisfied_users = count_sat_users(mask)</line-80>
<line-81> </line-81>
<line-82> f_pizza = next(iter(pizzas[mask_F]))</line-82>
<line-83> s_pizza = next(iter(pizzas[mask_S]))</line-83>
<line-84> </line-84>
<line-85> summary_cost = 0</line-85>
<line-86> summary_cost += f_pizza[0]</line-86>
<line-87> summary_cost += s_pizza[0]</line-87>
<line-88> </line-88>
<line-89> ans = max(ans,</line-89>
<line-90> (satisfied_users,</line-90>
<line-91> -summary_cost,</line-91>
<line-92> s_pizza[1],</line-92>
<line-93> f_pizza[1]))</line-93>
<line-94> </line-94>
<line-95> # bruting all masks</line-95>
<line-96> bmask = mask</line-96>
<line-97> while bmask:</line-97>
<line-98> satisfied_users += user_masks[bmask]</line-98>
<line-99> bmask = (bmask - 1) & mask</line-99>
<line-100> </line-100>
<line-101> if len(pizzas[mask_F]) == 2:</line-101>
<line-102> satisfied_users = count_sat_users(mask_F)</line-102>
<line-103> </line-103>
<line-104> it = iter(pizzas[mask_F])</line-104>
<line-105> </line-105>
<line-106> f_pizza = next(it)</line-106>
<line-107> s_pizza = next(it)</line-107>
<line-108> summary_cost = 0</line-108>
<line-109> summary_cost += f_pizza[0] + s_pizza[0]</line-109>
<line-110> ans = max(ans,</line-110>
<line-111> (satisfied_users,</line-111>
<line-112> -summary_cost,</line-112>
<line-113> s_pizza[1],</line-113>
<line-114> f_pizza[1]))</line-114>
<line-115> </line-115>
<line-116> if len(pizzas[mask_S]) == 2:</line-116>
<line-117> satisfied_users = count_sat_users(mask_S)</line-117>
<line-118> </line-118>
<line-119> it = iter(pizzas[mask_S])</line-119>
<line-120> </line-120>
<line-121> f_pizza = next(it)</line-121>
<line-122> s_pizza = next(it)</line-122>
<line-123> summary_cost = 0</line-123>
<line-124> summary_cost += f_pizza[0] + s_pizza[0]</line-124>
<line-125> ans = max(ans,</line-125>
<line-126> (satisfied_users,</line-126>
<line-127> -summary_cost,</line-127>
<line-128> s_pizza[1],</line-128>
<line-129> f_pizza[1]))</line-129>
<line-130> </line-130>
<line-131> aans = [ans[2],ans[3]]</line-131>
<line-132> aans.sort()</line-132>
<line-134></line-134>
<line-135></line-135>
<line-136>main()</line-136>
|
{"code": "<line-2># created: 23.06.2019, 21:58</line-2>\n<line-133> print(*aans, sep=' ')</line-133>", "lines": [2, 133]}
#### 0
|
<line-1>M,S=list(map(int,input().split()))</line-1>
<line-2></line-2>
<line-4> print('0 0')</line-4>
<line-5> return</line-5>
<line-6>elif S==0 or M*9 < S:</line-6>
<line-7> print('-1 -1')</line-7>
<line-8> return</line-8>
<line-9></line-9>
<line-10>m,s=M,S</line-10>
<line-11>l=[]</line-11>
<line-12>if s<=(m-1)*9+1:</line-12>
<line-13> l.append(1)</line-13>
<line-14> s-=1</line-14>
<line-15>while len(l)<m:</line-15>
<line-16> r = (m-len(l)-1)*9</line-16>
<line-17> if s<=r:</line-17>
<line-18> l.append(0)</line-18>
<line-19> else:</line-19>
<line-20> l.append(s-r)</line-20>
<line-21> s-=s-r</line-21>
<line-22></line-22>
<line-23>m,s=M,S</line-23>
<line-24>h=[]</line-24>
<line-25>while s>=9:</line-25>
<line-26> h.append(9)</line-26>
<line-27> s-=9</line-27>
<line-28>while len(h)<m:</line-28>
<line-29> h.append(s)</line-29>
<line-31></line-31>
<line-32>print(''.join(repr(x) for x in l), ''.join(repr(x) for x in h))</line-32>
<line-33></line-33>
|
{"code": "<line-3>if S==0 and M==1:</line-3>\n<line-30> s=0</line-30>", "lines": [3, 30]}
#### 0
|
<line-1></line-1>
<line-2></line-2>
<line-3></line-3>
<line-4>l, r, k =list(map(int,input().split()))</line-4>
<line-5></line-5>
<line-7></line-7>
<line-8>cache = {}</line-8>
<line-9></line-9>
<line-10>def can(i, m):</line-10>
<line-11> return d[i] & m</line-11>
<line-12></line-12>
<line-13>def calc(m):</line-13>
<line-14> b = 1</line-14>
<line-15> c = 0</line-15>
<line-16> for i in range(10):</line-16>
<line-17> if b & m:</line-17>
<line-18> c += 1</line-18>
<line-19> b *= 2</line-19>
<line-20></line-20>
<line-21> return c</line-21>
<line-22></line-22>
<line-23>def sm(ln, k, m, s='', first=False):</line-23>
<line-24> if ln < 1:</line-24>
<line-25> return 0, 1</line-25>
<line-26></line-26>
<line-27> if (ln, k, m, s, first) in cache:</line-27>
<line-28> return cache[(ln, k, m, s, first)]</line-28>
<line-29></line-29>
<line-30> ans = 0</line-30>
<line-31> count = 0</line-31>
<line-32> base = 10 ** (ln-1)</line-32>
<line-33></line-33>
<line-34> use_new = calc(m) < k</line-34>
<line-35></line-35>
<line-36> if s:</line-36>
<line-37> finish = int(s[0])+1</line-37>
<line-38> else:</line-38>
<line-39> finish = 10</line-39>
<line-40></line-40>
<line-41> for i in range(finish):</line-41>
<line-42> if use_new or can(i, m):</line-42>
<line-43> ss = s[1:]</line-43>
<line-44> if i != finish-1:</line-44>
<line-45> ss = ''</line-45>
<line-46> nm = m | d[i]</line-46>
<line-47> nfirst = False</line-47>
<line-48> if i == 0 and first:</line-48>
<line-49> nm = m</line-49>
<line-50> nfirst = True</line-50>
<line-51> nexta, nextc = sm(ln-1, k, nm, ss, nfirst)</line-51>
<line-52> ans += base * i * nextc + nexta</line-52>
<line-53> count += nextc</line-53>
<line-54></line-54>
<line-55># print(ln, k, m, s, first, ans, count)</line-55>
<line-56> cache[(ln, k, m, s, first)] = (ans, count)</line-56>
<line-57></line-57>
<line-58> return ans, count</line-58>
<line-59></line-59>
<line-60>def call(a, k):</line-60>
<line-61> s = str(a)</line-61>
<line-62> return sm(len(s), k, 0, s, True)[0]</line-62>
<line-63></line-63>
<line-64></line-64>
<line-66>print((call(r, k) - call(l-1, k)) % 998244353)</line-66>
|
{"code": "<line-6>d = {i:2**i for i in range(10)}</line-6>\n<line-65>#print(call(r, k) - call(l-1, k))</line-65>", "lines": [6, 65]}
#### 0
|
<line-1>#!/usr/bin/env python3</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>[n, k, d] = list(map(int, input().strip().split()))</line-5>
<line-6>ais = list(map(int, input().strip().split()))</line-6>
<line-7>if k == 1:</line-7>
<line-8> print ('YES')</line-8>
<line-9> return</line-9>
<line-10></line-10>
<line-11>ais.sort()</line-11>
<line-12></line-12>
<line-13># can do ais[i:]</line-13>
<line-14>cando = [False for _ in range(n)]</line-14>
<line-15>j = n - 1 # j is such that a[j] > a[i] + d >= a[j - 1] (upper_bound) a[:j] <= a[i] + d < a[j:]</line-15>
<line-16>count = 0 # sum(cando[i + k:j + 1])</line-16>
<line-17>for i in reversed(list(range(n))):</line-17>
<line-18> if i + k < n and cando[i + k]:</line-18>
<line-19> count += 1</line-19>
<line-20> if n - i < k:</line-20>
<line-21> continue</line-21>
<line-22> if ais[-1] - ais[i] <= d:</line-22>
<line-23> cando[i] = True</line-23>
<line-24> continue</line-24>
<line-25> while ais[j - 1] > ais[i] + d:</line-25>
<line-26> if cando[j]:</line-26>
<line-27> count -= 1</line-27>
<line-28> j -= 1</line-28>
<line-29> cando[i] = (count > 0)</line-29>
<line-30> </line-30>
<line-31></line-31>
<line-32>if cando[0]:</line-32>
<line-33> print ('YES')</line-33>
<line-35> print ('NO')</line-35>
<line-36></line-36>
|
{"code": "<line-3>from bisect import bisect</line-3>\n<line-34>else:</line-34>", "lines": [3, 34]}
#### 0
|
<line-1>s = input()</line-1>
<line-3>t = 'RBYG'</line-3>
<line-4>for i in t:</line-4>
<line-5> ind = s.find(i) % 4</line-5>
<line-6> ans = 0</line-6>
<line-7> while ind < n:</line-7>
<line-8> ans += s[ind] == '!'</line-8>
<line-10> print(ans, end=' ')</line-10>
|
{"code": "<line-2>n = len(s)</line-2>\n<line-9>\t\tind += 4</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>n, m = list(map(int, input().split()))</line-1>
<line-3>edges_to = [[] for _ in range(n)]</line-3>
<line-4></line-4>
<line-5>for _ in range(m):</line-5>
<line-6> _from, to = [int(x)-1 for x in input().split()]</line-6>
<line-7> edges_from[_from].append(to)</line-7>
<line-8></line-8>
<line-9>E_dist_to_goal = [0] * n</line-9>
<line-10>P_of_reaching = [0] * n</line-10>
<line-11>P_of_reaching[0] = 1</line-11>
<line-12></line-12>
<line-13>for v in range(n-2, -1, -1):</line-13>
<line-14> routes = edges_from[v]</line-14>
<line-15> for next_v in routes:</line-15>
<line-16> E_dist_to_goal[v] += E_dist_to_goal[next_v] + 1</line-16>
<line-17> E_dist_to_goal[v] /= len(routes)</line-17>
<line-18></line-18>
<line-19>for v in range(n-1):</line-19>
<line-20> P_now = P_of_reaching[v]</line-20>
<line-21> routes = edges_from[v]</line-21>
<line-22> P_next = P_now / len(routes)</line-22>
<line-23> for next_v in routes:</line-23>
<line-24> P_of_reaching[next_v] += P_next</line-24>
<line-25></line-25>
<line-26>initial_ans = E_dist_to_goal[0]</line-26>
<line-27>answers = [initial_ans]</line-27>
<line-28>for v in range(n-2):</line-28>
<line-29> routes = edges_from[v]</line-29>
<line-30> num_of_routes = len(routes)</line-30>
<line-31> if num_of_routes == 1:</line-31>
<line-32> continue</line-32>
<line-33> not_cut_dist = E_dist_to_goal[v]</line-33>
<line-34> longest_dist = max([E_dist_to_goal[next_v]+1 for next_v in routes])</line-34>
<line-35> after_cut_dist = (not_cut_dist - longest_dist/num_of_routes) * num_of_routes / (num_of_routes-1)</line-35>
<line-36> delta = not_cut_dist - after_cut_dist</line-36>
<line-37> candidate = initial_ans - delta * P_of_reaching[v]</line-37>
<line-39></line-39>
<line-40>print((min(answers)))</line-40>
|
{"code": "<line-2>edges_from = [[] for _ in range(n)]</line-2>\n<line-38> answers.append(candidate)</line-38>", "lines": [2, 38]}
#### 0
|
<line-2></line-2>
<line-3>n = int(input())</line-3>
<line-4>print(10 * round(n / 10))</line-4>
|
{"code": "<line-1>import math</line-1>", "lines": [1]}
#### 0
|
<line-1>a = input()</line-1>
<line-3></line-3>
<line-4>symbols = {}</line-4>
<line-5>pairs = []</line-5>
<line-6></line-6>
<line-7>for i in range(len(a)):</line-7>
<line-8> if a[i] in symbols:</line-8>
<line-9> if symbols[a[i]] != b[i]:</line-9>
<line-10> print('-1')</line-10>
<line-11> break</line-11>
<line-12> elif b[i] in symbols:</line-12>
<line-13> if symbols[b[i]] != a[i]:</line-13>
<line-14> print('-1')</line-14>
<line-15> break</line-15>
<line-16> else:</line-16>
<line-17> symbols[a[i]] = b[i]</line-17>
<line-18> symbols[b[i]] = a[i]</line-18>
<line-19> if a[i] != b[i]:</line-19>
<line-20> pairs.append((a[i], b[i]))</line-20>
<line-21>else:</line-21>
<line-22> print(len(pairs))</line-22>
<line-24> print(elem[0], elem[1])</line-24>
|
{"code": "<line-2>b = input()</line-2>\n<line-23> for elem in pairs:</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>from collections import *</line-1>
<line-3>import sys</line-3>
<line-4></line-4>
<line-5>def main():</line-5>
<line-6> a, b = input().split()</line-6>
<line-7> ans = a + b</line-7>
<line-8> n = len(a)</line-8>
<line-9> m = len(b)</line-9>
<line-10> for i in range(1, n + 1):</line-10>
<line-11> for j in range(1, m + 1):</line-11>
<line-12> c = a[:i] + b[:j]</line-12>
<line-13> # print(c)</line-13>
<line-14> ans = min(ans, c)</line-14>
<line-16></line-16>
<line-17>main()</line-17>
|
{"code": "<line-2>import itertools</line-2>\n<line-15> print(ans)</line-15>", "lines": [2, 15]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>d = [0] * n</line-3>
<line-4>cd = 0</line-4>
<line-5>xp = []</line-5>
<line-6>for i in range(n):</line-6>
<line-7> if x[i] == '[':</line-7>
<line-8> d[i] = cd</line-8>
<line-9> cd = cd + 1</line-9>
<line-10> else:</line-10>
<line-11> cd = cd - 1</line-11>
<line-12> d[i] = cd</line-12>
<line-13>for i in range(n-1):</line-13>
<line-14> xp.append((x[i], d[i]))</line-14>
<line-15> if x[i] == '[' and x[i+1] == ']':</line-15>
<line-16> xp.extend([(' ', d[i]), (' ', d[i]), (' ', d[i])])</line-16>
<line-17>xp.append((x[n-1], d[n-1]))</line-17>
<line-18>md = max(d)</line-18>
<line-19>h = md * 2 + 3</line-19>
<line-20>res = []</line-20>
<line-21>for i in range(h):</line-21>
<line-22> l = [' ' for j in xp]</line-22>
<line-23> res.append(l)</line-23>
<line-24>for i in range(len(xp)):</line-24>
<line-25> for j in range(h):</line-25>
<line-26> if xp[i][0] == '[' and j > xp[i][1] and j < h - xp[i][1] - 1:</line-26>
<line-27> res[j][i] = '|'</line-27>
<line-28> elif xp[i][0] == ']' and j > xp[i][1] and j < h - xp[i][1] - 1:</line-28>
<line-29> res[j][i] = '|'</line-29>
<line-30> elif xp[i][0] == '[' and (j == xp[i][1] or j == h - xp[i][1] - 1):</line-30>
<line-31> res[j][i] = '+'</line-31>
<line-32> res[j][i+1] = '-'</line-32>
<line-33> elif xp[i][0] == ']' and (j == xp[i][1] or j == h - xp[i][1] - 1):</line-33>
<line-34> res[j][i] = '+'</line-34>
<line-35> res[j][i-1] = '-'</line-35>
<line-36></line-36>
<line-38> print(''.join(res[i]))</line-38>
<line-39></line-39>
|
{"code": "<line-2>x = input()</line-2>\n<line-37>for i in range(h):</line-37>", "lines": [2, 37]}
#### 0
|
<line-1>u = v = 0</line-1>
<line-3>n, m = len(a), len(b)</line-3>
<line-4>if n > m: b = '0' * (n - m) + b</line-4>
<line-5>else: a = '0' * (m - n) + a</line-5>
<line-6>for i in range(max(n, m)):</line-6>
<line-7> u, v = v + u, u + int(a[i]) - int(b[i])</line-7>
<line-8> if u > 1:</line-8>
<line-9> print('>')</line-9>
<line-10> return</line-10>
<line-11> elif u < -1:</line-11>
<line-12> print('<')</line-12>
<line-13> return</line-13>
<line-14>d = 2 * v + u</line-14>
<line-15>if u == v == 0: print('=')</line-15>
<line-16>elif u >= 0 and d >= 0: print('>')</line-16>
<line-18>else: print('>' if (u * u > v * (v + u)) ^ (u < 0) else '<')</line-18>
|
{"code": "<line-2>a, b = input(), input()</line-2>\n<line-17>elif u <= 0 and d <= 0: print('<')</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>sol = []</line-3>
<line-4>for i in range(6):</line-4>
<line-5> c = ['purple', 'green', 'blue', 'orange', 'red', 'yellow'][i]</line-5>
<line-6> if c not in a:</line-6>
<line-7> sol.append(['Power', 'Time', 'Space', 'Soul', 'Reality', 'Mind'][i])</line-7>
<line-8>print(len(sol))</line-8>
<line-10> print(i)</line-10>
|
{"code": "<line-2>a = [input() for i in range(n)]</line-2>\n<line-9>for i in sol:</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>cnt = 0</line-4>
<line-5>l = [set([x]) for x in range(1, n+1)]</line-5>
<line-6></line-6>
<line-7>while 1:</line-7>
<line-8> l = list([tup[0] | tup[1] for tup in zip(l[::2], l[1::2])])</line-8>
<line-9> cnt += 1</line-9>
<line-10> for el in l:</line-10>
<line-11> if a in el and b in el:</line-11>
<line-13> return</line-13>
|
{"code": "<line-2>n, a, b = list(map(int, input().split()))</line-2>\n<line-12> print(cnt if len(el) < n else 'Final!')</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>p = [int(i) for i in input().split()]</line-4>
<line-5>b = [int(i) for i in input().split()]</line-5>
<line-6></line-6>
<line-7>ans = 0</line-7>
<line-8>num_cycles = 0</line-8>
<line-9>checked = set()</line-9>
<line-10></line-10>
<line-11>for i in range(n):</line-11>
<line-12> if i in checked:</line-12>
<line-13> continue</line-13>
<line-14></line-14>
<line-15> checked.add(i)</line-15>
<line-16></line-16>
<line-17> nxt = p[i] - 1</line-17>
<line-18></line-18>
<line-19> while nxt != i:</line-19>
<line-20> checked.add(nxt)</line-20>
<line-21> nxt = p[nxt] - 1</line-21>
<line-22></line-22>
<line-23> num_cycles += 1</line-23>
<line-24></line-24>
<line-25>ans += num_cycles if num_cycles != 1 else 0</line-25>
<line-27></line-27>
<line-28>print(ans)</line-28>
|
{"code": "<line-3>n = int(input())</line-3>\n<line-26>ans += (sum(b) % 2) == 0</line-26>", "lines": [3, 26]}
#### 0
|
<line-1>v1, v2 = list(map(int, input().split()))</line-1>
<line-3>vm = [0] * t</line-3>
<line-4></line-4>
<line-5>v = v1</line-5>
<line-6>for i in range(t):</line-6>
<line-7> vm[i] = v</line-7>
<line-8> v += d</line-8>
<line-9></line-9>
<line-10>v = v2</line-10>
<line-11>for i in range(t - 1, -1, -1):</line-11>
<line-12> vm[i] = min(v, vm[i])</line-12>
<line-14></line-14>
<line-15>print(sum(vm))</line-15>
|
{"code": "<line-2>t, d = list(map(int, input().split()))</line-2>\n<line-13> v += d</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>import sys</line-1>
<line-3>from itertools import permutations, accumulate</line-3>
<line-4>import heapq</line-4>
<line-5>import bisect</line-5>
<line-6>from operator import itemgetter</line-6>
<line-7></line-7>
<line-8>def dijkstra(start, edge):</line-8>
<line-9> n = len(edge)</line-9>
<line-10> dist = [0]*n</line-10>
<line-11> que = [(0, start)]</line-11>
<line-12> while que:</line-12>
<line-13> d, v = heapq.heappop(que)</line-13>
<line-14> if dist[v] < d:</line-14>
<line-15> continue</line-15>
<line-16> for nv, nd in edge[v]:</line-16>
<line-17> if dist[nv] > d + nd:</line-17>
<line-18> dist[nv] = d + nd</line-18>
<line-19> heapq.heappush(que, (dist[nv], nv))</line-19>
<line-20> return dist</line-20>
<line-21></line-21>
<line-22>n, m = map(int, input().split())</line-22>
<line-23>W = tuple(map(int, input().split()))</line-23>
<line-24>LV = sorted((tuple(map(int, input().split())) for _ in range(m)), key=itemgetter(1))</line-24>
<line-25>L, V = zip(*LV)</line-25>
<line-26>P = [0]</line-26>
<line-27>w_max = max(W)</line-27>
<line-28>for l, v in LV:</line-28>
<line-29> if w_max > v:</line-29>
<line-30> print(-1)</line-30>
<line-31> return</line-31>
<line-32> if P[-1] > l:</line-32>
<line-33> P.append(P[-1])</line-33>
<line-34> else:</line-34>
<line-35> P.append(l)</line-35>
<line-36>def f(K):</line-36>
<line-37> S = list(accumulate((W[k] for k in K)))</line-37>
<line-38> edge = [[] for _ in range(n)]</line-38>
<line-39> for i in range(n-1):</line-39>
<line-40> edge[i+1].append((i, 0))</line-40>
<line-41> for i in range(n-1):</line-41>
<line-42> for j in range(i+1, n):</line-42>
<line-43> if i == 0:</line-43>
<line-44> t = S[j]</line-44>
<line-45> else:</line-45>
<line-46> t = S[j] - S[i-1]</line-46>
<line-47> p = P[bisect.bisect_left(V, t)]</line-47>
<line-48> edge[j].append((i, -p))</line-48>
<line-49> return -dijkstra(n-1, edge)[0]</line-49>
<line-50></line-50>
<line-51>ans = float("inf")</line-51>
<line-52>for K in permutations(range(n)):</line-52>
<line-54>print(ans)</line-54>
|
{"code": "<line-2>input = sys.stdin.readline</line-2>\n<line-53> ans = min(ans, f(K))</line-53>", "lines": [2, 53]}
#### 0
|
<line-1>a, b = map(int, input().split())</line-1>
<line-2></line-2>
<line-4> print(0)</line-4>
<line-5>else:</line-5>
<line-6> s = 1</line-6>
<line-7> for i in range(a + 1, b + 1):</line-7>
<line-9> print(str(s)[-1])</line-9>
|
{"code": "<line-3>if b - a > 10:</line-3>\n<line-8>\t\ts *= i</line-8>", "lines": [3, 8]}
#### 0
|
<line-1>'''input</line-1>
<line-3>1001</line-3>
<line-4>'''</line-4>
<line-5></line-5>
<line-6>def list_input():</line-6>
<line-7> return list(map(int,input().split()))</line-7>
<line-8>def map_input():</line-8>
<line-9> return map(int,input().split())</line-9>
<line-10>def map_string():</line-10>
<line-11> return input().split()</line-11>
<line-12> </line-12>
<line-13>n,d = map_input()</line-13>
<line-14>s = input()</line-14>
<line-15>cur = 0</line-15>
<line-16>cnt = 0</line-16>
<line-17>while cur < n-1:</line-17>
<line-18> j = -1</line-18>
<line-19> for i in range(cur+1,min(cur+d+1,n)):</line-19>
<line-20> if s[i] == '1': j = i</line-20>
<line-21> if j == -1:</line-21>
<line-22> print(-1)</line-22>
<line-23> break</line-23>
<line-24> cur = j</line-24>
<line-26>else: print(cnt) </line-26>
|
{"code": "<line-2>4 2</line-2>\n<line-25>\tcnt += 1</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>def prime(x):</line-1>
<line-3> return False</line-3>
<line-4> if x == 2:</line-4>
<line-5> return True</line-5>
<line-6> if x % 2 == 0:</line-6>
<line-7> return False</line-7>
<line-8></line-8>
<line-9> for d in range(3, x, 2):</line-9>
<line-10> if d * d > x:</line-10>
<line-11> break</line-11>
<line-12> if x % d == 0:</line-12>
<line-13> return False</line-13>
<line-14></line-14>
<line-15> return True</line-15>
<line-16></line-16>
<line-17>def main():</line-17>
<line-18> n = int(input())</line-18>
<line-19> for m in range(1, 1001):</line-19>
<line-20> if not prime(n * m + 1):</line-20>
<line-21> ans = m</line-21>
<line-22> break</line-22>
<line-23></line-23>
<line-25></line-25>
<line-26>main()</line-26>
|
{"code": "<line-2> if x < 2:</line-2>\n<line-24> print(ans)</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>3</line-1>
<line-3>#</line-3>
<line-4># This program is free software; you can redistribute it and/or</line-4>
<line-5># modify it under the terms of the GNU General Public License as</line-5>
<line-6># published by the Free Software Foundation; version 3</line-6>
<line-7>#</line-7>
<line-8># This program is distributed in the hope that it will be useful,</line-8>
<line-9># but WITHOUT ANY WARRANTY; without even the implied warranty of</line-9>
<line-10># MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the</line-10>
<line-11># GNU General Public License for more details.</line-11>
<line-12>#</line-12>
<line-13># You should have received a copy of the GNU General Public License</line-13>
<line-14># along with this program; If not, see <http://www.gnu.org/licenses/>.</line-14>
<line-15></line-15>
<line-16>def main():</line-16>
<line-17> n = int(input())</line-17>
<line-18> ans = False</line-18>
<line-19> for a in range(0, 1001):</line-19>
<line-20> for b in range(0, 1001):</line-20>
<line-21> left = n - 1234567 * a - 123456 * b</line-21>
<line-22> if left >= 0 and left % 1234 == 0:</line-22>
<line-23> ans = True</line-23>
<line-25></line-25>
<line-26>main()</line-26>
|
{"code": "<line-2># Copyright (C) 2016 Sayutin Dmitry.</line-2>\n<line-24> print(\"YES\" if ans else \"NO\")</line-24>", "lines": [2, 24]}
#### 0
|
<line-1>k = []</line-1>
<line-2></line-2>
<line-4>c, d = list(map(int, input().split(' ')))</line-4>
<line-5>for i in range(x):</line-5>
<line-6> a, b = list(map(int, input().split(' ')))</line-6>
<line-7> k.append([c*a+b, d*a+b])</line-7>
<line-8></line-8>
<line-9>k.sort()</line-9>
<line-10>for i in range(len(k)-1):</line-10>
<line-11> if k[i+1][1] < k[i][1]:</line-11>
<line-12> print("YES")</line-12>
<line-14>print("NO")</line-14>
|
{"code": "<line-3>x = int(input())</line-3>\n<line-13> quit()</line-13>", "lines": [3, 13]}
#### 0
|
<line-2></line-2>
<line-3>print(1 + n // 2)</line-3>
|
{"code": "<line-1>n = int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools</line-1>
<line-2></line-2>
<line-4>inf = 10**20</line-4>
<line-5>gosa = 1.0 / 10**10</line-5>
<line-6>mod = 10**9+7</line-6>
<line-7></line-7>
<line-8>def LI(): return [int(x) for x in sys.stdin.readline().split()]</line-8>
<line-9>def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]</line-9>
<line-10>def LF(): return [float(x) for x in sys.stdin.readline().split()]</line-10>
<line-11>def LS(): return sys.stdin.readline().split()</line-11>
<line-12>def I(): return int(sys.stdin.readline())</line-12>
<line-13>def F(): return float(sys.stdin.readline())</line-13>
<line-14>def S(): return input()</line-14>
<line-15></line-15>
<line-16></line-16>
<line-17>def main():</line-17>
<line-18> n,k = LI()</line-18>
<line-19> if k == 0 or n==k:</line-19>
<line-20> return '0 0'</line-20>
<line-21></line-21>
<line-23></line-23>
<line-24>print(main())</line-24>
<line-25></line-25>
<line-26></line-26>
<line-27></line-27>
|
{"code": "<line-3>sys.setrecursionlimit(10**7)</line-3>\n<line-22> return \"1 {}\".format(min(n-k, k*2))</line-22>", "lines": [3, 22]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>cur = 1</line-3>
<line-4>lst = 1</line-4>
<line-5>while cur + lst <= n:</line-5>
<line-6> cur, lst = cur + lst, cur</line-6>
<line-8>print(x)</line-8>
|
{"code": "<line-2>x = 0</line-2>\n<line-7> x += 1</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>s = input()</line-1>
<line-3>d['V'] = 'K'</line-3>
<line-4>d['K'] = 'V'</line-4>
<line-5>m = s.count('VK')</line-5>
<line-6>s = list(s)</line-6>
<line-7>for i in range(len(s)):</line-7>
<line-8> s[i] = d[s[i]]</line-8>
<line-9> m = max(m,''.join(s).count('VK'))</line-9>
<line-11>print(m)</line-11>
|
{"code": "<line-2>d = dict()</line-2>\n<line-10> s[i] = d[s[i]]</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>while a * b < n:</line-5>
<line-6> if a < b:</line-6>
<line-7> a += 1</line-7>
<line-8> else:</line-8>
<line-10></line-10>
<line-11>print(a+b)</line-11>
|
{"code": "<line-3>a = b = 1</line-3>\n<line-9> b += 1</line-9>", "lines": [3, 9]}
#### 0
|
<line-1>def l2i(s):</line-1>
<line-3>a, b=l2i(input())</line-3>
<line-4>t=0</line-4>
<line-5>while (a<=b):</line-5>
<line-6> a*=3</line-6>
<line-7> b*=2</line-7>
<line-9>print(t)</line-9>
|
{"code": "<line-2>\treturn [int(i) for i in s.split()]</line-2>\n<line-8>\tt+=1</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>h, n = list(map(int, input().split()))</line-1>
<line-3>r = 0</line-3>
<line-4>while m > 1:</line-4>
<line-5> if c == 0:</line-5>
<line-6> if n > m // 2:</line-6>
<line-7> r += m - 1</line-7>
<line-8> n -= m // 2</line-8>
<line-9> c = 1 - c</line-9>
<line-10> else:</line-10>
<line-11> if n > m // 2:</line-11>
<line-12> n -= m // 2</line-12>
<line-13> else:</line-13>
<line-14> r += m - 1</line-14>
<line-15> c = 1 - c</line-15>
<line-16> c = 1 - c</line-16>
<line-17> r += 1</line-17>
<line-18> m //= 2</line-18>
<line-20>print(r)</line-20>
|
{"code": "<line-2>c, m = 0, 2 ** h</line-2>\n<line-19> #print(c, m, r, n)</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>x = int(input())</line-1>
<line-2></line-2>
<line-4> count = 0</line-4>
<line-5> lst = []</line-5>
<line-6> x6 = x * 6</line-6>
<line-7> for n in range(1, x + 1):</line-7>
<line-8> t, r = divmod(x6, n*(n+1))</line-8>
<line-9> if t < 2*n + 1:</line-9>
<line-10> break</line-10>
<line-11> if r:</line-11>
<line-12> continue</line-12>
<line-13> m, r = divmod(t + n - 1, 3)</line-13>
<line-14> if r:</line-14>
<line-15> continue</line-15>
<line-16> count += 2</line-16>
<line-17> lst.append((n, m))</line-17>
<line-18> nn, mm = lst[-1]</line-18>
<line-19> if nn == mm:</line-19>
<line-20> count -= 1</line-20>
<line-21> print(count)</line-21>
<line-22> for n, m in lst:</line-22>
<line-23> print(n, m)</line-23>
<line-24> if nn != mm:</line-24>
<line-25> print(mm, nn)</line-25>
<line-26> lst.reverse()</line-26>
<line-27> for n, m in lst[1:]:</line-27>
<line-29></line-29>
<line-30>solve(x)</line-30>
|
{"code": "<line-3>def solve(x):</line-3>\n<line-28> print(m, n)</line-28>", "lines": [3, 28]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>a = [0] * n</line-3>
<line-4>m = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]</line-4>
<line-5>for i in range(n):</line-5>
<line-6> a[i] = int(s[i])</line-6>
<line-7>ans = "No"</line-7>
<line-8>for i in range(len(m) - n):</line-8>
<line-9> if a == m[i:i+n]:</line-9>
<line-10> ans = "Yes"</line-10>
<line-12>print(ans)</line-12>
|
{"code": "<line-2>s = input().split()</line-2>\n<line-11> break</line-11>", "lines": [2, 11]}
#### 0
|
<line-1>from math import sqrt</line-1>
<line-2></line-2>
<line-4> ans = u</line-4>
<line-5> for i in range(2, int(sqrt(n)) + 1):</line-5>
<line-6> if u % i == 0:</line-6>
<line-7> while u % i == 0:</line-7>
<line-8> u = u / i</line-8>
<line-9> ans = ans - int(ans / i)</line-9>
<line-10> if n > 1:</line-10>
<line-11> ans = ans - int(ans / n)</line-11>
<line-12> return ans</line-12>
<line-13></line-13>
<line-14>def binpow(u, a, mod):</line-14>
<line-15> ans = 1</line-15>
<line-16> if a == 0:</line-16>
<line-17> return 1;</line-17>
<line-18> while a > 0:</line-18>
<line-19> if a % 2 == 0:</line-19>
<line-20> u = (u ** 2) % mod</line-20>
<line-21> a = int(a / 2)</line-21>
<line-22> else :</line-22>
<line-23> ans = (ans * u) % mod</line-23>
<line-24> a = a - 1</line-24>
<line-25> return int(ans)</line-25>
<line-26></line-26>
<line-27>n = int(input())</line-27>
<line-28></line-28>
<line-29>b1 = 1</line-29>
<line-30>b2 = 0</line-30>
<line-31>nn = n</line-31>
<line-32>for i in range(2, int(sqrt(n)) + 1):</line-32>
<line-33> if n%i == 0 :</line-33>
<line-34> while nn % i == 0:</line-34>
<line-35> b1 = b1 * i</line-35>
<line-36> nn = nn / i</line-36>
<line-37> b2 = int(n / b1)</line-37>
<line-38> break</line-38>
<line-39></line-39>
<line-40>if b2 < 2:</line-40>
<line-41> print("NO")</line-41>
<line-42> return</line-42>
<line-43>a1 = b1 - binpow(b2, phi(b1) - 1, b1)</line-43>
<line-44>a2 = b2 - int((a1*b2+1)/b1)</line-44>
<line-45>print("YES")</line-45>
<line-46>print(2)</line-46>
<line-48>print(a2, b2)</line-48>
|
{"code": "<line-3>def phi(u):</line-3>\n<line-47>print(a1, b1)</line-47>", "lines": [3, 47]}
#### 0
|
<line-1>r = open('input.txt')</line-1>
<line-3></line-3>
<line-4>f = lambda: map(int, r.readline().split())</line-4>
<line-5></line-5>
<line-6>f()</line-6>
<line-7>a, b = f()</line-7>
<line-8>if a > b: a, b = b, a</line-8>
<line-9>n = 40001</line-9>
<line-10>u, v = [n] * n, [n] * n</line-10>
<line-11>x = s = 0</line-11>
<line-12>u[0] = v[0] = 0</line-12>
<line-13></line-13>
<line-14>for y in f():</line-14>
<line-15> s += y</line-15>
<line-16> p = []</line-16>
<line-17> h = min(x, y)</line-17>
<line-18> for d in range(min(s, a), max(0, s - b - y) - 1, -1):</line-18>
<line-19> t = v[d]</line-19>
<line-20></line-20>
<line-21> if u[d] != n:</line-21>
<line-22> u[d + y] = min(u[d], u[d + y])</line-22>
<line-23> v[d] = min(t, u[d] + h)</line-23>
<line-24> u[d] = n</line-24>
<line-25></line-25>
<line-26> if t != n:</line-26>
<line-27> u[d + y] = min(u[d + y], t + h)</line-27>
<line-28> x = y</line-28>
<line-29></line-29>
<line-30>i = max(s - b, 0)</line-30>
<line-31>j = min(s, a) + 1</line-31>
<line-32></line-32>
<line-33>d = min(u[i:j] + v[i:j]) if i < j else n</line-33>
<line-34>w.write(str(d if d < n else -1))</line-34>
<line-35></line-35>
<line-37>r.close()</line-37>
|
{"code": "<line-2>w = open('output.txt', mode='w')</line-2>\n<line-36>w.close()</line-36>", "lines": [2, 36]}
#### 0
|
<line-1>def gcd(a, b):</line-1>
<line-3> while b:</line-3>
<line-4> a, b = b, a % b</line-4>
<line-5> return a</line-5>
<line-6></line-6>
<line-7></line-7>
<line-8>n, m, k = list(map(int, input().split()))</line-8>
<line-9>_n, _m = n, m</line-9>
<line-10>n, k = n // gcd(n, k), k // gcd(n, k)</line-10>
<line-11>m, k = m // gcd(m, k), k // gcd(m, k)</line-11>
<line-12>a = 2</line-12>
<line-13>a, k = a // gcd(a, k), k // gcd(a, k)</line-13>
<line-14>if k != 1:</line-14>
<line-15> print("NO")</line-15>
<line-16>elif a * n <= _n:</line-16>
<line-17> print("YES")</line-17>
<line-18> print("0 0")</line-18>
<line-19> print(a * n, 0)</line-19>
<line-20> print(0, m)</line-20>
<line-21>elif a * m <= _m:</line-21>
<line-22> print("YES")</line-22>
<line-23> print("0 0")</line-23>
<line-24> print(n, 0)</line-24>
<line-25> print(0, m * a)</line-25>
<line-27> print("NO")</line-27>
|
{"code": "<line-2> a, b = max(a, b), min(a, b)</line-2>\n<line-26>else:</line-26>", "lines": [2, 26]}
#### 0
|
<line-2>n=(n//k)%2</line-2>
<line-3>print('YES' if n==1 else 'NO')</line-3>
|
{"code": "<line-1>n,k=list(map(int,input().split()))</line-1>", "lines": [1]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>A=[0,0,0]</line-5>
<line-6>for i in range(n):</line-6>
<line-7> A[i%3]+=int(s[i])</line-7>
<line-8></line-8>
<line-9>m=max(A)</line-9>
<line-10></line-10>
<line-11>if(m==A[0]):</line-11>
<line-12> print("chest")</line-12>
<line-13>elif(m==A[1]):</line-13>
<line-14> print("biceps")</line-14>
<line-16> print("back")</line-16>
|
{"code": "<line-3>s=input().split()</line-3>\n<line-15>else:</line-15>", "lines": [3, 15]}
#### 0
|
<line-1>def read_input():</line-1>
<line-3></line-3>
<line-4>n = int(input())</line-4>
<line-5>a = sorted(read_input())</line-5>
<line-6></line-6>
<line-7>s = sum(a)</line-7>
<line-8>i = 0</line-8>
<line-9></line-9>
<line-10>while 2 * s < 9 * n:</line-10>
<line-11> delta = 5 - a[i]</line-11>
<line-12> s += delta</line-12>
<line-14></line-14>
<line-15>print(i)</line-15>
|
{"code": "<line-2>\treturn map(int, input().split())</line-2>\n<line-13>\ti += 1</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>u, v = list(map(int, input().split()))</line-1>
<line-3> print(-1)</line-3>
<line-4>else:</line-4>
<line-5> if u == v:</line-5>
<line-6> if u == 0:</line-6>
<line-7> print(0)</line-7>
<line-8> else:</line-8>
<line-9> print("1\n" + str(u))</line-9>
<line-10> else:</line-10>
<line-11> w = (v - u) // 2</line-11>
<line-12> if (w | u) == (w + u):</line-12>
<line-13> print("2\n" + str(w|u) + ' ' + str(w))</line-13>
<line-15> print("3\n" + str(u) + ' ' + str(w) + ' ' + str(w))</line-15>
<line-16></line-16>
|
{"code": "<line-2>if v < u or (v - u) % 2 != 0:</line-2>\n<line-14> else:</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>"""</line-1>
<line-3></line-3>
<line-4>Author : chaotic_iak</line-4>
<line-5>Language: Python 3.3.4</line-5>
<line-6>"""</line-6>
<line-7></line-7>
<line-8>def read(mode=2):</line-8>
<line-9> # 0: String</line-9>
<line-10> # 1: List of strings</line-10>
<line-11> # 2: List of integers</line-11>
<line-12> inputs = input().strip()</line-12>
<line-13> if mode == 0:</line-13>
<line-14> return inputs</line-14>
<line-15> if mode == 1:</line-15>
<line-16> return inputs.split()</line-16>
<line-17> if mode == 2:</line-17>
<line-18> return [int(x) for x in inputs.split()]</line-18>
<line-19></line-19>
<line-20>def write(s="\n"):</line-20>
<line-21> if isinstance(s, list): s = " ".join(s)</line-21>
<line-22> s = str(s)</line-22>
<line-23> print(s, end="")</line-23>
<line-24></line-24>
<line-25>################################################### SOLUTION</line-25>
<line-26>def g(n):</line-26>
<line-27> return (10**n-1)//9</line-27>
<line-28></line-28>
<line-29>def solve(n):</line-29>
<line-30> if n <= 6: return n</line-30>
<line-31> if 7 <= n <= 11: return 13-n</line-31>
<line-32> l = 1</line-32>
<line-33> while g(l) < n: l += 1</line-33>
<line-34> l -= 1</line-34>
<line-35> gl = g(l)</line-35>
<line-36> a = n</line-36>
<line-37> res1 = 0</line-37>
<line-38> res1 += (a // gl) * l</line-38>
<line-39> a %= gl</line-39>
<line-40> res1 += solve(a)</line-40>
<line-41> b = g(l+1) - n</line-41>
<line-42> res2 = l+1</line-42>
<line-43> res2 += (b // gl) * l</line-43>
<line-44> b %= gl</line-44>
<line-45> res2 += solve(b)</line-45>
<line-46> return min(res1, res2)</line-46>
<line-47></line-47>
<line-49>print(solve(n))</line-49>
|
{"code": "<line-2>Codeforces Testing Round 10 Problem C</line-2>\n<line-48>n, = read()</line-48>", "lines": [2, 48]}
#### 0
|
<line-1>x1, y1, x2, y2 = list(map(int, input().split()))</line-1>
<line-3></line-3>
<line-4>x, y = abs(x), abs(y)</line-4>
<line-5></line-5>
<line-6>x_ = abs(x2 - x1)</line-6>
<line-7>y_ = abs(y2 - y1)</line-7>
<line-8></line-8>
<line-9>if x_ % x == 0 and y_ % y == 0:</line-9>
<line-10> if (x_ // x + y_ // y) % 2 == 0:</line-10>
<line-11> print("YES")</line-11>
<line-12> else:</line-12>
<line-13> print("NO")</line-13>
<line-15> print("NO")</line-15>
|
{"code": "<line-2>x, y = list(map(int, input().split()))</line-2>\n<line-14>else:</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>n=input()</line-1>
<line-3>for i in n: rg[int(i)]+=1</line-3>
<line-4>rl=[]</line-4>
<line-5>ff=0</line-5>
<line-6>for i in range(len(rg)):</line-6>
<line-7> if rg[i]!=0:</line-7>
<line-8> rl.append(rg[i])</line-8>
<line-9> if i==0: ff=1</line-9>
<line-10>fact=[1]</line-10>
<line-11>fc=1</line-11>
<line-12>for i in range(1,20):</line-12>
<line-13> fc*=i</line-13>
<line-14> fact.append(fc)</line-14>
<line-15>rt=[]</line-15>
<line-16>t=0</line-16>
<line-17>def cfs(d):</line-17>
<line-18> if d==len(rl):</line-18>
<line-19> nonlocal t,ff</line-19>
<line-20> jj=fact[sum(rt)]</line-20>
<line-21> for i in rt: jj=jj/fact[i]</line-21>
<line-22> if ff:</line-22>
<line-23> jjj=fact[sum(rt)-1]</line-23>
<line-24> jjj=jjj/fact[rt[0]-1]</line-24>
<line-25> for i in range(1,len(rt)): jjj=jjj/fact[rt[i]]</line-25>
<line-26> jj-=jjj</line-26>
<line-27> t+=jj</line-27>
<line-28> return</line-28>
<line-29> </line-29>
<line-30> for i in range(1,rl[d]+1):</line-30>
<line-31> rt.append(i)</line-31>
<line-32> cfs(d+1)</line-32>
<line-33> rt.pop(-1)</line-33>
<line-34></line-34>
<line-35>cfs(0)</line-35>
<line-36>print(int(t))</line-36>
<line-37></line-37>
<line-38></line-38>
<line-39> </line-39>
<line-40> </line-40>
<line-41> </line-41>
<line-42></line-42>
<line-43>'''</line-43>
<line-44>//////////////// ////// /////// // /////// // // //</line-44>
<line-45>//// // /// /// /// /// // /// /// //// //</line-45>
<line-46>//// //// /// /// /// /// // ///////// //// ///////</line-46>
<line-47>//// ///// /// /// /// /// // /// /// //// // //</line-47>
<line-49>'''</line-49>
<line-50></line-50>
|
{"code": "<line-2>rg=[0]*10</line-2>\n<line-48>////////////// /////////// /////////// ////// /// /// // // // //</line-48>", "lines": [2, 48]}
#### 0
|
<line-1>a=int(input())</line-1>
<line-3>c=int(input())</line-3>
<line-4>d=int(input())</line-4>
<line-5>e=int(input())</line-5>
<line-6>f=int(input())</line-6>
<line-7>if e>=f:</line-7>
<line-8> ans=min(a,d)</line-8>
<line-9> d-=ans</line-9>
<line-10> a-=ans</line-10>
<line-11> ans*=e</line-11>
<line-12> ans+=min(d,b,c)*f</line-12>
<line-13>else:</line-13>
<line-14> ans=min(d,b,c)</line-14>
<line-15> d-=ans</line-15>
<line-16> ans*=f</line-16>
<line-18>print(ans)</line-18>
|
{"code": "<line-2>b=int(input())</line-2>\n<line-17> ans+=min(a,d)*e</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>a, b, p, x = [int(x) for x in input().split()]</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>while powers[-1] != 1:</line-5>
<line-6> powers.append(powers[-1] * a % p)</line-6>
<line-7> </line-7>
<line-8>order = len(powers)</line-8>
<line-9>powers = [powers[-1]] + powers</line-9>
<line-10></line-10>
<line-11>inverse = pow(order, p-2, p)</line-11>
<line-12></line-12>
<line-13>def f(sol):</line-13>
<line-14> return (x // (p * order)) + (1 if sol <= x % (p * order) else 0)</line-14>
<line-15></line-15>
<line-16>def chinese(a, n, b, m):</line-16>
<line-17> k = inverse * (b - a + m) % m</line-17>
<line-18> x = k * n + a</line-18>
<line-19> return x % (n * m)</line-19>
<line-20></line-20>
<line-21>res = 0</line-21>
<line-22>for i in range(len(powers)-1):</line-22>
<line-23> inv = powers[order - i]</line-23>
<line-24> val = inv * b % p</line-24>
<line-25> </line-25>
<line-26> sol = chinese(i, order, val, p)</line-26>
<line-27> </line-27>
<line-29> </line-29>
<line-30>print(res)</line-30>
|
{"code": "<line-3>powers = [a]</line-3>\n<line-28> res += f(sol)</line-28>", "lines": [3, 28]}
#### 0
|
<line-1>k2, k3, k5, k6 = list(map(int, input().split()))</line-1>
<line-3>k2 -= c</line-3>
<line-4>ans = 256 * c</line-4>
<line-6>print(ans)</line-6>
|
{"code": "<line-2>c = min(k2, k5, k6)</line-2>\n<line-5>ans += 32 * min(k3, k2)</line-5>", "lines": [2, 5]}
#### 0
|
<line-1>x, y, n, c = 0, 0, 0, 0</line-1>
<line-3> return m * m</line-3>
<line-4>def suma_n(m):</line-4>
<line-5> return m * (m - 1) // 2</line-5>
<line-6>def cnt(t):</line-6>
<line-7> u, d, l, r = x + t, x - t, y - t, y + t</line-7>
<line-8> suma = t ** 2 + (t + 1) ** 2</line-8>
<line-9> if u > n: suma -= suma_impares(u - n)</line-9>
<line-10> if d < 1: suma -= suma_impares(1 - d)</line-10>
<line-11> if l < 1: suma -= suma_impares(1 - l)</line-11>
<line-12> if r > n: suma -= suma_impares(r - n)</line-12>
<line-13> if 1 - l > x - 1 and 1 - d > y - 1:</line-13>
<line-14> suma += suma_n(2 - l - x)</line-14>
<line-15> if r - n > x - 1 and 1 - d > n - y:</line-15>
<line-16> suma += suma_n(r - n - x + 1)</line-16>
<line-17> if 1 - l > n - x and u - n > y - 1:</line-17>
<line-18> suma += suma_n(1 - l - n + x)</line-18>
<line-19> if u - n > n - y and r - n > n - x:</line-19>
<line-20> suma += suma_n(u - n - n + y)</line-20>
<line-21> return suma</line-21>
<line-22> </line-22>
<line-23>n, x, y, c = input().split()</line-23>
<line-24>n, x, y, c = int(n), int(x), int(y), int(c)</line-24>
<line-25>#for i in range(10):</line-25>
<line-26># print(i, cnt(i))</line-26>
<line-27>ini, fin = 0, int(1e9)</line-27>
<line-28>cont = int(1e9)</line-28>
<line-29>while cont > 0:</line-29>
<line-30> m = ini</line-30>
<line-31> paso = cont // 2</line-31>
<line-32> m += paso</line-32>
<line-33> if cnt(m) < c:</line-33>
<line-34> ini = m + 1</line-34>
<line-35> cont -= paso + 1</line-35>
<line-36> else:</line-36>
<line-38>print(ini)</line-38>
|
{"code": "<line-2>def suma_impares(m):</line-2>\n<line-37>\t\tcont = paso</line-37>", "lines": [2, 37]}
#### 0
|
<line-1>import sys</line-1>
<line-3>i=64</line-3>
<line-4>while i>=0:</line-4>
<line-5> if ((1<<i)&l!=0 and (1<<i)&r!=0) or ((1<<i)&l==0 and (1<<i)&r==0):i-=1</line-5>
<line-7>print((1<<(i+1))-1)</line-7>
|
{"code": "<line-2>l,r=map(int,(sys.stdin.readline().split()))</line-2>\n<line-6> else:break</line-6>", "lines": [2, 6]}
#### 0
|
<line-2></line-2>
<line-3>print((K+N-1)//N)</line-3>
|
{"code": "<line-1>N, K = list(map(int, input().split()))</line-1>", "lines": [1]}
#### 0
|
<line-1>x, y, z, t1, t2, t3 = map(int, input().split())</line-1>
<line-3>elevator = abs(x - z) * t2 + 3 * t3 + abs(x - y) * t2</line-3>
<line-4>if elevator > ladder:</line-4>
<line-5> print("NO")</line-5>
<line-7> print("YES")</line-7>
|
{"code": "<line-2>ladder = abs(x - y) * t1</line-2>\n<line-6>else:</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>n, m = list(map(int, input().split()))</line-1>
<line-3> print(1)</line-3>
<line-4>elif m - 1 >= n - m:</line-4>
<line-5> print(m - 1)</line-5>
<line-7> print(m + 1)</line-7>
|
{"code": "<line-2>if n == 1:</line-2>\n<line-6>else:</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>c = 0</line-3>
<line-4>l = 0</line-4>
<line-5>b = 0</line-5>
<line-6>while c < len(a) and a[c] == 0:</line-6>
<line-7> c += 1</line-7>
<line-8> b += 1</line-8>
<line-9></line-9>
<line-10>if c == len(a):</line-10>
<line-11> print(0)</line-11>
<line-12> return</line-12>
<line-13></line-13>
<line-14>d = len(a) - 1</line-14>
<line-15>while a[d] != 1:</line-15>
<line-16> d -= 1</line-16>
<line-17> b += 1</line-17>
<line-18></line-18>
<line-19>while c <= d:</line-19>
<line-20> if a[c] == 0:</line-20>
<line-21> l += 1</line-21>
<line-22> else:</line-22>
<line-23> if l > 1:</line-23>
<line-24> b += l</line-24>
<line-25> l = 0</line-25>
<line-27></line-27>
<line-28>print(n - b)</line-28>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-26> c += 1</line-26>", "lines": [2, 26]}
#### 0
|
<line-1>#!/bin/python</line-1>
<line-2></line-2>
<line-4>p = list(map(int, input().split()))</line-4>
<line-5></line-5>
<line-6>a, b = 0, 0</line-6>
<line-7>for i in range(n):</line-7>
<line-8> a += p[i]</line-8>
<line-9> x = min(8, a)</line-9>
<line-10> b += x</line-10>
<line-11> a -= x</line-11>
<line-12> if b >= k:</line-12>
<line-13> print(i+1)</line-13>
<line-14> break</line-14>
<line-16> print(-1)</line-16>
|
{"code": "<line-3>n, k = list(map(int, input().split()))</line-3>\n<line-15>else:</line-15>", "lines": [3, 15]}
#### 0
|
<line-1>n, k = list(map(int, input().split()))</line-1>
<line-3></line-3>
<line-4>ans = 0</line-4>
<line-5>for i in range(1, n):</line-5>
<line-6> diff = k - (a[i] + a[i - 1])</line-6>
<line-7> if diff > 0:</line-7>
<line-8> a[i] += diff</line-8>
<line-9> ans += diff</line-9>
<line-10></line-10>
<line-12>print(' '.join(map(str, a)))</line-12>
<line-13></line-13>
|
{"code": "<line-2>a = list(map(int, input().split()))</line-2>\n<line-11>print(ans)</line-11>", "lines": [2, 11]}
#### 0
|
<line-2>a = n * (n + 1) // 2</line-2>
<line-3>print(4 * a - 4 * n + 1)</line-3>
|
{"code": "<line-1>n = int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>a = [False for i in range(26)]</line-3>
<line-4>for x in s:</line-4>
<line-5> a[ord(x.lower()) - ord('a')] = True</line-5>
<line-6>for x in a:</line-6>
<line-7> if not x:</line-7>
<line-8> print('NO')</line-8>
<line-10>print('YES')</line-10>
|
{"code": "<line-2>s = input()</line-2>\n<line-9> return</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>def main():</line-1>
<line-3> c = int(input())</line-3>
<line-4></line-4>
<line-5> a += c // 60</line-5>
<line-6> b += c % 60</line-6>
<line-7> if b > 59:</line-7>
<line-8> b %= 60</line-8>
<line-9> a += 1</line-9>
<line-10></line-10>
<line-11> aa = str(a % 24)</line-11>
<line-12> if len(aa) < 2:</line-12>
<line-13> aa = "0" + aa</line-13>
<line-14></line-14>
<line-15> bb = str(b % 60)</line-15>
<line-16> if len(bb) < 2:</line-16>
<line-17> bb = "0" + bb</line-17>
<line-18></line-18>
<line-19> print(aa + ":" + bb)</line-19>
<line-20></line-20>
<line-21>def __starting_point():</line-21>
<line-23>__starting_point()</line-23>
|
{"code": "<line-2> a, b = map(int, input().split(\":\"))</line-2>\n<line-22> main()</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>n, m = list(map(int, input().split()))</line-1>
<line-3></line-3>
<line-4>ignorable = [True] * n</line-4>
<line-5></line-5>
<line-6>for i in range(m):</line-6>
<line-7> cnt = 0</line-7>
<line-8> for j in range(n):</line-8>
<line-9> cnt += a[j][i]</line-9>
<line-10> if cnt == 1:</line-10>
<line-11> for j in range(n):</line-11>
<line-12> if a[j][i]:</line-12>
<line-13> ignorable[j] = False</line-13>
<line-14></line-14>
<line-15>if any(ignorable):</line-15>
<line-16> print('YES')</line-16>
<line-18> print('NO')</line-18>
|
{"code": "<line-2>a = [list(map(int, input())) for i in range(n)]</line-2>\n<line-17>else:</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>N = int(input())</line-1>
<line-3>Sum = 0</line-3>
<line-4>Sum_l, Sum_r = 0, 0</line-4>
<line-5>for i in range(N):</line-5>
<line-6> x, y = list(map(int, input().split()))</line-6>
<line-7> Sum_l += x</line-7>
<line-8> Sum_r += y</line-8>
<line-9> Sum += x + y</line-9>
<line-10> if (x % 2 + y % 2) % 2:</line-10>
<line-11> Check = True</line-11>
<line-12>if Sum % 2:</line-12>
<line-13> print(-1)</line-13>
<line-14>elif Sum_l % 2:</line-14>
<line-15> if not Check:</line-15>
<line-16> print(-1)</line-16>
<line-17> else:</line-17>
<line-18> print(1)</line-18>
<line-20> print(0)</line-20>
|
{"code": "<line-2>Check = False</line-2>\n<line-19>elif Sum_l % 2 == 0:</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>def isPrime(n) : </line-1>
<line-3> if (n <= 1) : </line-3>
<line-4> return False</line-4>
<line-5> if (n <= 3) : </line-5>
<line-6> return True</line-6>
<line-7> </line-7>
<line-8> # This is checked so that we can skip </line-8>
<line-9> # middle five numbers in below loop </line-9>
<line-10> if (n % 2 == 0 or n % 3 == 0) : </line-10>
<line-11> return False</line-11>
<line-12> </line-12>
<line-13> i = 5</line-13>
<line-14> while(i * i <= n) : </line-14>
<line-15> if (n % i == 0 or n % (i + 2) == 0) : </line-15>
<line-16> return False</line-16>
<line-17> i = i + 6</line-17>
<line-18> </line-18>
<line-19> return True</line-19>
<line-20>t=int(input())</line-20>
<line-21>for yes in range(t):</line-21>
<line-22> a,b=map(int,input().split())</line-22>
<line-23> xx=a-b</line-23>
<line-24> yy=a+b </line-24>
<line-25> if xx==1 and isPrime(yy)==True:</line-25>
<line-26> print("YES")</line-26>
<line-28> print("NO")</line-28>
|
{"code": "<line-2> # Corner cases </line-2>\n<line-27>\telse:</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>rcnt = 0</line-3>
<line-4>for i in range(n):</line-4>
<line-5> x, y = map(int, input().split())</line-5>
<line-6> if x < 0:</line-6>
<line-7> lcnt += 1</line-7>
<line-8> else:</line-8>
<line-9> rcnt += 1</line-9>
<line-10></line-10>
<line-11>if (lcnt <= 1 or rcnt <= 1):</line-11>
<line-12> print("Yes")</line-12>
<line-14> print("No")</line-14>
|
{"code": "<line-2>lcnt = 0</line-2>\n<line-13>else:</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>a, b = map(int, input().split())</line-1>
<line-3>ans = 1</line-3>
<line-4>for i in range(1, a + 1):</line-4>
<line-6>print(ans)</line-6>
|
{"code": "<line-2>a = min(a, b)</line-2>\n<line-5> ans *= i</line-5>", "lines": [2, 5]}
#### 0
|
<line-2>print (9 * n, 8 * n)</line-2>
|
{"code": "<line-1>n = int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>def reachable(es, source):</line-1>
<line-3> Q = [source]</line-3>
<line-4> while Q:</line-4>
<line-5> cur = Q.pop()</line-5>
<line-6> for nxt in es[cur]:</line-6>
<line-7> if nxt not in ret:</line-7>
<line-8> Q.append(nxt)</line-8>
<line-9> ret.add(nxt)</line-9>
<line-10> return ret</line-10>
<line-11></line-11>
<line-12>def BellmanFord(V:int, es:list, source=0):</line-12>
<line-13> INF = float("inf")</line-13>
<line-14> D = [INF]*V</line-14>
<line-15> D[source] = 0</line-15>
<line-16> for _ in range(V):</line-16>
<line-17> upd = False</line-17>
<line-18> for f, t, c in es:</line-18>
<line-19> tmp = D[f] + c</line-19>
<line-20> if D[t] > tmp:</line-20>
<line-21> D[t] = tmp</line-21>
<line-22> upd = True</line-22>
<line-23> if not upd:</line-23>
<line-24> return D[-1]</line-24>
<line-25> else:</line-25>
<line-26> return None</line-26>
<line-27> </line-27>
<line-28>def main():</line-28>
<line-29> N,M,P,*L=map(int,open(0).read().split())</line-29>
<line-30> fwd = [[] for _ in range(N)]</line-30>
<line-31> bwd = [[] for _ in range(N)]</line-31>
<line-32> tmp = []</line-32>
<line-33> for a,b,c in zip(*[iter(L)]*3):</line-33>
<line-34> fwd[a-1].append(b-1)</line-34>
<line-35> bwd[b-1].append(a-1)</line-35>
<line-36> tmp+=[(a-1,b-1,P-c)]</line-36>
<line-37> judge = reachable(fwd,0) & reachable(bwd,N-1)</line-37>
<line-38> ans = BellmanFord(N,[(a,b,c) for a,b,c in tmp if a in judge and b in judge])</line-38>
<line-39> if ans==None:</line-39>
<line-40> print(-1)</line-40>
<line-41> else:</line-41>
<line-42> print(max(0,-ans))</line-42>
<line-43></line-43>
<line-44>def __starting_point():</line-44>
<line-46>__starting_point()</line-46>
|
{"code": "<line-2>\tret = {source}</line-2>\n<line-45>\tmain()</line-45>", "lines": [2, 45]}
#### 0
|
<line-1>it = lambda: list(map(int, input().strip().split()))</line-1>
<line-3></line-3>
<line-4></line-4>
<line-5>def solve():</line-5>
<line-6> N = int(input())</line-6>
<line-7> S = []</line-7>
<line-8> R = []</line-8>
<line-9> C = []</line-9>
<line-10> for _ in range(N):</line-10>
<line-11> s, c = input().strip().split()</line-11>
<line-12> S.append(s)</line-12>
<line-13> R.append(s[::-1])</line-13>
<line-14> C.append(int(c))</line-14>
<line-15> </line-15>
<line-16> vis = set()</line-16>
<line-17> mem = dict()</line-17>
<line-18></line-18>
<line-19> def dp(s, p):</line-19>
<line-20> if (s, p) in mem: return mem[s, p]</line-20>
<line-21> if s == s[::-1]: return 0</line-21>
<line-22> if (s, p) in vis: return INF</line-22>
<line-23></line-23>
<line-24> ans = INF</line-24>
<line-25> vis.add((s, p))</line-25>
<line-26> for i, t in enumerate(S if p else R):</line-26>
<line-27> if len(t) >= len(s) and t.startswith(s):</line-27>
<line-28> ans = min(ans, dp(t[len(s):], p ^ 1) + C[i])</line-28>
<line-29> elif len(s) > len(t) and s.startswith(t):</line-29>
<line-30> ans = min(ans, dp(s[len(t):], p) + C[i])</line-30>
<line-31> vis.discard((s, p))</line-31>
<line-32> mem[s, p] = ans</line-32>
<line-33> return ans</line-33>
<line-34> </line-34>
<line-35> ans = INF</line-35>
<line-36> for i in range(N):</line-36>
<line-37> ans = min(ans, dp(S[i], 0) + C[i])</line-37>
<line-38> return -1 if ans == INF else ans</line-38>
<line-39></line-39>
<line-40></line-40>
<line-41>def __starting_point():</line-41>
<line-42> ans = solve()</line-42>
<line-44>__starting_point()</line-44>
|
{"code": "<line-2>INF = float('inf')</line-2>\n<line-43> print(ans)</line-43>", "lines": [2, 43]}
#### 0
|
<line-1>R=lambda:list(map(int,input().split()))</line-1>
<line-3>if k==1:print(n)</line-3>
<line-4>else:</line-4>
<line-5> i=0</line-5>
<line-7> print((1<<i)-1)</line-7>
|
{"code": "<line-2>n,k=R()</line-2>\n<line-6> while (1<<i)<=n:i+=1</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>for _ in range(n):</line-3>
<line-4> a,b = list(map(int,input().split()))</line-4>
<line-6>print(res)</line-6>
|
{"code": "<line-2>res = -float('inf')</line-2>\n<line-5> res = max(res,a+b)</line-5>", "lines": [2, 5]}
#### 0
|
<line-2>for i in input(): t[i] += 1</line-2>
<line-3>print(min([t['i'], t['t'], t['e'] // 3, max(0, (t['n'] - 1)) // 2]))</line-3>
|
{"code": "<line-1>t = {i: 0 for i in 'qwertyuiopasdfghjklzxcvbnm'}</line-1>", "lines": [1]}
#### 0
|
<line-1>import sys, math</line-1>
<line-2></line-2>
<line-4>f = sys.stdin</line-4>
<line-5></line-5>
<line-6>P, Y = list(map(int, f.readline().split()))</line-6>
<line-7></line-7>
<line-8>is_ok = False</line-8>
<line-9>for t in range(Y, P, -1):</line-9>
<line-10> is_ok = True</line-10>
<line-11> for x in range(2, P+1):</line-11>
<line-12> if t%x == 0:</line-12>
<line-13> is_ok = False</line-13>
<line-14> break</line-14>
<line-15> if x*x > t:</line-15>
<line-16> break</line-16>
<line-17> if is_ok:</line-17>
<line-18> print(t)</line-18>
<line-19> break</line-19>
<line-21> print(-1)</line-21>
|
{"code": "<line-3>#f = open('input_0', 'r')</line-3>\n<line-20>if not is_ok:</line-20>", "lines": [3, 20]}
#### 0
|
<line-1>n, m, k = list(map(int, input().split()))</line-1>
<line-3>line = list(map(int, input().split()))</line-3>
<line-4>answer = n</line-4>
<line-5>for i in range(n):</line-5>
<line-6> if line[i] == 0:</line-6>
<line-7> continue</line-7>
<line-8> if line[i] > k:</line-8>
<line-9> continue</line-9>
<line-11>print(answer * 10)</line-11>
|
{"code": "<line-2>m -= 1</line-2>\n<line-10> answer = min(answer, abs(m - i))</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>from collections import Counter</line-1>
<line-2></line-2>
<line-3></line-3>
<line-5> res = tuple((Counter() for _ in range(n + m)))</line-5>
<line-6> for i in range(n):</line-6>
<line-7> for j, a in enumerate(map(int, input().split())):</line-7>
<line-8> res[i + j][a] += 1</line-8>
<line-9> return res</line-9>
<line-10></line-10>
<line-11></line-11>
<line-12>n, m = list(map(int, input().split()))</line-12>
<line-13>if input_matrix() == input_matrix():</line-13>
<line-14> print("YES")</line-14>
<line-16> print("NO")</line-16>
|
{"code": "<line-4>def input_matrix():</line-4>\n<line-15>else:</line-15>", "lines": [4, 15]}
#### 0
|
<line-1>import sys</line-1>
<line-3>b = input()</line-3>
<line-4>if a != b:</line-4>
<line-5> print(max(len(a), len(b)))</line-5>
<line-7> print(-1)</line-7>
|
{"code": "<line-2>a = input()</line-2>\n<line-6>else:</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>a, b = map(int,input().split())</line-1>
<line-3>ONE = set()</line-3>
<line-4>TWO = set()</line-4>
<line-5>for i in range(b, 50000, a):</line-5>
<line-6> ONE.add(i)</line-6>
<line-7>for i in range(d, 50000, c):</line-7>
<line-8> TWO.add(i)</line-8>
<line-9></line-9>
<line-10>opt = 99999</line-10>
<line-11>for i in ONE:</line-11>
<line-12> if i in TWO:</line-12>
<line-13> opt = min(opt, i)</line-13>
<line-14>if opt == 99999:</line-14>
<line-15> print(-1)</line-15>
<line-17> print(opt)</line-17>
|
{"code": "<line-2>c, d = map(int,input().split())</line-2>\n<line-16>else:</line-16>", "lines": [2, 16]}
#### 0
|
<line-2>if n%3 == 0: print(1, 1, n-2)</line-2>
<line-3>elif n%3 == 1: print(1, 1, n-2)</line-3>
<line-4>else: print(1, 2, n-3)</line-4>
|
{"code": "<line-1>n = int(input())</line-1>", "lines": [1]}
#### 0
|
<line-1>n, a, b, c, d= [int(i) for i in input().split()]</line-1>
<line-3>for i in range(1, n+1):</line-3>
<line-4> if i+b-c>0 and i+b-c<=n:</line-4>
<line-5> if i+a-d>0 and i+a-d<=n:</line-5>
<line-6> if i+a+b-c-d>0 and i+a+b-c-d<=n:</line-6>
<line-8>print(o*n)</line-8>
|
{"code": "<line-2>o = 0</line-2>\n<line-7>\t\t\t\to+=1</line-7>", "lines": [2, 7]}
#### 0
|
<line-1>w, h = map(int, input().split())</line-1>
<line-3>u2, d2 = map(int, input().split())</line-3>
<line-4></line-4>
<line-5>for i in range(h, -1, -1):</line-5>
<line-6> w += i</line-6>
<line-7> if i == d1:</line-7>
<line-8> w = max(w - u1, 0)</line-8>
<line-9> elif i == d2:</line-9>
<line-11></line-11>
<line-12>print(w)</line-12>
|
{"code": "<line-2>u1, d1 = map(int, input().split())</line-2>\n<line-10> w = max(w - u2, 0)</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>m = int(input())</line-1>
<line-3>x, y = list(map(int,input().split()))</line-3>
<line-4></line-4>
<line-5>for i in range(m):</line-5>
<line-6> sb = sum(c[:-i-1])</line-6>
<line-7> si = sum(c[-i-1:])</line-7>
<line-8> if x <= sb <= y:</line-8>
<line-9> if x <= si <= y:</line-9>
<line-10> print(m-i)</line-10>
<line-11> break</line-11>
<line-13> print(0)</line-13>
|
{"code": "<line-2>c = list(map(int,input().split()))</line-2>\n<line-12>else:</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4> return int(input())</line-4>
<line-5></line-5>
<line-6>def read_ints():</line-6>
<line-7> return [int(x) for x in input().split()]</line-7>
<line-8></line-8>
<line-9>n = read_int()</line-9>
<line-10>k = read_int()</line-10>
<line-11>a = read_int()</line-11>
<line-12>b = read_int()</line-12>
<line-13></line-13>
<line-14>cost = 0</line-14>
<line-15></line-15>
<line-16>if k == 1:</line-16>
<line-17> cost = (n - 1) * a</line-17>
<line-18>else:</line-18>
<line-19> while n != 1:</line-19>
<line-20> if n % k == 0:</line-20>
<line-21> if b < (n - n // k) * a:</line-21>
<line-22> cost += b</line-22>
<line-23> else:</line-23>
<line-24> cost += (n - n // k) * a</line-24>
<line-25> n = n // k</line-25>
<line-26> else:</line-26>
<line-27> cost += (n % k) * a</line-27>
<line-28> n -= n % k</line-28>
<line-29> if n == 0:</line-29>
<line-30> n += 1</line-30>
<line-32></line-32>
<line-33>print(cost)</line-33>
|
{"code": "<line-3>def read_int():</line-3>\n<line-31> cost -= a</line-31>", "lines": [3, 31]}
#### 0
|
<line-1>def ii():</line-1>
<line-3>def mi():</line-3>
<line-4> return list(map(int, input().split()))</line-4>
<line-5>def li():</line-5>
<line-6> return list(mi())</line-6>
<line-7>MX = 10 ** 5</line-7>
<line-8></line-8>
<line-9>n = ii()</line-9>
<line-10>fac = 2</line-10>
<line-11>pr = []</line-11>
<line-12>while fac * fac <= n:</line-12>
<line-13> c = 0</line-13>
<line-14> while n % fac == 0:</line-14>
<line-15> c += 1</line-15>
<line-16> n //= fac</line-16>
<line-17> if c:</line-17>
<line-18> pr.append((fac, c))</line-18>
<line-19> fac += 1</line-19>
<line-20>if n > 1:</line-20>
<line-21> pr.append((n, 1))</line-21>
<line-22>if pr:</line-22>
<line-23> mx = max(e for p, e in pr)</line-23>
<line-24> mn = min(e for p, e in pr)</line-24>
<line-25> mx2 = 1</line-25>
<line-26> cnt = 0</line-26>
<line-27> while mx2 < mx:</line-27>
<line-28> mx2 *= 2</line-28>
<line-29> cnt += 1</line-29>
<line-30> ans = cnt + int(mn != mx2)</line-30>
<line-31> pdt = 1</line-31>
<line-32> for p, e in pr:</line-32>
<line-33> pdt *= p</line-33>
<line-34>else:</line-34>
<line-36>print(pdt, ans)</line-36>
|
{"code": "<line-2> return int(input())</line-2>\n<line-35> pdt, ans = 1, 0</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>###Prediction and Restriction</line-1>
<line-3>r,s,p=list(map(int,input().split()))</line-3>
<line-4>t=input()</line-4>
<line-5>win=[False]*n</line-5>
<line-6>def janken(char):</line-6>
<line-7> if char=='r':</line-7>
<line-8> return p</line-8>
<line-9> elif char=='s':</line-9>
<line-10> return r</line-10>
<line-11> else:</line-11>
<line-12> return s</line-12>
<line-13>cnt=0</line-13>
<line-14>for i in range(n):</line-14>
<line-15> if i-k<0:</line-15>
<line-16> point=janken(t[i])</line-16>
<line-17> cnt+=point</line-17>
<line-18> win[i]=True</line-18>
<line-19> else:</line-19>
<line-20> if t[i]!=t[i-k]:</line-20>
<line-21> point=janken(t[i])</line-21>
<line-22> cnt+=point</line-22>
<line-23> win[i]=True</line-23>
<line-24> else:</line-24>
<line-25> if not win[i-k]:</line-25>
<line-26> point=janken(t[i])</line-26>
<line-27> cnt+=point</line-27>
<line-29></line-29>
<line-30>print(cnt)</line-30>
|
{"code": "<line-2>n,k=list(map(int,input().split()))</line-2>\n<line-28> win[i]=True</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>a, b, c = list(map(int, input().split()))</line-1>
<line-3>if a != b:</line-3>
<line-5>print(x)</line-5>
|
{"code": "<line-2>x = 2 * (c + min(a, b))</line-2>\n<line-4> x += 1</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>def read_data():</line-1>
<line-3> As = list(map(int, input().split()))</line-3>
<line-4> return n, k, p, x, y, As</line-4>
<line-5></line-5>
<line-6>def solve(n, k, p, x, y, As):</line-6>
<line-7> '''median (As + Bs) >= y</line-7>
<line-8> sum(As + Bs) <= x</line-8>
<line-9> 1 <= Bi <= p</line-9>
<line-10> '''</line-10>
<line-11> middle = n // 2</line-11>
<line-12> As.sort(reverse=True)</line-12>
<line-13> sumA = sum(As)</line-13>
<line-14> minSum = sumA + 1 * (n - k)</line-14>
<line-15> if minSum > x:</line-15>
<line-16> return ['-1']</line-16>
<line-17> num_a_over_y = len([1 for a in As if a >= y])</line-17>
<line-18> if num_a_over_y > middle:</line-18>
<line-19> return ['1'] * (n - k)</line-19>
<line-20> min_num_y = middle + 1 - num_a_over_y</line-20>
<line-21> if min_num_y > n - k:</line-21>
<line-22> return ['-1']</line-22>
<line-23> minSum2 = sumA + min_num_y * y + (n - k - min_num_y) * 1</line-23>
<line-24> if minSum2 > x:</line-24>
<line-25> return ['-1']</line-25>
<line-26> return [str(y)] * min_num_y + ['1'] * (n - k - min_num_y)</line-26>
<line-27></line-27>
<line-28>def __starting_point():</line-28>
<line-29> n, k, p, x, y, As = read_data()</line-29>
<line-30> seq = solve(n, k, p, x, y, As)</line-30>
<line-32>__starting_point()</line-32>
|
{"code": "<line-2> n, k, p, x, y = map(int, input().split())</line-2>\n<line-31> print(' '.join(seq))</line-31>", "lines": [2, 31]}
#### 0
|
<line-1>s = input()</line-1>
<line-3>n = len(s)</line-3>
<line-4></line-4>
<line-5>def is_vowel(c):</line-5>
<line-6> return c in "aouie"</line-6>
<line-7></line-7>
<line-8>for i, x in enumerate(s):</line-8>
<line-9> if not is_vowel(x) and x != 'n':</line-9>
<line-11></line-11>
<line-12>print("YES" if ok else "NO")</line-12>
|
{"code": "<line-2>ok = 1</line-2>\n<line-10>\t\tok &= ((i + 1 < n) and is_vowel(s[i + 1]))</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>n, m = map(int, input().split())</line-1>
<line-2></line-2>
<line-4>g = [[] for i in range(7)]</line-4>
<line-5></line-5>
<line-6>for i in range(m):</line-6>
<line-7> x, y = map(int, input().split())</line-7>
<line-8> x -= 1</line-8>
<line-9> y -= 1</line-9>
<line-10> d[x] += 1</line-10>
<line-11> d[y] += 1</line-11>
<line-12> </line-12>
<line-13> g[x].append(y)</line-13>
<line-14> g[y].append(x)</line-14>
<line-15> </line-15>
<line-16>mn = min(d)</line-16>
<line-17>for i in range(7):</line-17>
<line-18> for j in range(i):</line-18>
<line-19> cnt = 0</line-19>
<line-20> for k in range(7):</line-20>
<line-21> if((k in g[i]) and (k in g[j])):</line-21>
<line-22> cnt += 1</line-22>
<line-23> mn = min(mn, cnt)</line-23>
<line-25>print(m) </line-25>
|
{"code": "<line-3>d = [0 for i in range(7)]</line-3>\n<line-24>m -= mn</line-24>", "lines": [3, 24]}
#### 0
|
<line-1>n, m = list(map(int, input().split()))</line-1>
<line-3>auci = list(map(int, input().split()))</line-3>
<line-4></line-4>
<line-5>scores = 0</line-5>
<line-6></line-6>
<line-7># m auc</line-7>
<line-8># n - m default</line-8>
<line-9></line-9>
<line-10>for i in range(len(prices)):</line-10>
<line-11> if (i+1) not in auci:</line-11>
<line-12> scores += prices[i]</line-12>
<line-13> prices[i] = 0</line-13>
<line-14></line-14>
<line-15>ra = []</line-15>
<line-16>for i in prices:</line-16>
<line-17> if i != 0:</line-17>
<line-18> ra.append(i)</line-18>
<line-19>ra.sort()</line-19>
<line-20>ra = ra[::-1]</line-20>
<line-21></line-21>
<line-22>for i in ra:</line-22>
<line-23> if i > scores:</line-23>
<line-24> scores += i</line-24>
<line-25> else:</line-25>
<line-26> scores *= 2</line-26>
<line-27></line-27>
<line-29>#print(ra)</line-29>
|
{"code": "<line-2>prices = list(map(int, input().split()))</line-2>\n<line-28>print(scores)</line-28>", "lines": [2, 28]}
#### 0
|
<line-1>m = list(map(int, input().split()))</line-1>
<line-3>a = [500, 1000, 1500, 2000, 2500]</line-3>
<line-4>v = list(map(int, input().split()))</line-4>
<line-5>ans = 0</line-5>
<line-6>for i in range(len(m)):</line-6>
<line-7> ans += max(0.3 * a[i], (1 - m[i] / 250) * a[i] - 50 * w[i])</line-7>
<line-8>ans += v[0] * 100</line-8>
<line-10>print(int(ans))</line-10>
|
{"code": "<line-2>w = list(map(int, input().split()))</line-2>\n<line-9>ans -= v[1] * 50</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>n,m,L,R = list(map(int,input().split()))</line-1>
<line-3>pp = p//2</line-3>
<line-4>#liczba pokryc n x m ze jest parzyscie wiele zer albo parzyscie wiele jedynek</line-4>
<line-5>def pow(a,w):</line-5>
<line-6> wyn = 1</line-6>
<line-7> mn = a</line-7>
<line-8> while w > 0:</line-8>
<line-9> if w%2 == 1:</line-9>
<line-10> wyn = (wyn * mn)%p</line-10>
<line-11> mn = (mn*mn)%p</line-11>
<line-12> w //= 2</line-12>
<line-13> return wyn</line-13>
<line-14>dupsko = pow((R-L+1), m*n)</line-14>
<line-15>if L == R:</line-15>
<line-16> print(1) </line-16>
<line-17>else:</line-17>
<line-18> if (m*n)%2 == 1:</line-18>
<line-19> print(dupsko%pp)</line-19>
<line-21> print((dupsko - dupsko//2)%pp)</line-21>
|
{"code": "<line-2>p = 998244353*2</line-2>\n<line-20>\telse:</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>def main():</line-1>
<line-3></line-3>
<line-4> def read():</line-4>
<line-5> return stdin.readline().rstrip('\n')</line-5>
<line-6></line-6>
<line-7> def read_array(sep=None, maxsplit=-1):</line-7>
<line-8> return read().split(sep, maxsplit)</line-8>
<line-9></line-9>
<line-10> def read_int():</line-10>
<line-11> return int(read())</line-11>
<line-12></line-12>
<line-13> def read_int_array(sep=None, maxsplit=-1):</line-13>
<line-14> return [int(a) for a in read_array(sep, maxsplit)]</line-14>
<line-15></line-15>
<line-16> def write(*args, **kwargs):</line-16>
<line-17> sep = kwargs.get('sep', ' ')</line-17>
<line-18> end = kwargs.get('end', '\n')</line-18>
<line-19> stdout.write(sep.join(str(a) for a in args) + end)</line-19>
<line-20></line-20>
<line-21> def write_array(array, **kwargs):</line-21>
<line-22> sep = kwargs.get('sep', ' ')</line-22>
<line-23> end = kwargs.get('end', '\n')</line-23>
<line-24> stdout.write(sep.join(str(a) for a in array) + end)</line-24>
<line-25></line-25>
<line-26> n, m = read_int_array()</line-26>
<line-27> minm, maxm = [], []</line-27>
<line-28> for _ in range(n):</line-28>
<line-29> minm.append(read_int_array())</line-29>
<line-30> for _ in range(n):</line-30>
<line-31> maxm.append(read_int_array())</line-31>
<line-32></line-32>
<line-33> for r in range(n):</line-33>
<line-34> for c in range(m):</line-34>
<line-35> minx = min(minm[r][c], maxm[r][c])</line-35>
<line-36> maxx = max(minm[r][c], maxm[r][c])</line-36>
<line-37> if r:</line-37>
<line-38> if minx <= minm[r-1][c] or maxx <= maxm[r-1][c]:</line-38>
<line-39> write("Impossible")</line-39>
<line-40> return</line-40>
<line-41> if c:</line-41>
<line-42> if minx <= minm[r][c-1] or maxx <= maxm[r][c-1]:</line-42>
<line-43> write("Impossible")</line-43>
<line-44> return</line-44>
<line-45> minm[r][c] = minx</line-45>
<line-46> maxm[r][c] = maxx</line-46>
<line-48></line-48>
<line-49>main()</line-49>
|
{"code": "<line-2> from sys import stdin, stdout</line-2>\n<line-47> write(\"Possible\")</line-47>", "lines": [2, 47]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>arr.sort()</line-3>
<line-4>arr = arr[::-1]</line-4>
<line-5>ans = [arr[0]]</line-5>
<line-6>for i in range(1, n):</line-6>
<line-7> if(arr[i] < ans[-1]):</line-7>
<line-8> ans.append(arr[i])</line-8>
<line-9> else:</line-9>
<line-11>print(sum(ans))</line-11>
|
{"code": "<line-2>arr = list(map(int, input().split()))</line-2>\n<line-10>\t\tans.append(max(0, ans[-1] - 1))</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>R=lambda:list(map(int,input().split()))</line-1>
<line-3>a=sorted(R())</line-3>
<line-4>b=0</line-4>
<line-5>for i in a:</line-5>
<line-6> while i>k+k:</line-6>
<line-7> k+=k</line-7>
<line-8> b+=1</line-8>
<line-10>print(b)</line-10>
|
{"code": "<line-2>n,k=R()</line-2>\n<line-9> k=max(k,i)</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>n = int(input())</line-1>
<line-3>min2, max2 = map(int, input().split())</line-3>
<line-4>min3, max3 = map(int, input().split())</line-4>
<line-5></line-5>
<line-6>d1 = min(n - min2 - min3, max1)</line-6>
<line-7>d2 = min(n - d1 - min3, max2)</line-7>
<line-9></line-9>
<line-10>print(d1,d2,d3)</line-10>
|
{"code": "<line-2>min1, max1 = map(int, input().split())</line-2>\n<line-8>d3 = n - d1 - d2</line-8>", "lines": [2, 8]}
#### 0
|
<line-1># You lost the game.</line-1>
<line-2></line-2>
<line-4>L = list(map(int, input().split()))</line-4>
<line-5></line-5>
<line-6>if n == 1:</line-6>
<line-7> if L[0] == 0:</line-7>
<line-8> print("UP")</line-8>
<line-9> elif L[0] == 15:</line-9>
<line-10> print("DOWN")</line-10>
<line-11> else:</line-11>
<line-12> print("-1")</line-12>
<line-13>else:</line-13>
<line-14> d = L[n-2] - L[n-1]</line-14>
<line-15> if d < 0:</line-15>
<line-16> if L[n-1] == 15:</line-16>
<line-17> print("DOWN")</line-17>
<line-18> else:</line-18>
<line-19> print("UP")</line-19>
<line-20> else:</line-20>
<line-21> if L[n-1] == 0:</line-21>
<line-22> print("UP")</line-22>
<line-24> print("DOWN")</line-24>
|
{"code": "<line-3>n = int(input())</line-3>\n<line-23> else:</line-23>", "lines": [3, 23]}
#### 0
|
<line-1>v = list('aeiou')</line-1>
<line-3>t = [c in v for c in input()]</line-3>
<line-4>if s == t:</line-4>
<line-5> print('Yes')</line-5>
<line-7> print('No')</line-7>
|
{"code": "<line-2>s = [c in v for c in input()]</line-2>\n<line-6>else:</line-6>", "lines": [2, 6]}
#### 0
|
<line-1>grid = [list(input()) for i in range(8)]</line-1>
<line-3>w = 9</line-3>
<line-4>tblock = False</line-4>
<line-5>bblock = False</line-5>
<line-6>for r in range(8):</line-6>
<line-7> for c in range(8):</line-7>
<line-8> for ri in range(r):</line-8>
<line-9> if grid[ri][c] == 'B':</line-9>
<line-10> tblock = True</line-10>
<line-11> for ri in range(r+1, 8):</line-11>
<line-12> if grid[ri][c] == 'W':</line-12>
<line-13> bblock = True</line-13>
<line-14> if grid[r][c] == 'B' and not bblock:</line-14>
<line-15> b = min([abs(7-r), b])</line-15>
<line-16> elif grid[r][c] == 'W' and not tblock:</line-16>
<line-17> w = min([w, r])</line-17>
<line-18> tblock = False</line-18>
<line-19> bblock = False</line-19>
<line-20>if b < w:</line-20>
<line-21> print('B')</line-21>
<line-23> print('A')</line-23>
<line-24> </line-24>
|
{"code": "<line-2>b = 9</line-2>\n<line-22>else:</line-22>", "lines": [2, 22]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.