question
stringlengths 0
30.2k
| answer
stringlengths 55
2.44k
|
|---|---|
<line-1># cook your dish here</line-1>
<line-3>from math import gcd</line-3>
<line-4>def fac50():</line-4>
<line-5> f = [0]*51</line-5>
<line-6> f[0] ,f[1] = 1,1</line-6>
<line-7> for i in range(1,51):f[i] = (f[i-1]*i)%mod</line-7>
<line-8> return f</line-8>
<line-9>def gcd110():</line-9>
<line-10> gc = [[0]*111 for i in range(111)]</line-10>
<line-11> for i in range(111):</line-11>
<line-12> for j in range(111):gc[i][j] = gcd(i,j)</line-12>
<line-13> return gc</line-13>
<line-14>factorials,gcds = fac50(),gcd110()</line-14>
<line-15>def rule_asc(n,l):</line-15>
<line-16> a,k = [0 for i in range(n + 1)],1</line-16>
<line-17> a[1] = n</line-17>
<line-18> while k != 0:</line-18>
<line-19> x,y = a[k - 1] + 1,a[k] - 1 </line-19>
<line-20> k -= 1</line-20>
<line-21> while x <= y and k < l - 1:</line-21>
<line-22> a[k],y = x,y-x</line-22>
<line-23> k += 1</line-23>
<line-24> a[k] = x + y</line-24>
<line-25> yield a[:k + 1]</line-25>
<line-26>def niceness(s):</line-26>
<line-27> t = 0</line-27>
<line-28> for i in range(len(s)):</line-28>
<line-29> for j in range(i+1,len(s)):t = (t + gcds[s[i]][s[j]])%mod</line-29>
<line-30> return t</line-30>
<line-31>def permcount(s,c):</line-31>
<line-32> f,p = [s.count(x) for x in set(s)],factorials[c] </line-32>
<line-33> for e in f:p = (p*pow(factorials[e],mod-2,mod))%mod</line-33>
<line-34> return p</line-34>
<line-35>def main():</line-35>
<line-36> for i in range(int(input())):</line-36>
<line-37> n,s = [int(item) for item in input().split()]</line-37>
<line-38> a = [int(item) for item in input().split()]</line-38>
<line-39> b = [i for i in a if i != -1]</line-39>
<line-40> s , ones = s - sum(b),a.count(-1) </line-40>
<line-41> if s < 0:print(0)</line-41>
<line-42> elif (s == 0 and ones == 0):print(niceness(a)%mod)</line-42>
<line-43> elif (s > 0 and ones == 0):print(0)</line-43>
<line-44> else:</line-44>
<line-45> t = 0</line-45>
<line-46> for seq in rule_asc(s,ones):</line-46>
<line-47> if len(seq) == ones: t = (t + (((permcount(seq,ones))%mod)*(niceness(b+seq)%mod))%mod)%mod</line-47>
<line-48> print(t) </line-48>
<line-50>__starting_point()</line-50>
|
{"code": "<line-2>mod = 10**9 + 7</line-2>\n<line-49>def __starting_point():main()</line-49>", "lines": [2, 49]}
#### 0
|
<line-1>#!/usr/bin/env python</line-1>
<line-2></line-2>
<line-4> EXPLORED_NODES.add(v)</line-4>
<line-5> r = False</line-5>
<line-6> for e in [x for x in E if v in x]:</line-6>
<line-7> if e in EXPLORED_EDGES: continue</line-7>
<line-8> if e[0] == v: w = e[1]</line-8>
<line-9> else: w = e[0]</line-9>
<line-10> if w in EXPLORED_NODES:</line-10>
<line-11> return True</line-11>
<line-12> else:</line-12>
<line-13> EXPLORED_EDGES.add(e)</line-13>
<line-14> r = r or iscycle(E, w, EXPLORED_NODES, EXPLORED_EDGES)</line-14>
<line-15> if r: break</line-15>
<line-16> return r</line-16>
<line-17></line-17>
<line-18>def process(E):</line-18>
<line-19> return iscycle(E, 1, set(), set()) and 'NO' or 'YES'</line-19>
<line-20></line-20>
<line-21>def main():</line-21>
<line-22> N, M = list(map(int, input().split()))</line-22>
<line-23> E = []</line-23>
<line-24> for m in range(M):</line-24>
<line-25> U, V = list(map(int, input().split()))</line-25>
<line-26> if U > V: U, V = V, U</line-26>
<line-27> E.append((U, V))</line-27>
<line-29></line-29>
<line-30>main()</line-30>
<line-31></line-31>
|
{"code": "<line-3>def iscycle(E, v, EXPLORED_NODES, EXPLORED_EDGES):</line-3>\n<line-28> print(process(E))</line-28>", "lines": [3, 28]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> s=input().split()</line-3>
<line-4> m=int(s[0])</line-4>
<line-5> p=float(s[1])</line-5>
<line-6> if(m%2==0):</line-6>
<line-7> r=(1-p**m)/(p+1)</line-7>
<line-8> else:</line-8>
<line-9> r=(1+p**m)/(p+1)</line-9>
<line-11> t-=1</line-11>
|
{"code": "<line-2>while(t):</line-2>\n<line-10> print(1000000000*r,1000000000*(1-r))</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>def dfs(node):</line-1>
<line-3> val=0</line-3>
<line-4> flag=0</line-4>
<line-5> for i in adj[node]:</line-5>
<line-6> x= dfs(i)</line-6>
<line-7> val+=x</line-7>
<line-8> if x==0:</line-8>
<line-9> flag=1</line-9>
<line-10> leaf+=val-val%3</line-10>
<line-11> if val%3==0 and flag==0:</line-11>
<line-12> return 1</line-12>
<line-13> else:</line-13>
<line-14> return 0</line-14>
<line-15>for _ in range(int(input())):</line-15>
<line-16> n=int(input())</line-16>
<line-17> adj=[[] for i in range(n+2)]</line-17>
<line-18> arr=[int(i) for i in input().split()]</line-18>
<line-19> leaf=0</line-19>
<line-20> #print(adj)</line-20>
<line-21> for i in range(2,n+1):</line-21>
<line-22> #print(i,arr[i-2])</line-22>
<line-23> adj[arr[i-2]].append(i)</line-23>
<line-24> </line-24>
<line-26> print(n-leaf)</line-26>
|
{"code": "<line-2> nonlocal adj,leaf</line-2>\n<line-25> dfs(1)</line-25>", "lines": [2, 25]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>def shortestSubarray(A, K):</line-5>
<line-6> </line-6>
<line-7> </line-7>
<line-8> N = len(A)</line-8>
<line-9> P = [0]</line-9>
<line-10></line-10>
<line-11> for x in A:</line-11>
<line-12> P.append(P[-1] + x)</line-12>
<line-13></line-13>
<line-14> #Want smallest y-x with Py - Px >= K</line-14>
<line-15> ans = N+1 # N+1 is impossible</line-15>
<line-16> monoq = collections.deque() #opt(y) candidates, represented as indices of P</line-16>
<line-17> for y, Py in enumerate(P):</line-17>
<line-18> #Want opt(y) = largest x with Px <= Py - K</line-18>
<line-19> if not monoq: </line-19>
<line-20> if Py>=K: return 1</line-20>
<line-21> while monoq and Py <= P[monoq[-1]]:</line-21>
<line-22> monoq.pop()</line-22>
<line-23></line-23>
<line-24> while monoq and Py - P[monoq[0]] >= K:</line-24>
<line-25> ans = min(ans, y - monoq.popleft())</line-25>
<line-26></line-26>
<line-27> monoq.append(y)</line-27>
<line-28></line-28>
<line-29> return ans if ans < N+1 else -1</line-29>
<line-30> </line-30>
<line-31> </line-31>
<line-32>for t in range(int(input())):</line-32>
<line-33> N, D = [int(x) for x in input().split()]</line-33>
<line-34> </line-34>
<line-36> </line-36>
<line-37> print(shortestSubarray(A, D))</line-37>
<line-38> </line-38>
|
{"code": "<line-3>import collections</line-3>\n<line-35> A = [int(x) for x in input().split()] </line-35>", "lines": [3, 35]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>def isPos(num):</line-3>
<line-4> if num%2==0:</line-4>
<line-5> for i in range(num,2*num,1):</line-5>
<line-6> if ((num**2)-((i/2)**2))**(1/2)==int(((num**2)-((i/2)**2))**(1/2)):</line-6>
<line-7> return 'YES'</line-7>
<line-8> return 'NO'</line-8>
<line-9> else:</line-9>
<line-10> for i in range(num+1,2*num,1):</line-10>
<line-11> if ((num**2)-((i/2)**2))**(1/2)==int(((num**2)-((i/2)**2))**(1/2)):</line-11>
<line-12> return 'YES'</line-12>
<line-13> return 'NO'</line-13>
<line-14></line-14>
<line-15>test = int(input())</line-15>
<line-16>for __ in range(test):</line-16>
<line-18> print(isPos(num))</line-18>
|
{"code": "<line-2>import math</line-2>\n<line-17> num=int(input())</line-17>", "lines": [2, 17]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(t):</line-3>
<line-4> (n,k,e,m)=tuple(map(int,input().split()))</line-4>
<line-5> scores=[]</line-5>
<line-6> for j in range(n-1):</line-6>
<line-7> scores.append(sum(list(map(int,input().split()))))</line-7>
<line-8> scores.sort(reverse=True);</line-8>
<line-9> bsc=scores[k-1];</line-9>
<line-10> msc=sum(list(map(int,input().split())))</line-10>
<line-11> mini=bsc-msc+1</line-11>
<line-12> if(mini<0):</line-12>
<line-13> print(0)</line-13>
<line-14> elif(mini>m):</line-14>
<line-15> print("Impossible")</line-15>
<line-17> print(mini)</line-17>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-16> else:</line-16>", "lines": [2, 16]}
#### 0
|
<line-1># # # # n = int(input())</line-1>
<line-3># # # # for _ in range(int(input())):</line-3>
<line-4># # # # l,r,mod = map(int , input().split())</line-4>
<line-5># # # # pro = 1</line-5>
<line-6># # # # for i in range(l - 1,r):</line-6>
<line-7># # # # pro *= arr[i]</line-7>
<line-8># # # # print(pro % mod) #sample testcases passed #TLE</line-8>
<line-9># # # import numpy #or use math</line-9>
<line-10># # # n = int(input())</line-10>
<line-11># # # arr = list(map(int , input().split()))</line-11>
<line-12># # # for _ in range(int(input())):</line-12>
<line-13># # # l,r,mod = map(int , input().split())</line-13>
<line-14># # # print(numpy.prod(arr[l - 1:r]) % mod) #sample cases passed, WA</line-14>
<line-15># # import math</line-15>
<line-16># # primes,dic,t = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97],{},0</line-16>
<line-17># # for i in primes:</line-17>
<line-18># # dic[i] = t</line-18>
<line-19># # t += 1</line-19>
<line-20># # def primeFactors(n,arr): </line-20>
<line-21># # for i in range(2,int(math.sqrt(n)) + 1,2): </line-21>
<line-22># # while(n % i == 0): </line-22>
<line-23># # arr[dic[i]] += 1 </line-23>
<line-24># # n /= i</line-24>
<line-25># # if(n > 2):</line-25>
<line-26># # arr[dic[n]] += 1</line-26>
<line-27># # return arr</line-27>
<line-28># # n = int(input())</line-28>
<line-29># # A = list(map(int , input().split()))</line-29>
<line-30># # dp = [0]*len(primes)</line-30>
<line-31># # for i in range(1,n + 1):</line-31>
<line-32># # r = [dp[i - 1]].copy()</line-32>
<line-33># # dp.append(primeFactors(A[i - 1],r))</line-33>
<line-34># # for _ in range(int(input())):</line-34>
<line-35># # li,ri,m=list(map(int,input().split()))</line-35>
<line-36># # ans = 1</line-36>
<line-37># # for i in range(len(primes)):</line-37>
<line-38># # ans *= (pow(primes[i],dp[ri][i] - dp[li - 1][i],m)) % m</line-38>
<line-39># # print(ans % m) #NZEC</line-39>
<line-40># import math</line-40>
<line-41># primes=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]</line-41>
<line-42># dic={}</line-42>
<line-43># t=0</line-43>
<line-44># for i in primes:</line-44>
<line-45># dic[i]=t</line-45>
<line-46># t+=1</line-46>
<line-47># def primeFactors(n,arr): </line-47>
<line-48># while(n % 2 == 0):</line-48>
<line-49># arr[dic[2]] += 1 </line-49>
<line-50># n /= 2</line-50>
<line-51># for i in range(3,int(math.sqrt(n))+1,2): </line-51>
<line-52># while(n % i == 0): </line-52>
<line-53># arr[dic[i]] += 1 </line-53>
<line-54># n /= i</line-54>
<line-55># if(n > 2): </line-55>
<line-56># arr[dic[n]] += 1</line-56>
<line-57># return arr</line-57>
<line-58># N = int(input())</line-58>
<line-59># A = list(map(int , input().split()))</line-59>
<line-60># dp = [[0]*len(primes)]</line-60>
<line-61># for i in range(1,N + 1):</line-61>
<line-62># r = dp[i - 1].copy()</line-62>
<line-63># dp.append(primeFactors(A[i - 1],r))</line-63>
<line-64># for _ in range(int(input())):</line-64>
<line-65># l,r,m = list(map(int , input().split()))</line-65>
<line-66># ans = 1</line-66>
<line-67># for i in range(len(primes)):</line-67>
<line-68># ans *= (pow(primes[i],dp[r][i] - dp[l - 1][i],m)) % m</line-68>
<line-69># print(ans % m)</line-69>
<line-70>import sys </line-70>
<line-71>import math</line-71>
<line-72>input = sys.stdin.readline</line-72>
<line-73>primes=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]</line-73>
<line-74>dic={}</line-74>
<line-75>t=0</line-75>
<line-76>for i in primes:</line-76>
<line-77> dic[i]=t</line-77>
<line-78> t+=1</line-78>
<line-79>def primeFactors(n,arr): </line-79>
<line-80> while n % 2 == 0: </line-80>
<line-81> arr[dic[2]]+=1 </line-81>
<line-82> n = n / 2</line-82>
<line-83></line-83>
<line-84> for i in range(3,int(math.sqrt(n))+1,2): </line-84>
<line-85> while n % i== 0: </line-85>
<line-86> arr[dic[i]]+=1 </line-86>
<line-87> n = n / i </line-87>
<line-88></line-88>
<line-89> if n > 2: </line-89>
<line-90> arr[dic[n]]+=1</line-90>
<line-91> return arr</line-91>
<line-92>def main():</line-92>
<line-93> N=int(input())</line-93>
<line-94> A=list(map(int,input().split()))</line-94>
<line-95> tp=[0]*len(primes)</line-95>
<line-96> dp=[]</line-96>
<line-97> dp.append(tp)</line-97>
<line-98> for i in range(1,N+1):</line-98>
<line-99> # print(i)</line-99>
<line-100> r=dp[i-1].copy()</line-100>
<line-101> t=primeFactors(A[i-1],r)</line-101>
<line-102> dp.append(t)</line-102>
<line-103> t=int(input())</line-103>
<line-104> for _ in range(t):</line-104>
<line-105> l,r,m=list(map(int,input().split()))</line-105>
<line-106> if(m==1):</line-106>
<line-107> print(0)</line-107>
<line-108> else:</line-108>
<line-109> ans=1</line-109>
<line-110> for i in range(len(primes)):</line-110>
<line-111> ans=ans*(pow(primes[i],dp[r][i]-dp[l-1][i],m))%m</line-111>
<line-112> print(ans%m)</line-112>
<line-113> </line-113>
<line-114>def __starting_point():</line-114>
<line-116>__starting_point()</line-116>
|
{"code": "<line-2># # # # arr = list(map(int , input().split()))</line-2>\n<line-115> main()</line-115>", "lines": [2, 115]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> n = int(input())</line-3>
<line-4> suffixes = {}</line-4>
<line-5> xx = input().split()</line-5>
<line-6> for x in range(n):</line-6>
<line-7> try:</line-7>
<line-8> a = suffixes[xx[x][-3:]]</line-8>
<line-9> except Exception as e:</line-9>
<line-10> a = []</line-10>
<line-11> a.append(xx[x])</line-11>
<line-12></line-12>
<line-13> suffixes.update({xx[x][-3:]: a})</line-13>
<line-14></line-14>
<line-15> print("Case : %d" % (i + 1))</line-15>
<line-17> print("".join(b + " " for b in sorted(suffixes[a])).strip())</line-17>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-16> for a in sorted(suffixes):</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>n=int(input())</line-1>
<line-3>l=[1]*n</line-3>
<line-4>if sorted(arr)==arr:</line-4>
<line-5> print('0')</line-5>
<line-6>else:</line-6>
<line-7> for i in range(0,len(arr)):</line-7>
<line-8> for j in range(i):</line-8>
<line-9> if arr[i]>=arr[j] and l[i]<l[j]+1:</line-9>
<line-11> print(n-max(l))</line-11>
|
{"code": "<line-2>arr=[int(x) for x in input().split()]</line-2>\n<line-10> l[i]=l[j]+1</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>import sys</line-1>
<line-3>n = int(n)</line-3>
<line-4>x = int(x)</line-4>
<line-5>y = int(y)</line-5>
<line-6>contests = {}</line-6>
<line-7></line-7>
<line-8>for i in range(n):</line-8>
<line-9> s, e = input().split(' ')</line-9>
<line-10> s = int(s)</line-10>
<line-11> e = int(e)</line-11>
<line-12> contests[(s, e)] = abs(s-e)</line-12>
<line-13></line-13>
<line-14>v_time = input().split(' ')</line-14>
<line-15>w_time = input().split(' ')</line-15>
<line-16></line-16>
<line-17>v_time, w_time = list(map(int, v_time)), list(map(int, w_time))</line-17>
<line-18>v_time.sort()</line-18>
<line-19>w_time.sort()</line-19>
<line-20></line-20>
<line-21></line-21>
<line-22>score = sys.maxsize</line-22>
<line-23></line-23>
<line-24>contests = dict(sorted(contests.items(), key=lambda item: item[1]))</line-24>
<line-25>for k, v in contests.items():</line-25>
<line-26> start=-1</line-26>
<line-27> end = sys.maxsize</line-27>
<line-28> for i in range(x):</line-28>
<line-29> if v_time[i] > k[0]:</line-29>
<line-30> break</line-30>
<line-31> start = v_time[i]</line-31>
<line-32> for j in range(y):</line-32>
<line-33> if w_time[j] >= k[1]:</line-33>
<line-34> end = w_time[j]</line-34>
<line-35> break</line-35>
<line-36> if start == -1:</line-36>
<line-37> continue</line-37>
<line-38> score = min(score, (end-start+1))</line-38>
<line-39> if score-1 <= v:</line-39>
<line-41></line-41>
<line-42>print(score)</line-42>
|
{"code": "<line-2>n, x, y = input().split(' ')</line-2>\n<line-40> break</line-40>", "lines": [2, 40]}
#### 0
|
<line-1>testcases=int(input())</line-1>
<line-3>for i in range(0,testcases):</line-3>
<line-4> friends=int(input())</line-4>
<line-5> l,b=list(map(int,input().split()))</line-5>
<line-6> over=False</line-6>
<line-7> if b>l:</line-7>
<line-8> temp=b</line-8>
<line-9> b=l</line-9>
<line-10> l=temp</line-10>
<line-11> for counter in range(0,friends):</line-11>
<line-12> if l==b:</line-12>
<line-13> over=True</line-13>
<line-14> break</line-14>
<line-15> elif l>b:</line-15>
<line-16> l=l-b</line-16>
<line-17> if b>l:</line-17>
<line-18> temp=b</line-18>
<line-19> b=l</line-19>
<line-20> l=temp</line-20>
<line-21> </line-21>
<line-22> if over:</line-22>
<line-23> results.append("No")</line-23>
<line-24> else:</line-24>
<line-25> results.append("Yes "+str(l*b))</line-25>
<line-26></line-26>
<line-28> print(results[i])</line-28>
|
{"code": "<line-2>results=[]</line-2>\n<line-27>for i in range(0,testcases):</line-27>", "lines": [2, 27]}
#### 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> s = 0</line-5>
<line-6> l.sort(reverse = True)</line-6>
<line-7> for i in range(0,n,2):</line-7>
<line-9> print(s)</line-9>
|
{"code": "<line-2>for i in range(int(input())):</line-2>\n<line-8> s = s+l[i]</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4> votes = {}</line-4>
<line-5> for x in range(p):</line-5>
<line-6> str = sys.stdin.readline()</line-6>
<line-7> t = str.split()</line-7>
<line-8> votes[t[0]] = t[1]</line-8>
<line-9></line-9>
<line-10> ans = 0</line-10>
<line-11> for per in votes:</line-11>
<line-12> if votes[per] == "+":</line-12>
<line-13> ans= ans+1</line-13>
<line-14> else:</line-14>
<line-15> ans = ans-1</line-15>
<line-16></line-16>
<line-17> return ans</line-17>
<line-18></line-18>
<line-19>x = sys.stdin.readline()</line-19>
<line-20>for t in range(int(x)):</line-20>
<line-22> print(f(int(p)))</line-22>
|
{"code": "<line-3>def f(p):</line-3>\n<line-21> p = sys.stdin.readline()</line-21>", "lines": [3, 21]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>Input:</line-3>
<line-4>The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.</line-4>
<line-5>The first line of each test case contains three space-separated integers p, q and r.</line-5>
<line-6>The second line contains three space-separated integers a, b and c.</line-6>
<line-7>Output:</line-7>
<line-8>For each test case, print a single line containing one integer ― the maximum required number of operations(if the conversion is possible), or else print "-1"</line-8>
<line-9>"""</line-9>
<line-10></line-10>
<line-11>T=int(input())</line-11>
<line-12>while T>0:</line-12>
<line-13> T-=1 </line-13>
<line-14> p,q,r=list(map(int,input().split()))</line-14>
<line-15> a,b,c=list(map(int,input().split()))</line-15>
<line-16> #ds=list()</line-16>
<line-17> s=0</line-17>
<line-18> d1=a-p</line-18>
<line-19> if d1>0:</line-19>
<line-20> #ds.append(d1)</line-20>
<line-21> s+=d1</line-21>
<line-22> d2=b-q</line-22>
<line-23> if d2>0:</line-23>
<line-24> #ds.append(d2)</line-24>
<line-25> s+=d2</line-25>
<line-26> d3=c-r</line-26>
<line-27> if d3>0:</line-27>
<line-28> #ds.append(d3)</line-28>
<line-29> s+=d3</line-29>
<line-30> </line-30>
<line-31> if(d1==0 and d2==0 and d3==0):</line-31>
<line-32> print(0)</line-32>
<line-33> elif(d1<0 or d2<0 or d3<0):</line-33>
<line-34> print(-1)</line-34>
<line-36> print(s)</line-36>
<line-37> </line-37>
<line-38> </line-38>
|
{"code": "<line-2>\"\"\"</line-2>\n<line-35> else:</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>from collections import Counter</line-1>
<line-3>def nc3(n):</line-3>
<line-4> a=factorial(n)</line-4>
<line-5> b=factorial(n-3)</line-5>
<line-6> return ((a)/(b*6))</line-6>
<line-7>def rem(s,k):</line-7>
<line-8> t=-1</line-8>
<line-9> x=-1</line-9>
<line-10> for i in range(len(s)):</line-10>
<line-11> if s[i][0]>2 and s[i][1]<=k:</line-11>
<line-12> if s[i][0]>3:</line-12>
<line-13> ch=(nc3(s[i][0])-nc3(s[i][0]-1))/s[i][1]</line-13>
<line-14> else:</line-14>
<line-15> ch=1/s[i][1]</line-15>
<line-16> if t<ch:</line-16>
<line-17> t=ch</line-17>
<line-18> x=i</line-18>
<line-19> return x</line-19>
<line-20>t=int(input())</line-20>
<line-21>for x in range(t):</line-21>
<line-22> n,c,k=map(int,input().split())</line-22>
<line-23> l={}</line-23>
<line-24> for i in range(n):</line-24>
<line-25> a,b,e=map(int,input().split())</line-25>
<line-26> if e in l:</line-26>
<line-27> l[e].append(a)</line-27>
<line-28> else:</line-28>
<line-29> l[e]=[]</line-29>
<line-30> l[e].append(a)</line-30>
<line-31> v=list(map(int,input().split()))</line-31>
<line-32> s=[]</line-32>
<line-33> for i in range(1,c+1):</line-33>
<line-34> if i in l:</line-34>
<line-35> s+=[[len(l[i]),v[i-1]]]</line-35>
<line-36> s.sort(key = lambda x: x[0],reverse=True)</line-36>
<line-37> while True:</line-37>
<line-38> ma=rem(s,k)</line-38>
<line-39> if ma<=-1:</line-39>
<line-40> break</line-40>
<line-41> else:</line-41>
<line-42> s[ma][0]-=1</line-42>
<line-43> k=k-s[ma][1]</line-43>
<line-44> re=0</line-44>
<line-45> for i in s:</line-45>
<line-46> if i[0]>2:</line-46>
<line-48> print(int(re))</line-48>
|
{"code": "<line-2>from math import factorial</line-2>\n<line-47> re=re+nc3(i[0])</line-47>", "lines": [2, 47]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> n1=0</line-3>
<line-4> ans=1</line-4>
<line-5> while(n>0):</line-5>
<line-6> d=int(n % 10)</line-6>
<line-7> if(d!=0):</line-7>
<line-8> if(d!=9 and d!=7 and d!=1):</line-8>
<line-9> n1=3</line-9>
<line-10> elif(d==1):</line-10>
<line-11> n1=1</line-11>
<line-12> else:</line-12>
<line-13> n1=4</line-13>
<line-14> ans=(int(ans)*int(n1))% (1000000007)</line-14>
<line-15> n/=10</line-15>
<line-16> else:</line-16>
<line-17> n/=10</line-17>
<line-18> if(ans==1):</line-18>
<line-19> print("0")</line-19>
<line-21> print(ans %(1000000007))</line-21>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-20> else:</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>import sys</line-1>
<line-3>r=int(input())</line-3>
<line-4>for v in range (0,r):</line-4>
<line-5> n = int(input())</line-5>
<line-6> x=1</line-6>
<line-7> arr=list(map(int,input().strip().split(" ")))</line-7>
<line-8> for i in range (0,n):</line-8>
<line-9> x=x*arr[i]</line-9>
<line-10> </line-10>
<line-11> for i in range (2,100000000):</line-11>
<line-12> if(x%(pow(i,2))==0):</line-12>
<line-13> ans1=i</line-13>
<line-15> </line-15>
<line-16> </line-16>
<line-17> print(ans1) </line-17>
|
{"code": "<line-2>import math</line-2>\n<line-14> break</line-14>", "lines": [2, 14]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>MOD=int(1e9+7)</line-3>
<line-4>for t in range(T):</line-4>
<line-5> N,K=[int(a) for a in input().split()]</line-5>
<line-6> M=K//2</line-6>
<line-7> # ans= ((K%2)?( (N+M)*(N+M) + M ):( (N+M)*(N+M) - M) )</line-7>
<line-8> ans=(N+M)*(N+M) -M</line-8>
<line-9> if(K%2):</line-9>
<line-10> ans+=2*M</line-10>
<line-11> if(N==0):</line-11>
<line-13> print(ans%MOD) </line-13>
|
{"code": "<line-2>T=int(input())</line-2>\n<line-12> ans=K*(K-1)</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> c=[int(z) for z in input().split()]</line-3>
<line-4> c.sort()</line-4>
<line-5> c.reverse()</line-5>
<line-6> b1,b2=0,0</line-6>
<line-7> for i in range(n):</line-7>
<line-8> if b1<b2:</line-8>
<line-9> b1+=c[i]</line-9>
<line-10> elif b2<b1:</line-10>
<line-11> b2+=c[i]</line-11>
<line-12> else:</line-12>
<line-14> print(max(b1,b2))</line-14>
<line-15> </line-15>
|
{"code": "<line-2> n=int(input())</line-2>\n<line-13> b1+=c[i]</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>'''Well I found the bug, but I don't understand why it was doing that. I mean, as</line-1>
<line-3>Note to self: deleting from (supposedly) local lists through recursion is dangerous!'''</line-3>
<line-4></line-4>
<line-5>class Group(object):</line-5>
<line-6> def __init__(self,size,start,end,value):</line-6>
<line-7> self.size = size</line-7>
<line-8> self.start = start</line-8>
<line-9> self.end = end</line-9>
<line-10> self.value = value</line-10>
<line-11> </line-11>
<line-12> def __lt__(self,other):</line-12>
<line-13> return self.start < other.start</line-13>
<line-14> </line-14>
<line-15> def __str__(self):</line-15>
<line-16> return "%i: %i->%i, $%i" %(self.size,self.start,self.end,self.value)</line-16>
<line-17> </line-17>
<line-18> </line-18>
<line-19>def hash(car,i):</line-19>
<line-20> people = []</line-20>
<line-21> for group in car:</line-21>
<line-22> people.extend([group.end]*group.size)</line-22>
<line-23> people.sort()</line-23>
<line-24> return tuple(people+[i])</line-24>
<line-25> </line-25>
<line-26> </line-26>
<line-27>def optimize(groups,car,capacity,i): </line-27>
<line-28> if i == len(groups):</line-28>
<line-29> return 0</line-29>
<line-30> </line-30>
<line-31> newcar = []</line-31>
<line-32> pos = groups[i].start</line-32>
<line-33> for group in car:</line-33>
<line-34> if group.end > pos:</line-34>
<line-35> newcar.append(group)</line-35>
<line-36> else:</line-36>
<line-37> capacity += group.size</line-37>
<line-38> </line-38>
<line-39> state = hash(newcar,i)</line-39>
<line-40> try:</line-40>
<line-41> return memo[state]</line-41>
<line-42> except:</line-42>
<line-43> v = optimize(groups,newcar,capacity,i+1) </line-43>
<line-44> if groups[i].size <= capacity:</line-44>
<line-45> w = optimize(groups,newcar+[groups[i]],capacity-groups[i].size,i+1) + groups[i].value</line-45>
<line-46> else:</line-46>
<line-47> w = 0</line-47>
<line-48> </line-48>
<line-49> if v > w:</line-49>
<line-50> ie[state] = -1</line-50>
<line-51> elif v < w:</line-51>
<line-52> ie[state] = 1</line-52>
<line-53> else:</line-53>
<line-54> ie[state] = 0</line-54>
<line-55> </line-55>
<line-56> ans = max(v,w)</line-56>
<line-57> memo[state] = ans</line-57>
<line-58> return ans</line-58>
<line-59> </line-59>
<line-60>cases = int(input())</line-60>
<line-61>for case in range(cases):</line-61>
<line-62> memo = {}</line-62>
<line-63> ie = {}</line-63>
<line-64> groups = []</line-64>
<line-65> n,_,capacity = list(map(int,input().split()))</line-65>
<line-66> </line-66>
<line-67> for g in range(n):</line-67>
<line-68> size,start,end,value = list(map(int,input().split()))</line-68>
<line-69> groups.append(Group(size,start,end,value))</line-69>
<line-71> print(optimize(groups,[],capacity,0))</line-71>
|
{"code": "<line-2>far as I can tell, it shouldn't be a bug!</line-2>\n<line-70> groups.sort()</line-70>", "lines": [2, 70]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>from math import sqrt,ceil,log10</line-3>
<line-4>def get_sum(a,b,digits):</line-4>
<line-5> sum=((b+a)*(b-a+1))//2</line-5>
<line-6> return sum*digits</line-6>
<line-7></line-7>
<line-8>def solve():</line-8>
<line-9> mod=10**9+7</line-9>
<line-10> thehighlimiter={i: 10 ** i - 1 for i in range(12)}</line-10>
<line-11> thelowlimiter={i: 10**i for i in range(12)}</line-11>
<line-12> for _ in range(int(input())):</line-12>
<line-13> l,r=map(int, stdin.readline().strip().split())</line-13>
<line-14> low=len(str(l))</line-14>
<line-15> high=len(str(r))</line-15>
<line-16> ans=0</line-16>
<line-17> if low==high:</line-17>
<line-18> ans=get_sum(l,r,low)</line-18>
<line-19> else:</line-19>
<line-20> ans+=get_sum(l,((10**low)-1),low)</line-20>
<line-21> ans+=get_sum((10**(high-1)),r,high)</line-21>
<line-22> for i in range(low+1,high):</line-22>
<line-23> ans+=get_sum(10**(i-1),(10**i)-1,i)</line-23>
<line-24> print(ans%mod)</line-24>
<line-25></line-25>
<line-26>def __starting_point():</line-26>
<line-28></line-28>
<line-29>__starting_point()</line-29>
|
{"code": "<line-2>from sys import stdin</line-2>\n<line-27> solve()</line-27>", "lines": [2, 27]}
#### 0
|
<line-1>N,M,K=map(int,input().split())</line-1>
<line-3>for i in range(N):</line-3>
<line-4> T=list(map(int,input().split()))</line-4>
<line-5> Q=T[-1]</line-5>
<line-6> T.pop(-1)</line-6>
<line-7> if Q<=10 and sum(T)>=M:</line-7>
<line-9>print(c)</line-9>
|
{"code": "<line-2>c=0</line-2>\n<line-8> c+=1</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>import math</line-1>
<line-3> n = int(input())</line-3>
<line-4> temp = math.sqrt(n)</line-4>
<line-5> if (temp == int(temp)):</line-5>
<line-6> print("YES")</line-6>
<line-8> print("NO")</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># cook your dish here</line-1>
<line-3> n=int(input());li=list(map(int,input().split()));dli=dict();modi=0</line-3>
<line-4> for i in li:</line-4>
<line-5> if i not in dli:dli[i]=1</line-5>
<line-6> else:dli[i]+=1</line-6>
<line-7> op=sorted(list(dli))</line-7>
<line-8> if(len(dli)!=0):</line-8>
<line-9> while 1:</line-9>
<line-10> tmp=[]</line-10>
<line-11> for i in op:</line-11>
<line-12> if dli[i]==0:continue</line-12>
<line-13> tmp.append(i);dli[i]-=1</line-13>
<line-14> l=len(tmp);mn=l</line-14>
<line-15> for i in range(l):mn=min(mn,tmp[i]-1-i+l-1-i)</line-15>
<line-16> modi+=mn</line-16>
<line-18> print(modi)</line-18>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-17> if(l==0):break</line-17>", "lines": [2, 17]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n=int(input())</line-3>
<line-4> a=list(map(int,input().split()))</line-4>
<line-5> even=[]</line-5>
<line-6> odd=[]</line-6>
<line-7> for i in a:</line-7>
<line-8> if(i & 1):</line-8>
<line-9> even.append(i)</line-9>
<line-10> else:</line-10>
<line-12> print(len(even)*len(odd))</line-12>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-11> odd.append(i)</line-11>", "lines": [2, 11]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> n = int(input())</line-3>
<line-4> m = n</line-4>
<line-5> x= 1</line-5>
<line-6> for i in range(n):</line-6>
<line-7> for j in range(m):</line-7>
<line-8> print(x, end = '')</line-8>
<line-9> x += 1</line-9>
<line-11> m -= 1</line-11>
|
{"code": "<line-2>for _ in range(int(input())):</line-2>\n<line-10> print()</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>t = input();</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>i = 0;</line-5>
<line-6></line-6>
<line-7>while i < int(t):</line-7>
<line-8></line-8>
<line-9> n = input();</line-9>
<line-10></line-10>
<line-11> k = input();</line-11>
<line-12></line-12>
<line-13> assert(len(k.split(' ')) == int(n));</line-13>
<line-14></line-14>
<line-15> for each in k.split(' '):</line-15>
<line-16></line-16>
<line-17> a[int(each)] += 1;</line-17>
<line-18></line-18>
<line-19></line-19>
<line-20> V = 0;</line-20>
<line-21></line-21>
<line-22> C = a[V];</line-22>
<line-23></line-23>
<line-24> for j in range(10001):</line-24>
<line-25></line-25>
<line-26> if C < a[j]:</line-26>
<line-27></line-27>
<line-28> V = j;</line-28>
<line-29></line-29>
<line-30> C = a[V];</line-30>
<line-31></line-31>
<line-32> a[j] = 0;</line-32>
<line-33></line-33>
<line-35></line-35>
<line-36> print(V, C);</line-36>
|
{"code": "<line-3>a = [0 for i in range(10001)]</line-3>\n<line-34>\ti += 1;</line-34>", "lines": [3, 34]}
#### 0
|
<line-1>T=int(input())</line-1>
<line-3> N=int(input())</line-3>
<line-4> A=list(map(int,input().split()))[:N]</line-4>
<line-5> l=[]</line-5>
<line-6> for j in range(len(A)):</line-6>
<line-7> for k in range(j+1,len(A)):</line-7>
<line-9> print(l.count(max(l))/((N*(N-1))/2))</line-9>
|
{"code": "<line-2>for i in range(T):</line-2>\n<line-8> l.append(A[j]+A[k])</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>T = int(input())</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5>for _ in range(T):</line-5>
<line-6> N = int(input())</line-6>
<line-7></line-7>
<line-8> A = list(map(int, input().split()))</line-8>
<line-9></line-9>
<line-10> if N == 1:</line-10>
<line-11> print(0)</line-11>
<line-12> continue</line-12>
<line-13></line-13>
<line-14> B = {}</line-14>
<line-15> C = {}</line-15>
<line-16></line-16>
<line-17> for i in range(N - 1):</line-17>
<line-18> u, v = input().split()</line-18>
<line-19> u = int(u) - 1</line-19>
<line-20> v = int(v) - 1</line-20>
<line-21></line-21>
<line-22> if u not in B:</line-22>
<line-23> B[u] = []</line-23>
<line-24></line-24>
<line-25> if v not in B:</line-25>
<line-26> B[v] = []</line-26>
<line-27></line-27>
<line-28> B[u].append(v)</line-28>
<line-29> B[v].append(u)</line-29>
<line-30></line-30>
<line-31> total_leaves = 0</line-31>
<line-32></line-32>
<line-33> for i in B:</line-33>
<line-34> if len(B[i]) == 1:</line-34>
<line-35> total_leaves += 1</line-35>
<line-36></line-36>
<line-37> S = [0]</line-37>
<line-38></line-38>
<line-39> visited = [False] * N</line-39>
<line-40></line-40>
<line-41> parent = [-1] * N</line-41>
<line-42></line-42>
<line-43> total_visits = [0] * N</line-43>
<line-44></line-44>
<line-45> while len(S) > 0:</line-45>
<line-46> current = S.pop(len(S) - 1)</line-46>
<line-47></line-47>
<line-48> if visited[current]:</line-48>
<line-49> p = parent[current]</line-49>
<line-50> if p != -1:</line-50>
<line-51> total_visits[p] += total_visits[current]</line-51>
<line-52> if p not in C:</line-52>
<line-53> C[p] = {}</line-53>
<line-54> C[p][current] = total_visits[current]</line-54>
<line-55> if current not in C:</line-55>
<line-56> C[current] = {}</line-56>
<line-57> C[current][p] = total_leaves - C[p][current]</line-57>
<line-58> else:</line-58>
<line-59> S.append(current)</line-59>
<line-60> visited[current] = True</line-60>
<line-61> for i, j in enumerate(B[current]):</line-61>
<line-62> if not visited[j]:</line-62>
<line-63> parent[j] = current</line-63>
<line-64> S.append(j)</line-64>
<line-65> if len(B[current]) == 1:</line-65>
<line-66> total_visits[current] = 1</line-66>
<line-67> p = parent[current]</line-67>
<line-68> if p != -1:</line-68>
<line-69> if p not in C:</line-69>
<line-70> C[p] = {}</line-70>
<line-71> C[p][current] = 1</line-71>
<line-72></line-72>
<line-73> D = {}</line-73>
<line-74> for i in C:</line-74>
<line-75> sum1 = 0</line-75>
<line-76> for j in C[i]:</line-76>
<line-77> sum1 += C[i][j]</line-77>
<line-78> D[i] = sum1</line-78>
<line-79></line-79>
<line-80> E = [0] * N</line-80>
<line-81> for i in C:</line-81>
<line-82> sum1 = 0</line-82>
<line-83> for j in C[i]:</line-83>
<line-84> D[i] -= C[i][j]</line-84>
<line-85> sum1 += C[i][j] * D[i]</line-85>
<line-86> E[i] = sum1</line-86>
<line-87></line-87>
<line-88> for i, j in enumerate(E):</line-88>
<line-89> if j == 0:</line-89>
<line-90> for k in C[i]:</line-90>
<line-91> E[i] = C[i][k]</line-91>
<line-92></line-92>
<line-93> E.sort()</line-93>
<line-94> E.reverse()</line-94>
<line-95> A.sort()</line-95>
<line-96> A.reverse()</line-96>
<line-97></line-97>
<line-98> E = [x % M for x in E]</line-98>
<line-99> A = [x % M for x in A]</line-99>
<line-100></line-100>
<line-101> ans = 0</line-101>
<line-102> for i, j in zip(E, A):</line-102>
<line-103> a = i * j</line-103>
<line-104> a %= M</line-104>
<line-105> ans += a</line-105>
<line-107></line-107>
<line-108> print(ans)</line-108>
|
{"code": "<line-3>M = 10 ** 9 + 7</line-3>\n<line-106> ans %= M</line-106>", "lines": [3, 106]}
#### 0
|
<line-1>from collections import defaultdict </line-1>
<line-3> </line-3>
<line-4> # Dictionary to store number of subarrays </line-4>
<line-5> # starting from index zero having </line-5>
<line-6> # particular value of sum. </line-6>
<line-7> prevSum = defaultdict(lambda : 0) </line-7>
<line-8> </line-8>
<line-9> res = 0 </line-9>
<line-10> </line-10>
<line-11> # Sum of elements so far. </line-11>
<line-12> currsum = 0 </line-12>
<line-13> </line-13>
<line-14> for i in range(0, n): </line-14>
<line-15> </line-15>
<line-16> # Add current element to sum so far. </line-16>
<line-17> currsum += arr[i] </line-17>
<line-18> </line-18>
<line-19> # If currsum is equal to desired sum, </line-19>
<line-20> # then a new subarray is found. So </line-20>
<line-21> # increase count of subarrays. </line-21>
<line-22> if currsum == Sum: </line-22>
<line-23> res += 1 </line-23>
<line-24> </line-24>
<line-25> # currsum exceeds given sum by currsum - sum. </line-25>
<line-26> # Find number of subarrays having </line-26>
<line-27> # this sum and exclude those subarrays </line-27>
<line-28> # from currsum by increasing count by </line-28>
<line-29> # same amount. </line-29>
<line-30> if (currsum - Sum) in prevSum: </line-30>
<line-31> res += prevSum[currsum - Sum] </line-31>
<line-32> </line-32>
<line-33> </line-33>
<line-34> # Add currsum value to count of </line-34>
<line-35> # different values of sum. </line-35>
<line-36> prevSum[currsum] += 1 </line-36>
<line-37> </line-37>
<line-38> return res </line-38>
<line-39>n=int(input())</line-39>
<line-40>lst=list(map(int,input().split()))</line-40>
<line-41>if(n==1):</line-41>
<line-42> if(lst[0]==0):</line-42>
<line-43> print(1)</line-43>
<line-44> else:</line-44>
<line-45> print(0)</line-45>
<line-47> print(findSubarraySum(lst,n,0)) </line-47>
|
{"code": "<line-2>def findSubarraySum(arr, n, Sum): </line-2>\n<line-46>else: </line-46>", "lines": [2, 46]}
#### 0
|
<line-1>import numpy as np</line-1>
<line-2></line-2>
<line-4> new_list = []</line-4>
<line-5> for i in range(len(array)):</line-5>
<line-6> start = 0</line-6>
<line-7> value = array[i][0]</line-7>
<line-8> last = len(new_list)</line-8>
<line-9> while start != last:</line-9>
<line-10> mid = (start + last) // 2</line-10>
<line-11> if new_list[mid][0] > value:</line-11>
<line-12> last = mid</line-12>
<line-13> else:</line-13>
<line-14> start = mid+1</line-14>
<line-15> new_list.insert(start,array[i])</line-15>
<line-16> return new_list</line-16>
<line-17></line-17>
<line-18>tests = int(input())</line-18>
<line-19>for _ in range(tests):</line-19>
<line-20> n, m, q = [int(j) for j in input().split()]</line-20>
<line-21> challenges = [[0] * 3 for _ in range(m)]</line-21>
<line-22> combos = [[0] * 2 for _ in range(q)]</line-22>
<line-23> for i in range(m):</line-23>
<line-24> challenges[i] = [int(j) for j in input().split()]</line-24>
<line-25> for i in range(q):</line-25>
<line-26> combos[i] = [int(j) for j in input().split()]</line-26>
<line-27> </line-27>
<line-28> sorted_chalenges = np.zeros((2 * m, 3),dtype=np.intc)</line-28>
<line-29> for i in range(m):</line-29>
<line-30> sorted_chalenges[2*i] = [challenges[i][0]-1,challenges[i][2],i]</line-30>
<line-31> sorted_chalenges[2*i+1] = [challenges[i][1],-challenges[i][2],i]</line-31>
<line-32> sorted_chalenges = np.array(sort_it(sorted_chalenges))</line-32>
<line-33> types_of_players = np.zeros((m + 1, 2 * m + 1),dtype=np.intc)</line-33>
<line-34> player_type = np.zeros(n,dtype=np.intc)</line-34>
<line-35> last_player = 0</line-35>
<line-36> for i in range(2 * m):</line-36>
<line-37> start, value, chal = sorted_chalenges[i]</line-37>
<line-38> types_of_players[chal+1:,i+1:] += value</line-38>
<line-39> player_type[last_player:start] = i</line-39>
<line-40> last_player = start</line-40>
<line-41> player_type[last_player:] = 2 * m</line-41>
<line-42> </line-42>
<line-43> combo_types = np.zeros((q, 2 * m + 1),dtype = np.intc)</line-43>
<line-44> for i in range(q):</line-44>
<line-45> first, last = combos[i]</line-45>
<line-46> r, p = [types_of_players[first - 1], types_of_players[last]]</line-46>
<line-47> combo_types[i] = np.maximum(p-r,0)</line-47>
<line-48> output = np.sum(combo_types,axis=0)[player_type]</line-48>
<line-49> for i in range(n):</line-49>
<line-51> print("")</line-51>
|
{"code": "<line-3>def sort_it(array):</line-3>\n<line-50> print(output[i], end = \" \")</line-50>", "lines": [3, 50]}
#### 0
|
<line-1>'''</line-1>
<line-3>codechef id :mj_13</line-3>
<line-4>Problem : Avenir Strings</line-4>
<line-5>'''</line-5>
<line-6>from sys import stdin,stdout</line-6>
<line-7>test=int(stdin.readline())</line-7>
<line-8>for _ in range(test):</line-8>
<line-9> N=int(stdin.readline())</line-9>
<line-10> seq=list(input())</line-10>
<line-11> fp,fp1,fl,fl1=0,0,0,1</line-11>
<line-12> for i in range(N):</line-12>
<line-13> if fl!=int(seq[i])-0:</line-13>
<line-14> fp+=1</line-14>
<line-15> fl=1-fl</line-15>
<line-16> for i in range(N):</line-16>
<line-17> if fl1!=int(seq[i])-0:</line-17>
<line-18> fp1+=1</line-18>
<line-20> print(fp) if fp<fp1 else print(fp1)</line-20>
|
{"code": "<line-2>Name : Jaymeet Mehta</line-2>\n<line-19> fl1=1-fl1</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>#dt = {} for i in x: dt[i] = dt.get(i,0)+1</line-1>
<line-3>inp,ip = lambda :int(input()),lambda :[int(w) for w in input().split()]</line-3>
<line-4></line-4>
<line-5>def kadane(arr, start, finish, n):</line-5>
<line-6> Sum = 0</line-6>
<line-7> maxSum = float('-inf')</line-7>
<line-8> i = None</line-8>
<line-9> finish[0] = -1</line-9>
<line-10> local_start = 0</line-10>
<line-11> for i in range(n):</line-11>
<line-12> Sum += arr[i]</line-12>
<line-13> if Sum < 0:</line-13>
<line-14> Sum = 0</line-14>
<line-15> local_start = i + 1</line-15>
<line-16> elif Sum > maxSum:</line-16>
<line-17> maxSum = Sum</line-17>
<line-18> start[0] = local_start</line-18>
<line-19> finish[0] = i</line-19>
<line-20></line-20>
<line-21> if finish[0] != -1:</line-21>
<line-22> return maxSum</line-22>
<line-23></line-23>
<line-24> maxSum = arr[0]</line-24>
<line-25> start[0] = finish[0] = 0</line-25>
<line-26></line-26>
<line-27> for i in range(1, n):</line-27>
<line-28> if arr[i] > maxSum:</line-28>
<line-29> maxSum = arr[i]</line-29>
<line-30> start[0] = finish[0] = i</line-30>
<line-31> return maxSum</line-31>
<line-32></line-32>
<line-33>def findMaxSum(M):</line-33>
<line-34> nonlocal ROW, COL</line-34>
<line-35> maxSum, finalLeft = float('-inf'), None</line-35>
<line-36> finalRight, finalTop, finalBottom = None, None, None</line-36>
<line-37> left, right, i = None, None, None</line-37>
<line-38></line-38>
<line-39> temp = [None] * ROW</line-39>
<line-40> Sum = 0</line-40>
<line-41> start = [0]</line-41>
<line-42> finish = [0]</line-42>
<line-43></line-43>
<line-44> for left in range(COL):</line-44>
<line-45> temp = [0] * ROW</line-45>
<line-46> for right in range(left, COL):</line-46>
<line-47> for i in range(ROW):</line-47>
<line-48> temp[i] += M[i][right]</line-48>
<line-49> Sum = kadane(temp, start, finish, ROW)</line-49>
<line-50> if Sum > maxSum:</line-50>
<line-51> maxSum = Sum</line-51>
<line-52> finalLeft = left</line-52>
<line-53> finalRight = right</line-53>
<line-54> finalTop = start[0]</line-54>
<line-55> finalBottom = finish[0]</line-55>
<line-56></line-56>
<line-57> for i in range(finalTop,finalBottom+1):</line-57>
<line-58> print(*M[i][finalLeft:finalRight+1])</line-58>
<line-59></line-59>
<line-60></line-60>
<line-61>ROW,COL = ip()</line-61>
<line-63>findMaxSum(M)</line-63>
<line-64></line-64>
<line-65></line-65>
<line-66> </line-66>
|
{"code": "<line-2>import sys;input = sys.stdin.readline</line-2>\n<line-62>M = [ip() for i in range(ROW)]</line-62>", "lines": [2, 62]}
#### 0
|
<line-1>#AUTHOR:: AMAN VERMA</line-1>
<line-3> for _ in range(int(input())):</line-3>
<line-4> row,column=list(map(int,input().split(" ")))</line-4>
<line-5> x_x,y_y=list(map(int,input().split(" ")))</line-5>
<line-6> ab=max((x_x-0),(row-x_x-1))</line-6>
<line-7> ba=max((y_y-0),(column-y_y-1))</line-7>
<line-8> print(ab+ba)</line-8>
<line-10> pass</line-10>
|
{"code": "<line-2>try:</line-2>\n<line-9>except:</line-9>", "lines": [2, 9]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>while t>0:</line-3>
<line-4> a=input().split(":")</line-4>
<line-5> a1=int(a[0])</line-5>
<line-6> a2=int(a[1])</line-6>
<line-7> b1=a1%12 </line-7>
<line-8> if a2%5!=0:</line-8>
<line-9> b2=(a2//5)*5+5</line-9>
<line-10> else:</line-10>
<line-11> b2=a2</line-11>
<line-12> </line-12>
<line-13> c1=b1*30 </line-13>
<line-14> </line-14>
<line-15> extra=0.5*b2 </line-15>
<line-16> c1+=extra</line-16>
<line-17> c1%=360</line-17>
<line-18></line-18>
<line-19> d1=(b2//5)*30 </line-19>
<line-20> d1%=360 </line-20>
<line-21> </line-21>
<line-22> if c1>d1:</line-22>
<line-23> ans1=c1-d1 </line-23>
<line-24> ans2=360-ans1</line-24>
<line-25> else:</line-25>
<line-26> ans1=d1-c1</line-26>
<line-27> ans2=360-ans1</line-27>
<line-28> ans=min(ans1,ans2)</line-28>
<line-29> if ans==int(ans):</line-29>
<line-30> ans3=int(ans)</line-30>
<line-31> y=str(ans3)+" degree"</line-31>
<line-32> print(y)</line-32>
<line-33> else:</line-33>
<line-34> y=str(ans)+" degree"</line-34>
<line-36> </line-36>
<line-37> t-=1</line-37>
<line-38> </line-38>
<line-39> </line-39>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-35> print(y)</line-35>", "lines": [2, 35]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> try:</line-3>
<line-4> m=int(input())</line-4>
<line-5> </line-5>
<line-6> n=int(m/2)</line-6>
<line-7> </line-7>
<line-8> a=m-n</line-8>
<line-9> </line-9>
<line-10> sum_even= int(2*(2*n*(n+1)*(2*n+1))/3)</line-10>
<line-11> </line-11>
<line-12> sum_odd= int(((4*a*a*a)-a)/3)</line-12>
<line-13> </line-13>
<line-14> result=sum_odd+sum_even</line-14>
<line-15> </line-15>
<line-16> if result%2==0:</line-16>
<line-17> print('Ravi')</line-17>
<line-18> else:</line-18>
<line-19> print('Jhon')</line-19>
<line-21> break;</line-21>
|
{"code": "<line-2>while True:</line-2>\n<line-20>\texcept:</line-20>", "lines": [2, 20]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>from math import ceil</line-3>
<line-4></line-4>
<line-5></line-5>
<line-6>def solve():</line-6>
<line-7> for _ in range(int(input())):</line-7>
<line-8> n, m = map(int, stdin.readline().split())</line-8>
<line-9> par = [i for i in range(n)]</line-9>
<line-10> for i in range(m):</line-10>
<line-11> ta, tb = map(int, stdin.readline().strip().split())</line-11>
<line-12> a, b = min(ta, tb), max(ta, tb)</line-12>
<line-13> for j in range(n):</line-13>
<line-14> if par[j] == par[b] and j != b:</line-14>
<line-15> par[j] = par[a]</line-15>
<line-16> par[b] = par[a]</line-16>
<line-17></line-17>
<line-18> q = int(input())</line-18>
<line-19> while q:</line-19>
<line-20> q -= 1</line-20>
<line-21> x, y = map(int, stdin.readline().split())</line-21>
<line-22> if par[x] == par[y]:</line-22>
<line-23> print("YO")</line-23>
<line-24> else:</line-24>
<line-25> print("NO")</line-25>
<line-26></line-26>
<line-27></line-27>
<line-28>def __starting_point():</line-28>
<line-30></line-30>
<line-31>__starting_point()</line-31>
|
{"code": "<line-2>from sys import stdin, stdout</line-2>\n<line-29> solve()</line-29>", "lines": [2, 29]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>t=int(input())</line-3>
<line-4>for _ in range(t):</line-4>
<line-5> n,p,q=list(map(int,input().split(" ")))</line-5>
<line-6> l=list(map(int,input().split(" ")))</line-6>
<line-7> l.sort()</line-7>
<line-8> s=sum(l)</line-8>
<line-9> a=p+2*q</line-9>
<line-10> b=0</line-10>
<line-11> for i in l:</line-11>
<line-12> if(p==0):</line-12>
<line-13> if(i%2==0 and a>=i):</line-13>
<line-14> a=a-i</line-14>
<line-15> b=b+1</line-15>
<line-16> elif(q==0):</line-16>
<line-17> if(a>=i):</line-17>
<line-18> a=a-i</line-18>
<line-19> b=b+1</line-19>
<line-20> else:</line-20>
<line-21> if(i%2==0 and a>=i):</line-21>
<line-22> a=a-i</line-22>
<line-23> b=b+1</line-23>
<line-24> elif(i%2!=0 and p!=0 and a>=i):</line-24>
<line-25> a=a-i</line-25>
<line-26> b=b+1</line-26>
<line-28></line-28>
<line-29> print(b) </line-29>
<line-30> </line-30>
<line-31> </line-31>
|
{"code": "<line-2># cook your dish here</line-2>\n<line-27> p=p-1</line-27>", "lines": [2, 27]}
#### 0
|
<line-2>for _ in range(int(input())):</line-2>
<line-3> n=list(map(int,input().split()))</line-3>
<line-4> print(n[0]*n[1])</line-4>
|
{"code": "<line-1># cook your dish here</line-1>", "lines": [1]}
#### 0
|
<line-2> n=int(input())</line-2>
<line-3> print((2*(pow(n,2)))-n+1)</line-3>
<line-4></line-4>
|
{"code": "<line-1>for _ in range(int(input())):</line-1>", "lines": [1]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(x):</line-3>
<line-4> y = list(map(str, input().split()))</line-4>
<line-5> j= 0</line-5>
<line-6> while j<len(y)-1:</line-6>
<line-7> print((y[j][0]).capitalize()+".", end=' ')</line-7>
<line-9> print(y[len(y)-1].capitalize())</line-9>
|
{"code": "<line-2>x= int(input())</line-2>\n<line-8> j+= 1</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>for j in range(t):</line-4>
<line-5> n = eval(input())</line-5>
<line-6> a = list(map(int, input().split()))</line-6>
<line-7> ch = 0</line-7>
<line-8> sm = 0 ; x = sum(a)</line-8>
<line-9> s1 = [0] * n ; s2 = [0] * n</line-9>
<line-10> for i in range(n):</line-10>
<line-11> sm += a[i]</line-11>
<line-12> s1[i] = sm</line-12>
<line-13> s2[i] = x</line-13>
<line-14> x -= a[i]</line-14>
<line-15> if(sum(a) - a[0] == 0):</line-15>
<line-16> print(0)</line-16>
<line-17> elif(sum(a) - a[n - 1] == 0):</line-17>
<line-18> print(n - 1)</line-18>
<line-19> else:</line-19>
<line-20> for i in range(1, n - 1):</line-20>
<line-21> if(s1[i - 1] == s2[i + 1]):</line-21>
<line-22> print(i)</line-22>
<line-23> ch = 1</line-23>
<line-24> break</line-24>
<line-25> if(ch == 0):</line-25>
<line-26> if(n == 1):</line-26>
<line-27> print(0)</line-27>
<line-29> print(-1)</line-29>
|
{"code": "<line-3>t = eval(input())</line-3>\n<line-28> else:</line-28>", "lines": [3, 28]}
#### 0
|
<line-1>def fastpow(base, power):</line-1>
<line-3> while power > 0:</line-3>
<line-4> if power % 2 == 0:</line-4>
<line-5> power = power // 2</line-5>
<line-6></line-6>
<line-7> base = base * base</line-7>
<line-8> else:</line-8>
<line-9> power = power - 1</line-9>
<line-10> result = result * base</line-10>
<line-11> power = power // 2</line-11>
<line-12> base = base * base</line-12>
<line-13> return result</line-13>
<line-14></line-14>
<line-15>t=int(input())</line-15>
<line-16>for i in range(t):</line-16>
<line-17> a=list(map(int,input().split()))</line-17>
<line-18> n,r=a[0],a[1]</line-18>
<line-20> </line-20>
<line-21> print(w)</line-21>
|
{"code": "<line-2> result = 1</line-2>\n<line-19> w=(n*(fastpow(n-1,r)))%((10**9)+7)</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> arr=list(map(int,input().split()))</line-3>
<line-4> risk=0</line-4>
<line-5> days_risk=0</line-5>
<line-6> days_norm=0</line-6>
<line-7> if d==1:</line-7>
<line-8> print(f)</line-8>
<line-9> else:</line-9>
<line-10> for a in arr:</line-10>
<line-11> if a>=80 or a<=9:</line-11>
<line-12> risk+=1</line-12>
<line-13> norm=f-risk</line-13>
<line-14> if risk%d==0:</line-14>
<line-15> days_risk=risk//d</line-15>
<line-16> else:</line-16>
<line-17> days_risk=(risk//d)+1</line-17>
<line-18> if norm%d==0:</line-18>
<line-19> days_norm=norm//d</line-19>
<line-20> else:</line-20>
<line-22> print(days_risk+days_norm)</line-22>
<line-23> </line-23>
<line-24> </line-24>
|
{"code": "<line-2> f,d=list(map(int,input().split()))</line-2>\n<line-21> days_norm=(norm//d)+1</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> a=list(map(int,input().split()))</line-3>
<line-4> dp=[0]*(max(a)+1)</line-4>
<line-5> for _ in range(n):</line-5>
<line-6> dp[a[_]]+=1</line-6>
<line-7> for _ in range(1,len(dp)):</line-7>
<line-8> if dp[_]>k:</line-8>
<line-10> print()</line-10>
|
{"code": "<line-2> n,k=[int(x) for x in input().split()]</line-2>\n<line-9> print(_,end=\" \")</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>mod = 1000000007</line-1>
<line-3>maxn = (10**5)+5</line-3>
<line-4>for i in range(2,maxn):</line-4>
<line-5> x = (fac[-1]*i)%mod</line-5>
<line-6> fac.append(x)</line-6>
<line-7></line-7>
<line-8>pre = [1]</line-8>
<line-9>for i in range(2,maxn):</line-9>
<line-10> x = 2*i-1</line-10>
<line-11> x = (pre[-1]*x)%mod</line-11>
<line-12> pre.append(x)</line-12>
<line-13></line-13>
<line-14>for _ in range(int(input())):</line-14>
<line-15> n = int(input())</line-15>
<line-16> x = fac[n]</line-16>
<line-18> print((x*y)%mod)</line-18>
|
{"code": "<line-2>fac = [1,1]</line-2>\n<line-17> y = pre[n-1]</line-17>", "lines": [2, 17]}
#### 0
|
<line-1>from sys import stdin,stdout</line-1>
<line-3>nmbr=lambda:int(stdin.readline())</line-3>
<line-4>lst=lambda:list(map(int, stdin.readline().split()))</line-4>
<line-5></line-5>
<line-6>for _ in range(nmbr()):</line-6>
<line-7> n=nmbr()</line-7>
<line-8> a=lst()</line-8>
<line-9> g=a[0]</line-9>
<line-10> ans=0</line-10>
<line-11> for v in a[1:]:</line-11>
<line-12> g=gcd(v,g)</line-12>
<line-13> for i in a:</line-13>
<line-15> print(g,ans)</line-15>
|
{"code": "<line-2>from math import gcd</line-2>\n<line-14> ans+=i//g</line-14>", "lines": [2, 14]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n,m=list(map(int,input().split()))</line-3>
<line-4> a=list(map(int,input().split()))</line-4>
<line-5> army=0</line-5>
<line-6> if n>m:</line-6>
<line-7> </line-7>
<line-8> for i in range(0,m):</line-8>
<line-9> army+=a[i]</line-9>
<line-10> </line-10>
<line-11> </line-11>
<line-12> for j in range(m,n):</line-12>
<line-13> army=army-(a[j]/2)</line-13>
<line-14> if army<0:</line-14>
<line-15> print('DEFEAT')</line-15>
<line-16> break</line-16>
<line-17> else:</line-17>
<line-18> continue</line-18>
<line-19> else:</line-19>
<line-20> print('VICTORY')</line-20>
<line-21> </line-21>
<line-23> print('VICTORY')</line-23>
|
{"code": "<line-2>for i in range(t):</line-2>\n<line-22> if n<=m:</line-22>", "lines": [2, 22]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>while t!=0:</line-3>
<line-4> n,k=map(int,input().split())</line-4>
<line-5> lst=[]</line-5>
<line-6> for i in range(1,n+1):</line-6>
<line-7> lst.append(i)</line-7>
<line-8> lst[k],lst[n-1]=lst[n-1],lst[k]</line-8>
<line-9> for item in lst:</line-9>
<line-11> t-=1</line-11>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-10> print(item,end=' ')</line-10>", "lines": [2, 10]}
#### 0
|
<line-1></line-1>
<line-2>t = int(input())</line-2>
<line-3></line-3>
<line-5> n,m = map(int,input().split())</line-5>
<line-6></line-6>
<line-7> if n==1:</line-7>
<line-8> print(m)</line-8>
<line-9> else:</line-9>
<line-10> </line-10>
<line-11> if n%2==0:</line-11>
<line-12> print((n//2)*m)</line-12>
<line-13> </line-13>
<line-15> print(((n//2)+1)*m)</line-15>
|
{"code": "<line-4>for _ in range(t):</line-4>\n<line-14> else:</line-14>", "lines": [4, 14]}
#### 0
|
<line-1>test = int(input())</line-1>
<line-3>for i in range(test):</line-3>
<line-4> n = int(input())</line-4>
<line-5> items = sorted(list(map(int, input().split())))</line-5>
<line-6> c = 1</line-6>
<line-7> for j in range(len(items)):</line-7>
<line-8> if items[j] < 2000:</line-8>
<line-9> t = 2000 - items[j]</line-9>
<line-10> if t in items[j+1:]:</line-10>
<line-11> ANS.append("Accepted")</line-11>
<line-12> c = 2</line-12>
<line-13> break</line-13>
<line-14> else:</line-14>
<line-15> pass</line-15>
<line-16> else:</line-16>
<line-17> break</line-17>
<line-18> if c==1:</line-18>
<line-19> ANS.append("Rejected")</line-19>
<line-21> print(ans)</line-21>
|
{"code": "<line-2>ANS = list()</line-2>\n<line-20>for ans in ANS:</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>a=eval(input())</line-1>
<line-3></line-3>
<line-4> x=eval(input())</line-4>
<line-5> b=list(map(int,input().split()))</line-5>
<line-6> z=[0]*100</line-6>
<line-7> k=1</line-7>
<line-8> j=0</line-8>
<line-9> c=0</line-9>
<line-10> for i in b:</line-10>
<line-11> </line-11>
<line-12> if i==0:</line-12>
<line-13> </line-13>
<line-14> z.insert(i,k)</line-14>
<line-15> </line-15>
<line-16> else:</line-16>
<line-17> </line-17>
<line-18> if z[z.index(i)+1]==0:</line-18>
<line-19> </line-19>
<line-20> z.insert(j,k)</line-20>
<line-21> else:</line-21>
<line-22> m=z.index(i)</line-22>
<line-23> n=m+1</line-23>
<line-24> p=(len(z)-z.count(0))-n</line-24>
<line-25> c=c+min(n,p)</line-25>
<line-26> </line-26>
<line-27> z.insert(m+1,k)</line-27>
<line-28> </line-28>
<line-29> </line-29>
<line-30> k+=1</line-30>
<line-31> j+=1</line-31>
<line-32> m=0</line-32>
<line-33> n=0</line-33>
<line-34> p=0</line-34>
<line-35> </line-35>
<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-48></line-48>
<line-49> a-=1</line-49>
|
{"code": "<line-2>while(a):</line-2>\n<line-36> print(c)</line-36>", "lines": [2, 36]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-3> s = input().strip()</line-3>
<line-4> if not s:</line-4>
<line-5> print('NO')</line-5>
<line-6></line-6>
<line-7> dp = [0 for x in range(len(s) + 1)]</line-7>
<line-8> dp[0] = 1</line-8>
<line-9> dp[1] = 1 if 0 < int(s[0]) <= 9 else 0</line-9>
<line-10></line-10>
<line-11> for i in range(2, len(s) + 1):</line-11>
<line-12> if 0 < int(s[i-1:i]) <= 9:</line-12>
<line-13> dp[i] += dp[i - 1]</line-13>
<line-14> if s[i-2:i][0] != '0' and int(s[i-2:i]) <= 26:</line-14>
<line-15> dp[i] += dp[i - 2]</line-15>
<line-16> </line-16>
<line-17> if dp[len(s)]%2 == 0:</line-17>
<line-18> print('YES')</line-18>
<line-19> else:</line-19>
<line-21> t -= 1</line-21>
|
{"code": "<line-2>while t>0:</line-2>\n<line-20> print('NO')</line-20>", "lines": [2, 20]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> b = bin(idx)[2:]</line-3>
<line-5> print(int(b, 2))</line-5>
|
{"code": "<line-2> p, idx = map(int, input().split())</line-2>\n<line-4> b = ('0' * (p - len(b)) + b)[::-1]</line-4>", "lines": [2, 4]}
#### 0
|
<line-1>try:</line-1>
<line-3> t=int(t)</line-3>
<line-4> m=list(m)</line-4>
<line-5> letters=list("abcdefghijklmnopqrstuvwxyz")</line-5>
<line-6> trans={}</line-6>
<line-7> for i in range(len(letters)):</line-7>
<line-8> trans[letters[i]]=m[i]</line-8>
<line-9> for i in range(t):</line-9>
<line-10> x=list(input())</line-10>
<line-11> y=""</line-11>
<line-12> for j in x:</line-12>
<line-13> if(j.isalpha()==True):</line-13>
<line-14> if(j.isupper()==True):</line-14>
<line-15> y+=trans[j.lower()].upper()</line-15>
<line-16> else:</line-16>
<line-17> y+=trans[j]</line-17>
<line-18> else:</line-18>
<line-19> if(j=='_'):</line-19>
<line-20> y+=" "</line-20>
<line-21> else:</line-21>
<line-22> y+=j</line-22>
<line-24> </line-24>
<line-25>except:pass</line-25>
|
{"code": "<line-2> t,m=input().split()</line-2>\n<line-23> print(y)</line-23>", "lines": [2, 23]}
#### 0
|
<line-1>arr=[]</line-1>
<line-3>for i in range(n):</line-3>
<line-4> a=int(input())</line-4>
<line-5> arr.append(a)</line-5>
<line-6> arr.sort()</line-6>
<line-8> print((i-p)+1)</line-8>
|
{"code": "<line-2>n=int(input())</line-2>\n<line-7> p=arr.index(a)</line-7>", "lines": [2, 7]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> </line-3>
<line-4> # Corner cases </line-4>
<line-5> if (n <= 1) : </line-5>
<line-6> return False</line-6>
<line-7> if (n <= 3) : </line-7>
<line-8> return True</line-8>
<line-9> </line-9>
<line-10> # This is checked so that we can skip </line-10>
<line-11> # middle five numbers in below loop </line-11>
<line-12> if (n % 2 == 0 or n % 3 == 0) : </line-12>
<line-13> return False</line-13>
<line-14> </line-14>
<line-15> i = 5</line-15>
<line-16> while(i * i <= n) : </line-16>
<line-17> if (n % i == 0 or n % (i + 2) == 0) : </line-17>
<line-18> return False</line-18>
<line-19> i = i + 6</line-19>
<line-20> </line-20>
<line-21> return True</line-21>
<line-22>t=int(input())</line-22>
<line-23>for i in range(0,t):</line-23>
<line-24> n=int(input())</line-24>
<line-25> if n==1:</line-25>
<line-26> print("2")</line-26>
<line-27> continue</line-27>
<line-28> if isPrime(n):</line-28>
<line-29> print(n+1)</line-29>
<line-30> continue</line-30>
<line-31> if n%2==0:</line-31>
<line-32> k=n//2</line-32>
<line-33> min=2+k</line-33>
<line-34> else:</line-34>
<line-35> min=n+1</line-35>
<line-36> for j in range(2,(n//2)+1):</line-36>
<line-37> if n%j==0:</line-37>
<line-38> k=n//j</line-38>
<line-39> if k!=j:</line-39>
<line-40> l=j+k</line-40>
<line-41> if l<min:</line-41>
<line-43> print(min)</line-43>
|
{"code": "<line-2>def isPrime(n) : </line-2>\n<line-42> min=l</line-42>", "lines": [2, 42]}
#### 0
|
<line-1>T= int(input());</line-1>
<line-2></line-2>
<line-4> n,k = list(map(int,input().split()));</line-4>
<line-5> s=list(map(int,input()));</line-5>
<line-6></line-6>
<line-7> if k==1:</line-7>
<line-8> s_0 ={};</line-8>
<line-9> s_1={};</line-9>
<line-10> c0=0;</line-10>
<line-11> c1=0;</line-11>
<line-12> for j in range(n):</line-12>
<line-13> if(j%2==0):</line-13>
<line-14> s_1[j]=1;</line-14>
<line-15> s_0[j]=0;</line-15>
<line-16> else:</line-16>
<line-17> s_1[j]=0;</line-17>
<line-18> s_0[j]=1;</line-18>
<line-19> for j in range(n):</line-19>
<line-20> if(s_0[j]-s[j]!=0):</line-20>
<line-21> c0+=1;</line-21>
<line-22> if(s_1[j]-s[j]!=0):</line-22>
<line-23> c1+=1;</line-23>
<line-24></line-24>
<line-25> if c0<c1:</line-25>
<line-26> print(c0);</line-26>
<line-27> p_s="";</line-27>
<line-28> for j in range(n):</line-28>
<line-29> p_s+=str(s_0[j]);</line-29>
<line-30> print(p_s);</line-30>
<line-31> else:</line-31>
<line-32> print(c1);</line-32>
<line-33> p_s="";</line-33>
<line-34> for j in range(n):</line-34>
<line-35> p_s+=str(s_1[j]);</line-35>
<line-36> print(p_s);</line-36>
<line-37></line-37>
<line-38> else:</line-38>
<line-39> count=1;</line-39>
<line-40> c=s[0];</line-40>
<line-41> flips=0</line-41>
<line-42> for j in range(1,n):</line-42>
<line-43> if(s[j]==c):</line-43>
<line-44> count+=1;</line-44>
<line-45> #print count;</line-45>
<line-46> if count > k:</line-46>
<line-47> if(j+1<n and s[j]==s[j+1]):</line-47>
<line-48> if(s[j]==1):</line-48>
<line-49> s[j]=0;</line-49>
<line-50> else:</line-50>
<line-51> s[j]=1;</line-51>
<line-52> else:</line-52>
<line-53> if(s[j-1]==1):</line-53>
<line-54> s[j-1]=0;</line-54>
<line-55> else:</line-55>
<line-56> s[j-1]=1;</line-56>
<line-57> flips+=1;</line-57>
<line-58> count=1;</line-58>
<line-59></line-59>
<line-60></line-60>
<line-61> elif(s[j]!=c):</line-61>
<line-62> count=1;</line-62>
<line-63> c=s[j];</line-63>
<line-64></line-64>
<line-65> print(flips);</line-65>
<line-66> p_s="";</line-66>
<line-67> for j in range(n):</line-67>
<line-69> print(p_s);</line-69>
|
{"code": "<line-3>for i in range(T):</line-3>\n<line-68> p_s+=str(s[j]);</line-68>", "lines": [3, 68]}
#### 0
|
<line-1>from math import log,pow</line-1>
<line-3>a=[]</line-3>
<line-4>for i in range(n):</line-4>
<line-5> no=int(input())</line-5>
<line-6> if(no%2==0):</line-6>
<line-7> a.append("0")</line-7>
<line-8> elif(no==1):</line-8>
<line-9> a.append("1")</line-9>
<line-10> elif(no==3):</line-10>
<line-11> a.append("3")</line-11>
<line-12> else:</line-12>
<line-13> s="2"</line-13>
<line-14> lv=int(log(no,2))</line-14>
<line-15> clv=1</line-15>
<line-16> cno=3</line-16>
<line-17> while(cno!=no):</line-17>
<line-18> if(no<cno*pow(2,lv-clv)):</line-18>
<line-19> s=s+"1"</line-19>
<line-20> clv=clv+1</line-20>
<line-21> cno=(2*cno)-1</line-21>
<line-22> else:</line-22>
<line-23> s=s+"2"</line-23>
<line-24> clv=clv+1</line-24>
<line-25> cno=(2*cno)+1</line-25>
<line-26> a.append(s)</line-26>
<line-28> print(i)</line-28>
<line-29> </line-29>
|
{"code": "<line-2>n=int(input())</line-2>\n<line-27>for i in a:</line-27>", "lines": [2, 27]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-2></line-2>
<line-4>ls=[]</line-4>
<line-5>for i in range(a):</line-5>
<line-6> ls.append(int(input()))</line-6>
<line-7>ls.sort()</line-7>
<line-8>c=0;i=0</line-8>
<line-9>while i<(a-1):</line-9>
<line-10> if ls[i+1]-ls[i]<=b:</line-10>
<line-11> c=c+1</line-11>
<line-12> i=i+1</line-12>
<line-14>print(c)</line-14>
|
{"code": "<line-3>a,b=list(map(int,input().split()))</line-3>\n<line-13> i=i+1</line-13>", "lines": [3, 13]}
#### 0
|
<line-1># cooking dish here</line-1>
<line-2></line-2>
<line-4>from collections import Counter</line-4>
<line-5>read = stdin.readline</line-5>
<line-6></line-6>
<line-7>for testcase in range(int(read())):</line-7>
<line-8> length = int(read())</line-8>
<line-9> string = read().strip()</line-9>
<line-10> </line-10>
<line-11> counts = Counter(string)</line-11>
<line-12> </line-12>
<line-13> odd_counts = 0</line-13>
<line-14> </line-14>
<line-15> for count in list(counts.values()):</line-15>
<line-16> # print(count, counts)</line-16>
<line-18> </line-18>
<line-19> print(max(odd_counts-1, 0))</line-19>
|
{"code": "<line-3>from sys import stdin</line-3>\n<line-17> odd_counts += count%2</line-17>", "lines": [3, 17]}
#### 0
|
<line-1>def g(x,y):</line-1>
<line-3> e= x[0]>y[0] or x[1]>y[1] or x[2]>y[2]</line-3>
<line-4> return d and e</line-4>
<line-5>t=int(input())</line-5>
<line-6>for _ in range(t):</line-6>
<line-7> a=list(map(int,input().split()))</line-7>
<line-8> b=list(map(int,input().split()))</line-8>
<line-9> c=list(map(int,input().split()))</line-9>
<line-10></line-10>
<line-11> if g(a,b) and g(b,c):</line-11>
<line-12> print('yes')</line-12>
<line-13> elif g(a,c) and g(c,b):</line-13>
<line-14> print('yes')</line-14>
<line-15> elif g(b,a) and g(a,c):</line-15>
<line-16> print('yes')</line-16>
<line-17> elif g(b,c) and g(c,a):</line-17>
<line-18> print('yes')</line-18>
<line-19> elif g(c,a) and g(a,b):</line-19>
<line-20> print('yes')</line-20>
<line-21> elif g(c,b) and g(b,a):</line-21>
<line-22> print('yes')</line-22>
<line-24> print('no')</line-24>
<line-25> </line-25>
|
{"code": "<line-2> d = x[0]>=y[0] and x[1]>=y[1] and x[2]>=y[2]</line-2>\n<line-23> else:</line-23>", "lines": [2, 23]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-2></line-2>
<line-3> </line-3>
<line-5>for _ in range(t):</line-5>
<line-6> l = input()</line-6>
<line-7> </line-7>
<line-8> n= len(l)</line-8>
<line-9> prod = 1</line-9>
<line-10> for k in range(n//2):</line-10>
<line-11> i = l[k]</line-11>
<line-12> j = l[n-k-1]</line-12>
<line-13> if ((i!=j) and (i!='?' and j!="?") ):</line-13>
<line-14> prod=0</line-14>
<line-15> break</line-15>
<line-16> elif ((i==j) and (i=='?')):</line-16>
<line-17> prod*=26</line-17>
<line-18> prod = prod%10000009</line-18>
<line-19> if n%2!=0:</line-19>
<line-20> if l[n//2]=="?":</line-20>
<line-22> </line-22>
<line-23> print(prod)</line-23>
|
{"code": "<line-4>t=int(input())</line-4>\n<line-21> prod*=26</line-21>", "lines": [4, 21]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(int(input())):</line-3>
<line-4> n=int(input())</line-4>
<line-5> c=0</line-5>
<line-6> while(n>0):</line-6>
<line-7> i=int(math.sqrt(n))</line-7>
<line-8> c+=1</line-8>
<line-10> print(c)</line-10>
<line-11> </line-11>
|
{"code": "<line-2>import math</line-2>\n<line-9> n=n-i**2</line-9>", "lines": [2, 9]}
#### 0
|
<line-1>from sys import stdin</line-1>
<line-3></line-3>
<line-4># Input data</line-4>
<line-5>#stdin = open("input", "r")</line-5>
<line-6></line-6>
<line-7></line-7>
<line-8>def dfs(src, visit):</line-8>
<line-9> visit[src] = 1</line-9>
<line-10> for nbr in d[src]:</line-10>
<line-11> if visit[nbr] == 0:</line-11>
<line-12> dfs(nbr, visit)</line-12>
<line-13></line-13>
<line-14>for _ in range(int(stdin.readline())):</line-14>
<line-15> n, m = list(map(int, stdin.readline().split()))</line-15>
<line-16> d = {}</line-16>
<line-17> for i in range(m):</line-17>
<line-18> u, v = list(map(int, stdin.readline().split()))</line-18>
<line-19> if u in d:</line-19>
<line-20> d[u].append(v)</line-20>
<line-21> else:</line-21>
<line-22> d[u] = [v]</line-22>
<line-23> if v in d:</line-23>
<line-24> d[v].append(u)</line-24>
<line-25> else:</line-25>
<line-26> d[v] = [u]</line-26>
<line-27> visited = {}</line-27>
<line-28> for i in range(n):</line-28>
<line-29> visited[i] = 0</line-29>
<line-30> ans = 0</line-30>
<line-31> for i in range(n):</line-31>
<line-32> if visited[i] == 0:</line-32>
<line-33> ans += 1</line-33>
<line-34> if i in d:</line-34>
<line-36> print(ans)</line-36>
|
{"code": "<line-2>from math import ceil, gcd</line-2>\n<line-35> dfs(i, visited)</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>nr=int(input())</line-1>
<line-3>for r in range(nr):</line-3>
<line-4> s,v=list(map(str,input().split()))</line-4>
<line-5> d[int(v)]=s</line-5>
<line-6>q=int(input())</line-6>
<line-7>lis=[]</line-7>
<line-8>for i in range(q):</line-8>
<line-9> lis.append(input())</line-9>
<line-10>l=list(d.keys())</line-10>
<line-11>l.sort(reverse=True)</line-11>
<line-12>ans='NO'</line-12>
<line-13></line-13>
<line-14></line-14>
<line-15>for j in lis:</line-15>
<line-16> ans='NO'</line-16>
<line-17> for k in l:</line-17>
<line-18> if len(j)<=len(d[k]):</line-18>
<line-19> a=d[k]</line-19>
<line-20> if j==a[0:len(j)]:</line-20>
<line-21> ans=a</line-21>
<line-23> print(ans) </line-23>
|
{"code": "<line-2>d={}</line-2>\n<line-22> break</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>def mod(a,b,c):</line-1>
<line-3> y = a</line-3>
<line-4> while(b>0):</line-4>
<line-5> if(b%2==1):</line-5>
<line-6> x = (x*y)%c</line-6>
<line-7> y = (y*y)%c</line-7>
<line-8> b /=2</line-8>
<line-9> return x%c</line-9>
<line-10>t = int(input())</line-10>
<line-11>num = 10**9+7</line-11>
<line-12>for i in range(t):</line-12>
<line-13> n,m,q,k = list(map(int,input().split()))</line-13>
<line-14> if m<=q:</line-14>
<line-15> print(0)</line-15>
<line-16> else:</line-16>
<line-17> a1 = m-q</line-17>
<line-18> a2 = mod(q+1,n,num)</line-18>
<line-19> a3 = mod(q-1,n,num)</line-19>
<line-20> a4 = mod(q,n,num)</line-20>
<line-21> a5 = a2-2*a4+a3</line-21>
<line-23> print(ans%num)</line-23>
|
{"code": "<line-2> x = 1</line-2>\n<line-22> ans = a1*a5</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>try:</line-1>
<line-3> x=[*list(map(int, input().split()))]</line-3>
<line-4> y=[*list(map(int, input().split()))]</line-4>
<line-5> for i in y:</line-5>
<line-6> d=x.count(i)-y.count(i)</line-6>
<line-7> if d!=0:</line-7>
<line-8> print(i)</line-8>
<line-10>except: pass</line-10>
|
{"code": "<line-2>\tn=int(input())</line-2>\n<line-9>\t\t\tbreak</line-9>", "lines": [2, 9]}
#### 0
|
{"code": "<line-1>print</line-1>", "lines": [1]}
#### 0
|
|
<line-1># cook your dish here</line-1>
<line-3> x=int(input())</line-3>
<line-4> if x<10:</line-4>
<line-5> print("Thanks for helping Chef!")</line-5>
<line-7> print("-1")</line-7>
|
{"code": "<line-2>for i in range(int(input())):</line-2>\n<line-6> else:</line-6>", "lines": [2, 6]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(int(input())):</line-3>
<line-4> n,m,k=map(int,input().split())</line-4>
<line-5> l,ans = list(map(int,input().split())),0</line-5>
<line-6> for i in l:</line-6>
<line-7> r=i//m + 1;c=i%m</line-7>
<line-8> if(c==0):c=m;r-=1</line-8>
<line-9> ans+=r*(n+1-r)*c*(m+1-c)</line-9>
<line-11> print(ans)</line-11>
|
{"code": "<line-2># cook your dish here</line-2>\n<line-10> ans/=((n+1)*(m+1)*n*m)//4</line-10>", "lines": [2, 10]}
#### 0
|
<line-1>#!/usr/bin/env python</line-1>
<line-2></line-2>
<line-4> N = int(input())</line-4>
<line-5> C = 0</line-5>
<line-6> for n in range(N):</line-6>
<line-7> S = input().strip()</line-7>
<line-8> Pi = S.split()[-1]</line-8>
<line-9> L = [Pi.count(k) for k in map(str, list(range(10)))]</line-9>
<line-10> if L[8] >= L[5] and L[5] >= L[3] and \</line-10>
<line-11> L[0] == 0 and L[1] == 0 and \</line-11>
<line-12> L[2] == 0 and L[4] == 0 and \</line-12>
<line-13> L[6] == 0 and L[7] == 0 and \</line-13>
<line-14> L[9] == 0: C += 1</line-14>
<line-16></line-16>
<line-17>main()</line-17>
<line-18></line-18>
|
{"code": "<line-3>def main():</line-3>\n<line-15> print(C)</line-15>", "lines": [3, 15]}
#### 0
|
<line-1>t = int(input())</line-1>
<line-2></line-2>
<line-4></line-4>
<line-5> str = input()</line-5>
<line-6></line-6>
<line-7> dict = {}</line-7>
<line-8></line-8>
<line-9> for x in range(len(str)):</line-9>
<line-10> if str[x] in dict:</line-10>
<line-11> dict[str[x]] = -1</line-11>
<line-12> else:</line-12>
<line-13> dict[str[x]] = x</line-13>
<line-14></line-14>
<line-15> shankyIndex = len(str)</line-15>
<line-16> ankuIndex = -1</line-16>
<line-17> for x in dict:</line-17>
<line-18> if dict[x] != -1:</line-18>
<line-19> if dict[x] < shankyIndex:</line-19>
<line-20> shankyIndex = dict[x]</line-20>
<line-21> if dict[x] > ankuIndex:</line-21>
<line-22> ankuIndex = dict[x]</line-22>
<line-23></line-23>
<line-24> ankuLetter = 0</line-24>
<line-25> shankyLetter = 0</line-25>
<line-26></line-26>
<line-27> if ankuIndex != -1:</line-27>
<line-28> ankuLetter = str[ankuIndex]</line-28>
<line-29> else:</line-29>
<line-30> print('PANDEY')</line-30>
<line-31> continue</line-31>
<line-32></line-32>
<line-33> if shankyIndex != len(str):</line-33>
<line-34> shankyLetter = str[shankyIndex]</line-34>
<line-35> else:</line-35>
<line-36> print('PANDEY')</line-36>
<line-37> continue</line-37>
<line-38></line-38>
<line-39> if shankyLetter > ankuLetter:</line-39>
<line-40> print('SHANKY')</line-40>
<line-41> elif ankuLetter > shankyLetter:</line-41>
<line-42> print('ANKU')</line-42>
<line-44> print('PANDEY')</line-44>
|
{"code": "<line-3>for e in range(t):</line-3>\n<line-43> else:</line-43>", "lines": [3, 43]}
#### 0
|
<line-1>def get(l,n):</line-1>
<line-3> i = 1</line-3>
<line-4> h1,m1 = l[0]</line-4>
<line-5> while (i < len(l)):</line-5>
<line-6> h2,m2 = l[i]</line-6>
<line-7> if (h1>h2):</line-7>
<line-8> if (m1 >= m2):</line-8>
<line-9> l1 += [(0,10**20)]</line-9>
<line-10> l2 += [(-1,-1)]</line-10>
<line-11> else:</line-11>
<line-12> d = (h1-h2)//(m2-m1)</line-12>
<line-13> if (((h1-h2)%(m2-m1)) == 0):</line-13>
<line-14> l1 += [(0,d-1)]</line-14>
<line-15> l2 += [(d+1,10**20)]</line-15>
<line-16> else:</line-16>
<line-17> l1 += [(0,d)]</line-17>
<line-18> l2 += [(d+1,10**20)]</line-18>
<line-19> elif(h1==h2):</line-19>
<line-20> if (m1 > m2):</line-20>
<line-21> l1 += [(1,10**20)]</line-21>
<line-22> l2 += [(-1,-1)]</line-22>
<line-23> elif(m1==m2):</line-23>
<line-24> l1 += [(-1,-1)]</line-24>
<line-25> l2 += [(-1,-1)]</line-25>
<line-26> else:</line-26>
<line-27> l2 += [(1,10**20)]</line-27>
<line-28> l1 += [(-1,-1)]</line-28>
<line-29> else:</line-29>
<line-30> if (m1 <= m2):</line-30>
<line-31> l2 += [(0,10**20)]</line-31>
<line-32> l1 += [(-1,-1)]</line-32>
<line-33> else:</line-33>
<line-34> d = (h2-h1)//(m1-m2)</line-34>
<line-35> if ((h2-h1)%(m1-m2) == 0):</line-35>
<line-36> l2 += [(0,d-1)]</line-36>
<line-37> l1 += [(d+1,10**20)]</line-37>
<line-38> else:</line-38>
<line-39> l2 += [(0,d)]</line-39>
<line-40> l1 += [(d+1,10**20)]</line-40>
<line-41> i += 1</line-41>
<line-42> h1,m1 = h2,m2</line-42>
<line-43> return l1,l2</line-43>
<line-44> </line-44>
<line-45>def intersect(k1,k2):</line-45>
<line-46> k1,k2 = min(k1,k2),max(k1,k2)</line-46>
<line-47> c1,c2 = k1</line-47>
<line-48> c3,c4 = k2</line-48>
<line-49> l = [c1,c2,c3,c4]</line-49>
<line-50> l.sort()</line-50>
<line-51> if (l[2]==c2):</line-51>
<line-52> return (c3,min(c2,c4))</line-52>
<line-53> elif (l[3]==c2):</line-53>
<line-54> return k2</line-54>
<line-55> else:</line-55>
<line-56> return (-1,-1)</line-56>
<line-57> </line-57>
<line-58> </line-58>
<line-59> </line-59>
<line-60>def union(k1,k2):</line-60>
<line-61> k1,k2 = min(k1,k2),max(k1,k2)</line-61>
<line-62> c1,c2 = k1</line-62>
<line-63> c3,c4 = k2</line-63>
<line-64> l = [c1,c2,c3,c4]</line-64>
<line-65> l.sort()</line-65>
<line-66> if (c2==l[3]):</line-66>
<line-67> return ([c1,c2])</line-67>
<line-68> elif(c2==l[2] or ((c3-c2) == 1)):</line-68>
<line-69> return([c1,c4])</line-69>
<line-70> else:</line-70>
<line-71> return([c1,c2,c3,c4])</line-71>
<line-72> </line-72>
<line-73> </line-73>
<line-74>def aa(l1,l2,n):</line-74>
<line-75> c1,c2 = 0,10**20</line-75>
<line-76> i = 0</line-76>
<line-77> n -= 1</line-77>
<line-78> while (i < n):</line-78>
<line-79> if (i%2 == 0):</line-79>
<line-80> k1,k2 = l1[i]</line-80>
<line-81> else:</line-81>
<line-82> k1,k2 = l2[i]</line-82>
<line-83> i += 1</line-83>
<line-84> if ((k1,k2) == (-1,-1)):</line-84>
<line-85> return (-1,-1)</line-85>
<line-86> c1,c2 = intersect((c1,c2),(k1,k2))</line-86>
<line-87> if ((c1,c2) == (-1,-1)):</line-87>
<line-88> return (c1,c2)</line-88>
<line-89> return (c1,c2)</line-89>
<line-90> </line-90>
<line-91> </line-91>
<line-92>test = int(input())</line-92>
<line-93>while (test != 0):</line-93>
<line-94> test -= 1</line-94>
<line-95> n = int(input())</line-95>
<line-96> l = []</line-96>
<line-97> i = 0</line-97>
<line-98> while (i < n):</line-98>
<line-99> c1,c2 = list(map(int,input().split()))</line-99>
<line-100> l += [(c1,c2)]</line-100>
<line-101> i += 1</line-101>
<line-102> if (n == 1):</line-102>
<line-103> print(1)</line-103>
<line-104> print("0 Inf")</line-104>
<line-105> else:</line-105>
<line-106> l1,l2 = (get(l,n))</line-106>
<line-107> k1,k2 = aa(l1,l2,n)</line-107>
<line-108> if ((k1,k2) == (-1,-1)):</line-108>
<line-109> k1,k2 = aa(l2,l1,n)</line-109>
<line-110> if ((k1,k2) == (-1,-1)):</line-110>
<line-111> print(0)</line-111>
<line-112> else:</line-112>
<line-113> print(1)</line-113>
<line-114> if (k2 == 10**20):</line-114>
<line-115> k2 = "Inf"</line-115>
<line-116> print(str(k1) + " " +str(k2))</line-116>
<line-117> else:</line-117>
<line-118> k3,k4 = aa(l2,l1,n)</line-118>
<line-119> if ((k3,k4) == (-1,-1)):</line-119>
<line-120> print(1)</line-120>
<line-121> if (k2 == 10**20):</line-121>
<line-122> k2 = "Inf"</line-122>
<line-123> print(str(k1) + " " +str(k2))</line-123>
<line-124> else:</line-124>
<line-125> p = union((k1,k2),(k3,k4))</line-125>
<line-126> if (len(p)==2):</line-126>
<line-127> c1,c2 = p</line-127>
<line-128> if (c2==10**20):</line-128>
<line-129> c2 = "Inf"</line-129>
<line-130> print(1)</line-130>
<line-131> print(str(c1) + " " +str(c2))</line-131>
<line-132> else:</line-132>
<line-133> c1,c2,c3,c4 = p</line-133>
<line-134> if (c4 == 10**20):</line-134>
<line-135> c4 = "Inf"</line-135>
<line-136> print(2)</line-136>
<line-138> print(str(c3) + " " +str(c4))</line-138>
|
{"code": "<line-2> l1,l2 = [],[]</line-2>\n<line-137> print(str(c1) + \" \" +str(c2))</line-137>", "lines": [2, 137]}
#### 0
|
<line-1>for i in range(int(input())):</line-1>
<line-3> c=a.count('m')</line-3>
<line-4> d=a.count('s')</line-4>
<line-5> t=0</line-5>
<line-6> while t<len(a)-1:</line-6>
<line-7> if (a[t]=='m' and a[t+1]=='s') or (a[t]=='s' and a[t+1]=='m'):</line-7>
<line-8> d=d-1</line-8>
<line-9> t=t+2</line-9>
<line-10> else:</line-10>
<line-11> t=t+1</line-11>
<line-12> if c>d:</line-12>
<line-13> print('mongooses')</line-13>
<line-14> elif d>c:</line-14>
<line-15> print('snakes')</line-15>
<line-17> print('tie')</line-17>
|
{"code": "<line-2> a=input()</line-2>\n<line-16> else:</line-16>", "lines": [2, 16]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>def __starting_point():</line-4>
<line-5> start = 0</line-5>
<line-6> for line in sys.stdin:</line-6>
<line-7> if start == 0:</line-7>
<line-8> start = 1</line-8>
<line-9> continue</line-9>
<line-10> else:</line-10>
<line-11> try:</line-11>
<line-12> n = int(line.strip())</line-12>
<line-13> </line-13>
<line-14> # print n </line-14>
<line-15> </line-15>
<line-16> q = n/7</line-16>
<line-17> rem = n%7</line-17>
<line-18> </line-18>
<line-19> </line-19>
<line-20> if rem==0:</line-20>
<line-21> res = n</line-21>
<line-22> elif rem==1:</line-22>
<line-23> res = (q-1)*7</line-23>
<line-24> elif rem==2:</line-24>
<line-25> res = (q-2)*7 </line-25>
<line-26> elif rem==3:</line-26>
<line-27> res = (q-3)*7</line-27>
<line-28> elif rem==4:</line-28>
<line-29> res = q*7</line-29>
<line-30> elif rem==5:</line-30>
<line-31> res = (q-1)*7</line-31>
<line-32> elif rem==6:</line-32>
<line-33> res = (q-2)*7 </line-33>
<line-34> </line-34>
<line-35> if res < 0:</line-35>
<line-36> print(-1)</line-36>
<line-37> else:</line-37>
<line-38> print(res)</line-38>
<line-39> </line-39>
<line-40> except:</line-40>
<line-42> </line-42>
<line-43> </line-43>
<line-44> </line-44>
<line-45> </line-45>
<line-46>__starting_point()</line-46>
|
{"code": "<line-2>import os</line-2>\n<line-41> break</line-41>", "lines": [2, 41]}
#### 0
|
<line-1>T = int(input())</line-1>
<line-3> line1, line2 = input(), input()</line-3>
<line-4> seq = line2.split()</line-4>
<line-5> current_min = 1000001</line-5>
<line-6> current_max = 0</line-6>
<line-7> max_spread = 0</line-7>
<line-8> for i in range(0,len(seq)):</line-8>
<line-9> current_value = int(seq[i])</line-9>
<line-10> if current_min > current_value:</line-10>
<line-11> current_min = current_value</line-11>
<line-12> current_max = current_value</line-12>
<line-13> elif current_max < current_value:</line-13>
<line-14> current_max = current_value</line-14>
<line-15> if max_spread < (current_max - current_min):</line-15>
<line-16> max_spread = current_max - current_min </line-16>
<line-17> if max_spread > 0:</line-17>
<line-18> print(max_spread)</line-18>
<line-20> print("UNFIT")</line-20>
|
{"code": "<line-2>for j in range(0,T):</line-2>\n<line-19> else:</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>p,s = [int(i) for i in input().split()]</line-1>
<line-3></line-3>
<line-4>for j in range(1, p + 1):</line-4>
<line-5> sc = [int(i) for i in input().split()]</line-5>
<line-6> ns = [int(i) for i in input().split()]</line-6>
<line-7> nsc = dict(list(zip(sc,ns)))</line-7>
<line-8> ssc = sorted(sc)</line-8>
<line-9> score = 0</line-9>
<line-10> for a,b in zip(ssc[:-1], ssc[1:]):</line-10>
<line-11> if nsc[a] > nsc[b]:</line-11>
<line-12> score += 1</line-12>
<line-13> if score in list(scores.keys()) :</line-13>
<line-14> scores[score].append(j)</line-14>
<line-15> else :</line-15>
<line-16> scores[score] = [j]</line-16>
<line-17></line-17>
<line-18>total_scores = sorted(list(scores.keys()))</line-18>
<line-19>final_list = []</line-19>
<line-20>for val in total_scores :</line-20>
<line-21> final_list += sorted(scores[val])</line-21>
<line-22></line-22>
<line-24> print(val)</line-24>
|
{"code": "<line-2>scores = {}</line-2>\n<line-23>for val in final_list :</line-23>", "lines": [2, 23]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3> 'april':30,'may':31,'june':30,'july':31,</line-3>
<line-4> 'august':31,'september':30,'october':31,</line-4>
<line-5> 'november':30,'december':31}</line-5>
<line-6> </line-6>
<line-7>#l=[[15,'january'],[31,'august'],[10,'october']]</line-7>
<line-8>l2 = list(d.keys())</line-8>
<line-9>for _ in range(int(input())):</line-9>
<line-10> l=input().split()</line-10>
<line-11> l[0]=int(l[0])</line-11>
<line-12> a = l[1]</line-12>
<line-13> ind = l2.index(a)</line-13>
<line-14> b = 183 - (d[l[1]] - l[0])</line-14>
<line-15> while b!=0:</line-15>
<line-16> if ind!=11:</line-16>
<line-17> ind+=1</line-17>
<line-18> else:</line-18>
<line-19> ind = 0</line-19>
<line-20> if b<=d[l2[ind]]:</line-20>
<line-21> print(b,l2[ind])</line-21>
<line-23> b-=d[l2[ind]]</line-23>
|
{"code": "<line-2>d = {'january':31,'february':29,'march':31,</line-2>\n<line-22> break</line-22>", "lines": [2, 22]}
#### 0
|
<line-1>import sys</line-1>
<line-3></line-3>
<line-4>def main(arr,k):</line-4>
<line-5> </line-5>
<line-6> ans=0</line-6>
<line-7> for i in range(len(arr)):</line-7>
<line-8> curr_min=float('inf')</line-8>
<line-9> for j in range(i,len(arr)):</line-9>
<line-10> curr_min=min(curr_min,arr[j])</line-10>
<line-11> </line-11>
<line-12> if curr_min==k:</line-12>
<line-13> ans+=1 </line-13>
<line-14> return ans</line-14>
<line-15> </line-15>
<line-16></line-16>
<line-17>n=int(input())</line-17>
<line-18>arr=list(map(int,input().split()))</line-18>
<line-19></line-19>
<line-20></line-20>
<line-22> </line-22>
<line-23> print(main(arr,int(input())))</line-23>
|
{"code": "<line-2>import math</line-2>\n<line-21>for i in range(int(input())):</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>s = input().lower()</line-1>
<line-3>ans = ""</line-3>
<line-4>for ch in s:</line-4>
<line-5> if ch in vow:</line-5>
<line-6> continue</line-6>
<line-7> if ch.isalpha():</line-7>
<line-9>print(ans)</line-9>
|
{"code": "<line-2>vow = [\"a\", \"e\", \"i\", \"o\", \"u\", \"y\"]</line-2>\n<line-8> ans += \".\" + ch</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>import sys</line-1>
<line-3> d,inp,mp,n,q=set(),list(map(ord,list(sys.stdin.readline().strip()))),[x=='b' for x in list(sys.stdin.readline().strip())],eval(input()),ord('a')</line-3>
<line-4> inps = [inp[i:] for i in range(len(inp))]</line-4>
<line-5> inps.sort()</line-5>
<line-6> op,prev= 0,''</line-6>
<line-7> for ip in inps:</line-7>
<line-8> i,ct=0,0</line-8>
<line-9> while i < min(len(ip),len(prev)):</line-9>
<line-10> if prev[i] != ip[i]:</line-10>
<line-11> break</line-11>
<line-12> if mp[ip[i]-q]:</line-12>
<line-13> ct = ct+ 1</line-13>
<line-14> i = i+1</line-14>
<line-15> while i < len(ip):</line-15>
<line-16> if mp[ip[i]-q]:</line-16>
<line-17> ct = ct + 1</line-17>
<line-18> if ct > n:</line-18>
<line-19> break</line-19>
<line-20> op,i= op+1,i+1</line-20>
<line-22> print(op)</line-22>
|
{"code": "<line-2>for _ in range(0,eval(input())): </line-2>\n<line-21> \tprev = ip</line-21>", "lines": [2, 21]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4> if k==0:</line-4>
<line-5> k = 1</line-5>
<line-6> x = 0</line-6>
<line-7> for i in range(2,n+1):</line-7>
<line-8> x = (x+k)%i</line-8>
<line-9> return x</line-9>
<line-10></line-10>
<line-11>FLAMES = ['FRIENDS', 'LOVE', 'ADORE', 'MARRIAGE', 'ENEMIES', 'SISTER']</line-11>
<line-12></line-12>
<line-13>nCase = int(sys.stdin.readline())</line-13>
<line-14>for _ in range(nCase):</line-14>
<line-15> a = ''.join(sys.stdin.readline().split())</line-15>
<line-16> b = ''.join(sys.stdin.readline().split())</line-16>
<line-17> n = 0</line-17>
<line-18> for ch in set(a+b):</line-18>
<line-20> print(FLAMES[joseph(n)])</line-20>
|
{"code": "<line-3>def joseph(k, n=6):</line-3>\n<line-19>\t\tn += abs(a.count(ch)-b.count(ch))</line-19>", "lines": [3, 19]}
#### 0
|
<line-1>t=int(input())</line-1>
<line-3> n,k=map(int,input().split())</line-3>
<line-4> a1,*a=map(int,input().split())</line-4>
<line-5> a.insert(0,a1)</line-5>
<line-6> j=0</line-6>
<line-7> while j<n:</line-7>
<line-8> if a[j]%k==0:</line-8>
<line-9> print(1,end="")</line-9>
<line-10> else:</line-10>
<line-11> print(0,end="")</line-11>
<line-13> print("")</line-13>
|
{"code": "<line-2>for i in range(0,t):</line-2>\n<line-12> j+=1</line-12>", "lines": [2, 12]}
#### 0
|
<line-1>import numpy as np</line-1>
<line-3>i8 = np.int64</line-3>
<line-4></line-4>
<line-5></line-5>
<line-6>@njit</line-6>
<line-7>def solve(a, b, t, K, N):</line-7>
<line-8> t1 = t // K</line-8>
<line-9> d = t % K * 2</line-9>
<line-10> # b が a から a + d の位置にあれば衝突する</line-10>
<line-11> x = 0</line-11>
<line-12> y = 0</line-12>
<line-13> ans = 0</line-13>
<line-14> for c in a:</line-14>
<line-15> while b[x] < c:</line-15>
<line-16> x += 1</line-16>
<line-17> while b[y] <= c + d:</line-17>
<line-18> y += 1</line-18>
<line-19> ans += y - x</line-19>
<line-20> ans += t1 * len(a) * (N - len(a)) * 2</line-20>
<line-21> return ans</line-21>
<line-22></line-22>
<line-23></line-23>
<line-24>def set_ini(DX, K):</line-24>
<line-25> a = DX[1][DX[0] == 1]</line-25>
<line-26> a = np.sort(a)</line-26>
<line-27> b = DX[1][DX[0] == 2]</line-27>
<line-28> b = np.sort(b)</line-28>
<line-29> b = np.hstack((b, b + K, b + 2 * K, [3 * K]))</line-29>
<line-30> return a, b</line-30>
<line-31></line-31>
<line-32></line-32>
<line-33>def main():</line-33>
<line-34> f = open('/dev/stdin', 'rb')</line-34>
<line-35> vin = np.fromstring(f.read(), i8, sep=' ')</line-35>
<line-36> N, Q, K = vin[0:3]</line-36>
<line-37> head = 3</line-37>
<line-38> DX = vin[head:head + 2*N].reshape(-1, 2).T</line-38>
<line-39> a, b = set_ini(DX, K)</line-39>
<line-40> head += 2 * N</line-40>
<line-41> T = vin[head: head + Q]</line-41>
<line-42> for t in T:</line-42>
<line-43> print(solve(a, b, t, K, N))</line-43>
<line-44></line-44>
<line-45></line-45>
<line-46>def __starting_point():</line-46>
<line-48>__starting_point()</line-48>
|
{"code": "<line-2>from numba import njit</line-2>\n<line-47> main()</line-47>", "lines": [2, 47]}
#### 0
|
<line-1>from math import factorial</line-1>
<line-3> if r<0:return 0</line-3>
<line-4> return factorial(n)/(factorial(n-r)*factorial(r))</line-4>
<line-5>def solve(m,n):</line-5>
<line-6> modulo=10**9+7</line-6>
<line-7> if m==n:</line-7>
<line-8> return (Ncr(2*n-1,n-1)+Ncr(2*n-2,n-2))%modulo</line-8>
<line-9> elif m>n:</line-9>
<line-10> return (Ncr(m+n,n)-Ncr(m+n-2,n-1))%modulo</line-10>
<line-11> else:</line-11>
<line-12> return (Ncr(m+n,m)-Ncr(m+n-2,m-1))%modulo</line-12>
<line-13> </line-13>
<line-14>t=int(input())</line-14>
<line-15>for i in range(t):</line-15>
<line-16> inp=list(map(int,input()))</line-16>
<line-17> m=inp.count(4)</line-17>
<line-19> print(solve(m,n))</line-19>
|
{"code": "<line-2>def Ncr(n,r):</line-2>\n<line-18> n=inp.count(7)</line-18>", "lines": [2, 18]}
#### 0
|
<line-1>import itertools</line-1>
<line-3>def sumPairs(arr, n):</line-3>
<line-4> s = 0</line-4>
<line-5> for i in range(n-1,-1,-1): </line-5>
<line-6> s += i*arr[i]-(n-1-i)*arr[i]</line-6>
<line-7> return s</line-7>
<line-8></line-8>
<line-9>def subarrayXor(arr, n, m):</line-9>
<line-10> ans = 0</line-10>
<line-11> xorArr =[0 for _ in range(n)]</line-11>
<line-12> mp = dfd(list)</line-12>
<line-13> xorArr[0] = arr[0]</line-13>
<line-14> for i in range(1, n): </line-14>
<line-15> xorArr[i] = xorArr[i - 1] ^ arr[i]</line-15>
<line-16> for i in range(n):</line-16>
<line-17> mp[xorArr[i]].append(i)</line-17>
<line-18> a = sorted(mp.items())</line-18>
<line-19> #print(xorArr)</line-19>
<line-20> #print(a)</line-20>
<line-21> for i in a:</line-21>
<line-22> diffs=0</line-22>
<line-23> if(i[0]!=0):</line-23>
<line-24> l = len(i[1])-1</line-24>
<line-25> ans += sumPairs(i[1],len(i[1]))-((l*(l+1))//2)</line-25>
<line-26> </line-26>
<line-27> else:</line-27>
<line-28> l = len(i[1])-1</line-28>
<line-29> ans += sumPairs(i[1],len(i[1]))-((l*(l+1))//2)</line-29>
<line-30> ans += sum(i[1])</line-30>
<line-31> return ans</line-31>
<line-32></line-32>
<line-33>for _ in range(int(input())):</line-33>
<line-34> n = int(input())</line-34>
<line-36> print(subarrayXor(arr,len(arr),0))</line-36>
|
{"code": "<line-2>from collections import defaultdict as dfd</line-2>\n<line-35> arr = list(map(int,input().split()))</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>from math import *</line-1>
<line-3>for _ in range(t):</line-3>
<line-4> n = int(input())</line-4>
<line-5> a = [int(d) for d in input().split()]</line-5>
<line-6> odd,even = 0,0</line-6>
<line-7> for i in range(n):</line-7>
<line-8> if bin(a[i]).count("1")%2 == 1:</line-8>
<line-9> odd += 1</line-9>
<line-10> else:</line-10>
<line-11> even +=1</line-11>
<line-12> total = 0</line-12>
<line-13> if odd >= 3 and even >= 2:</line-13>
<line-14> total += (odd*(odd-1)*(odd-2))//6</line-14>
<line-15> total += odd*(even*(even-1))//2</line-15>
<line-16> elif odd >= 3 and even < 2:</line-16>
<line-17> total += (odd*(odd-1)*(odd-2))//6</line-17>
<line-18> elif 0<odd < 3 and even >= 2:</line-18>
<line-20> </line-20>
<line-21> print(total%(10**9+7))</line-21>
|
{"code": "<line-2>t = int(input())</line-2>\n<line-19> total += odd*(even*(even-1))//2</line-19>", "lines": [2, 19]}
#### 0
|
<line-1>import math</line-1>
<line-2></line-2>
<line-4> return (a*b)//gcd(a, b)</line-4>
<line-5></line-5>
<line-6>def gcd(a, b):</line-6>
<line-7> if b == 0:</line-7>
<line-8> return a</line-8>
<line-9> return gcd(b, a%b) </line-9>
<line-10> </line-10>
<line-11>for _ in range(int(input())):</line-11>
<line-12> n = int(input())</line-12>
<line-13></line-13>
<line-14> na = math.ceil((2*n)/math.acos(-1))</line-14>
<line-15> nb = ((n+1)//2)**2</line-15>
<line-16></line-16>
<line-17> nlcm = lcm(na, nb)</line-17>
<line-18></line-18>
<line-19> oa = math.ceil(n/2)</line-19>
<line-20> ob = (n//2)*(n//2+1)</line-20>
<line-21></line-21>
<line-22> olcm = lcm(oa, ob)</line-22>
<line-23></line-23>
<line-24> if olcm > nlcm:</line-24>
<line-25> print("Nova's gonna kill me")</line-25>
<line-26> else:</line-26>
<line-28></line-28>
<line-29># cook your dish here</line-29>
|
{"code": "<line-3>def lcm(a, b):</line-3>\n<line-27> print(\"YESS(sunglass emo)\")</line-27>", "lines": [3, 27]}
#### 0
|
<line-1>for _ in range(int(input())):</line-1>
<line-3> if len(s)<4:</line-3>
<line-4> print("NO")</line-4>
<line-5> else:</line-5>
<line-6> if s[-4:]=="1000":</line-6>
<line-7> print("YES")</line-7>
<line-9> print("NO")</line-9>
|
{"code": "<line-2> s=input()</line-2>\n<line-8> else:</line-8>", "lines": [2, 8]}
#### 0
|
<line-1>def nCr(n,k):</line-1>
<line-3> k=min(k,n-k)</line-3>
<line-4> num,den=1,1</line-4>
<line-5> for i in range(k):</line-5>
<line-6> num*=(n-i)</line-6>
<line-7> den*=(i+1)</line-7>
<line-8> return num/den</line-8>
<line-9></line-9>
<line-10>def Main():</line-10>
<line-11> for cases in range(int(input())):</line-11>
<line-12> a,b=[int(x) for x in input().split()]</line-12>
<line-14></line-14>
<line-15>Main()</line-15>
|
{"code": "<line-2> if(k>n):return 0</line-2>\n<line-13> print(nCr(a,b))</line-13>", "lines": [2, 13]}
#### 0
|
<line-1>test=int(input())</line-1>
<line-3> n=int(input())</line-3>
<line-4> ls=list(map(int,input().split()))</line-4>
<line-5> ls.sort()</line-5>
<line-6> s=0</line-6>
<line-7> for i in range(n):</line-7>
<line-8> if s>=ls[i]:</line-8>
<line-9> s=s+1</line-9>
<line-10> else:</line-10>
<line-12> print(s)</line-12>
|
{"code": "<line-2>for _ in range(test):</line-2>\n<line-11> break</line-11>", "lines": [2, 11]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for _ in range(int(input())):</line-3>
<line-4> n=int(input())</line-4>
<line-5> sum=(n*(n+1))//2</line-5>
<line-6> #print(sum)</line-6>
<line-7> if(sum%2!=0):</line-7>
<line-8> print(0)</line-8>
<line-9> continue</line-9>
<line-10> m=(int((sqrt(1+4*(sum)))-1)//2)</line-10>
<line-11> if(m*(m+1)//2==sum//2):</line-11>
<line-12> print((((m-1)*m)//2)+n-m+((n-m-1)*(n-m))//2)</line-12>
<line-14> print(n-m)</line-14>
|
{"code": "<line-2>from math import sqrt</line-2>\n<line-13> else:</line-13>", "lines": [2, 13]}
#### 0
|
<line-1># cook your dish here</line-1>
<line-3>for i in range(t):</line-3>
<line-4> a=0</line-4>
<line-5> b=0</line-5>
<line-6> N,K,x,y=map(int,input().split())</line-6>
<line-7> if x==y:</line-7>
<line-8> a=N</line-8>
<line-9> b=N</line-9>
<line-10> elif x>y:</line-10>
<line-11> if K%4==1:</line-11>
<line-12> a=N </line-12>
<line-13> b=y-x+N</line-13>
<line-14> elif K%4==2:</line-14>
<line-15> a=y-x+N</line-15>
<line-16> b=N</line-16>
<line-17> elif K%4==3:</line-17>
<line-18> a=0</line-18>
<line-19> b=x-y</line-19>
<line-20> else:</line-20>
<line-21> a=x-y</line-21>
<line-22> b=0</line-22>
<line-23> else:</line-23>
<line-24> if K%4==1:</line-24>
<line-25> a=x-y+N </line-25>
<line-26> b=N</line-26>
<line-27> elif K%4==2:</line-27>
<line-28> a=N</line-28>
<line-29> b=x-y+N</line-29>
<line-30> elif K%4==3:</line-30>
<line-31> a=y-x</line-31>
<line-32> b=0</line-32>
<line-33> else:</line-33>
<line-34> a=0</line-34>
<line-36> print(a,b)</line-36>
|
{"code": "<line-2>t=int(input())</line-2>\n<line-35> b=y-x</line-35>", "lines": [2, 35]}
#### 0
|
<line-1>import sys,io,os,math</line-1>
<line-3>from itertools import permutations</line-3>
<line-4>mod=1000000007</line-4>
<line-5>mod1=998244353</line-5>
<line-6>def printlist(n):</line-6>
<line-7> sys.stdout.write(" ".join(map(str,n)) + "\n")</line-7>
<line-8>printf=lambda n:sys.stdout.write(str(n)+"\n")</line-8>
<line-9>def printns(n):</line-9>
<line-10> sys.stdout.write(str(n)) </line-10>
<line-11>def intinp():</line-11>
<line-12> return int(sys.stdin.readline())</line-12>
<line-13>def strinp():</line-13>
<line-14> return sys.stdin.readline()</line-14>
<line-15>def arrinp():</line-15>
<line-16> return list(map(int,sys.stdin.readline().strip().split()))</line-16>
<line-17>def mulinp():</line-17>
<line-18> return list(map(int,sys.stdin.readline().strip().split()))</line-18>
<line-19>def flush():</line-19>
<line-20> return sys.stdout.flush()</line-20>
<line-21>def power_two(x):</line-21>
<line-22> return (1<<x)</line-22>
<line-23>def lcm(a,b):</line-23>
<line-24> return a*b//gcd(a,b) </line-24>
<line-25>def solve():</line-25>
<line-26> n=intinp()</line-26>
<line-27> ans=str(n)</line-27>
<line-28> count=0</line-28>
<line-29> for i in ans:</line-29>
<line-30> count+=int(i)</line-30>
<line-31> if(n%count==0):</line-31>
<line-32> print('Yes')</line-32>
<line-33> return 0</line-33>
<line-34> print('No')</line-34>
<line-35></line-35>
<line-36></line-36>
<line-37>def main():</line-37>
<line-38> tc=intinp()</line-38>
<line-39> while(tc):</line-39>
<line-40> solve()</line-40>
<line-42> </line-42>
<line-43>main()</line-43>
<line-44></line-44>
|
{"code": "<line-2>from math import ceil,log,gcd,inf</line-2>\n<line-41> tc-=1\t</line-41>", "lines": [2, 41]}
#### 0
|
<line-1></line-1>
<line-2>def interesting_nums(m):</line-2>
<line-4> for x in range(m + 1, 2 * m + 1):</line-4>
<line-5> if x * m % (x - m) == 0:</line-5>
<line-6> nums.append(x)</line-6>
<line-7></line-7>
<line-8> return nums</line-8>
<line-9></line-9>
<line-10></line-10>
<line-11>def main():</line-11>
<line-12></line-12>
<line-13> T = int(input())</line-13>
<line-14></line-14>
<line-15> for _ in range(T):</line-15>
<line-16> num_list = interesting_nums(int(input()))</line-16>
<line-17> print(len(num_list))</line-17>
<line-18></line-18>
<line-19> for num in num_list:</line-19>
<line-21></line-21>
<line-22></line-22>
<line-23>main()</line-23>
|
{"code": "<line-3> nums = []</line-3>\n<line-20> print(num)</line-20>", "lines": [3, 20]}
#### 0
|
<line-1>for __ in range(eval(input())):</line-1>
<line-3> a = list(map(int,input().split()))</line-3>
<line-4> key = eval(input())</line-4>
<line-5> query = eval(input())</line-5>
<line-6> maxvisited = x #maximum visted value</line-6>
<line-7> j = x-1</line-7>
<line-8> ans = []</line-8>
<line-9> val = 0</line-9>
<line-10> while j>=0:</line-10>
<line-11> if a[j]==key:</line-11>
<line-12> ans.append(val+1)</line-12>
<line-13> val = val +1</line-13>
<line-14> else: ans.append(val)</line-14>
<line-15> j-=1</line-15>
<line-16> ans.reverse()</line-16>
<line-17> #print ans</line-17>
<line-18> for ii in range(query):</line-18>
<line-19> W = eval(input())</line-19>
<line-20> print(ans[W], end=' ')</line-20>
<line-21> print(x-W, end=' ')</line-21>
<line-22> #print maxvisited, W</line-22>
<line-23> if maxvisited>W:</line-23>
<line-24> print(maxvisited-W+1)</line-24>
<line-26> else: print('1')</line-26>
|
{"code": "<line-2> x = eval(input())</line-2>\n<line-25> maxvisited = W</line-25>", "lines": [2, 25]}
#### 0
|
<line-1>from itertools import permutations</line-1>
<line-3>V = list(permutations([3,6,9,12]))</line-3>
<line-4>P = list(permutations([25,50,75,100]))</line-4>
<line-5>R = []</line-5>
<line-6></line-6>
<line-7>def test():</line-7>
<line-8> d = {}</line-8>
<line-9> n = int(input())</line-9>
<line-10> for i in C[0]:</line-10>
<line-11> for j in V[0]:</line-11>
<line-12> d[i+str(j)] = 0</line-12>
<line-13> for i in range(n):</line-13>
<line-14> x,y = input().split()</line-14>
<line-15> d[x+y] += 1</line-15>
<line-16> ans = -1000000000</line-16>
<line-17> for i in C:</line-17>
<line-18> for j in V:</line-18>
<line-19> for k in P:</line-19>
<line-20> c = 0</line-20>
<line-21> for l in range(4): </line-21>
<line-22> if d[i[l]+str(j[l])] == 0:</line-22>
<line-23> c -= 100</line-23>
<line-24> else:</line-24>
<line-25> c += (d[i[l]+str(j[l])]*k[l])</line-25>
<line-26> ans = max(ans,c)</line-26>
<line-27> R.append(ans)</line-27>
<line-28> print(ans)</line-28>
<line-29></line-29>
<line-30>def __starting_point():</line-30>
<line-31> t = int(input())</line-31>
<line-32> for i in range(t):</line-32>
<line-33> test()</line-33>
<line-35></line-35>
<line-36>__starting_point()</line-36>
|
{"code": "<line-2>C = list(permutations(['A','B','C','D']))</line-2>\n<line-34> print(sum(R))</line-34>", "lines": [2, 34]}
#### 0
|
<line-1>import sys</line-1>
<line-2></line-2>
<line-4>T=int(rl())</line-4>
<line-5>for t in range(T):</line-5>
<line-6> P=int(rl())</line-6>
<line-7> T=(P+1)//2</line-7>
<line-8> F=list(map(int,rl().split()))[1:]</line-8>
<line-9> numtorn=int(rl())</line-9>
<line-10> t=sum(range(1,P+1))-sum(F)</line-10>
<line-12> print('%.4f' % (t*K/float(T)))</line-12>
<line-13> </line-13>
|
{"code": "<line-3>rl=sys.stdin.readline</line-3>\n<line-11> K=T-numtorn</line-11>", "lines": [3, 11]}
#### 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.