Input:
import math,string,itertools,math,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)

inf = 10**20

eps = 1.0 / 10**15

mod = 10**9+7

def LI(): return [int(x) for x in sys.stdin.readline().split()]

def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]

def LF(): return [float(x) for x in sys.stdin.readline().split()]

def LS(): return sys.stdin.readline().split()

def I(): return int(sys.stdin.readline())

def F(): return float(sys.stdin.readline())

def S(): return input()

def pf(s): return print(s, flush=True)

def divisions(n):

    sq = int(math.sqrt(n)+1)

    d = collections.defaultdict(int)

    while n % 2 == 0:

        n //= 2

        d[2] += 1

    i = 3

    while n > 1 and sq >= i:

        if n % i == 0:

            n //= i

            d[i] += 1

        else:

            i += 2

    if n > 1:

        d[n] += 1

    r = [1]

    for k, v in d.items():

        for c in r[:]:

            for i in range(1,v+1):

                r.append(c*(k**i))

    return sorted(r)

def main():

    n = I()

    a = LI()

    s = set()

    for i in range(n,0,-1):

        d = divisions(i)

        ld = len(d)

        for j in range(1,2**ld):

            c = []

            ff = True

            for k in range(ld):

                if j & (1<<k):

                    f = True

                    for e in c:

                        if d[k] % e == 0:

                            f = False

                            ff = False

                            break

                    if f:

                        c.append(d[k])

                if not ff:

                    break

            if ff:

                s.add(tuple(c + [n+1]))

    b = sorted(list(s), reverse=True)

    for c in b:

        t = 0

        for j in range(1,n+1):

            f = False

            for e in c:

                if j%e == 0:

                    f = True

                    break

            if f:

                t += a[j-1]

        if t < 0:

            for j in range(1,n+1):

                f = False

                for e in c:

                    if j%e == 0:

                        f = True

                        break

                if f:

                    a[j-1] = 0

    return sum(a)

print(main())

import Ġmath ,string ,it ertools , math , heap q ,c ollections ,re ,array ,b is ect , sys , random ,time ,copy , fun ct ools ĊĊĊĊ sys .set rec ursion limit ( 1 0 ** 7 )ĊĊ inf Ġ= Ġ 1 0 ** 2 0 ĊĊ eps Ġ= Ġ 1 . 0 Ġ/ Ġ 1 0 ** 1 5 ĊĊ mod Ġ= Ġ 1 0 ** 9 + 7 ĊĊĊĊ def ĠLI (): Ġreturn Ġ[ int (x ) Ġfor Ġx Ġin Ġsys .stdin .readline (). split ()]ĊĊ def ĠLI _ (): Ġreturn Ġ[ int (x )- 1 Ġfor Ġx Ġin Ġsys .stdin .readline (). split ()]ĊĊ def ĠLF (): Ġreturn Ġ[ float (x ) Ġfor Ġx Ġin Ġsys .stdin .readline (). split ()]ĊĊ def ĠLS (): Ġreturn Ġsys .stdin .readline (). split ()ĊĊ def ĠI (): Ġreturn Ġint (sys .stdin .readline ())ĊĊ def ĠF (): Ġreturn Ġfloat (sys .stdin .readline ())ĊĊ def ĠS (): Ġreturn Ġinput ()ĊĊ def Ġpf (s ): Ġreturn Ġprint (s , Ġflush =True )ĊĊ def Ġdivisions (n ):ĊĊ ĠĠĠ Ġsq Ġ= Ġint (math .sqrt (n )+ 1 )ĊĊ ĠĠĠ Ġd Ġ= Ġcollections .default dict (int )ĊĊ ĠĠĠ Ġwhile Ġn Ġ% Ġ 2 Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġn Ġ//= Ġ 2 ĊĊ ĠĠĠĠĠĠĠ Ġd [ 2 ] Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġi Ġ= Ġ 3 ĊĊ ĠĠĠ Ġwhile Ġn Ġ> Ġ 1 Ġand Ġsq Ġ>= Ġi :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġn Ġ% Ġi Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġn Ġ//= Ġi ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġd [i ] Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġi Ġ+= Ġ 2 ĊĊĊĊ ĠĠĠ Ġif Ġn Ġ> Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġd [n ] Ġ+= Ġ 1 ĊĊĊĊ ĠĠĠ Ġr Ġ= Ġ[ 1 ]ĊĊ ĠĠĠ Ġfor Ġk , Ġv Ġin Ġd .items ():ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġc Ġin Ġr [: ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange ( 1 ,v + 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġr .append (c *( k ** i )) ĊĊĊĊ ĠĠĠ Ġreturn Ġsorted (r )ĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġn Ġ= ĠI ()ĊĊ ĠĠĠ Ġa Ġ= ĠLI ()ĊĊ ĠĠĠ Ġs Ġ= Ġset ()ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n , 0 ,- 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġd Ġ= Ġdivisions (i )ĊĊ ĠĠĠĠĠĠĠ Ġld Ġ= Ġlen (d )ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange ( 1 , 2 ** ld ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġc Ġ= Ġ[]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġff Ġ= ĠTrue ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġk Ġin Ġrange (ld ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġj Ġ& Ġ( 1 << k ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġf Ġ= ĠTrue ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġe Ġin Ġc :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġd [k ] Ġ% Ġe Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġf Ġ= ĠFalse ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġff Ġ= ĠFalse ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġf :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġc .append (d [k ])ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġnot Ġff :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġff :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġs .add (tuple (c Ġ+ Ġ[ n + 1 ]))ĊĊ ĠĠĠ Ġb Ġ= Ġsorted (list (s ), Ġreverse =True )ĊĊ ĠĠĠ Ġfor Ġc Ġin Ġb :ĊĊ ĠĠĠĠĠĠĠ Ġt Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange ( 1 ,n + 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġf Ġ= ĠFalse ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġe Ġin Ġc :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġj % e Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġf Ġ= ĠTrue ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġf :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġt Ġ+= Ġa [j - 1 ]ĊĊ ĠĠĠĠĠĠĠ Ġif Ġt Ġ< Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange ( 1 ,n + 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġf Ġ= ĠFalse ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġe Ġin Ġc :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġj % e Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġf Ġ= ĠTrue ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġf :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġa [j - 1 ] Ġ= Ġ 0 ĊĊĊĊ ĠĠĠ Ġreturn Ġsum (a )ĊĊĊĊĊĊĊĊ print (main ())ĊĊ ĊĊĊ


Input:
N = int(input())

ans = N - 1

p = 1

for i in range(2, int((N ** 0.5) + 1)):

    if p % 2 == 1 and i > (N ** 0.5):

        break

    if N % i == 0:

        p = i

        j = N // i

        m = i + j - 2

        if m < ans:

            ans = m

        else:

            continue

    else:

        continue

print(ans)

N Ġ= Ġint (input ())ĊĊ ans Ġ= ĠN Ġ- Ġ 1 ĊĊ p Ġ= Ġ 1 ĊĊ for Ġi Ġin Ġrange ( 2 , Ġint (( N Ġ** Ġ 0 . 5 ) Ġ+ Ġ 1 )) :ĊĊ ĠĠĠ Ġif Ġp Ġ% Ġ 2 Ġ== Ġ 1 Ġand Ġi Ġ> Ġ( N Ġ** Ġ 0 . 5 ):ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġif ĠN Ġ% Ġi Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġp Ġ= Ġi ĊĊ ĠĠĠĠĠĠĠ Ġj Ġ= ĠN Ġ// Ġi ĊĊ ĠĠĠĠĠĠĠ Ġm Ġ= Ġi Ġ+ Ġj Ġ- Ġ 2 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġm Ġ< Ġans :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ= Ġm ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġcontinue ĊĊ print (ans )Ċ


Input:
import sys

import heapq

# \n

def input():

    return sys.stdin.readline().rstrip()

def main():

    X, Y, Z, K = list(map(int, input().split()))

    A = list(map(int, input().split()))

    B = list(map(int, input().split()))

    C = list(map(int, input().split()))

    A.sort(reverse=True)

    B.sort(reverse=True)

    C.sort(reverse=True)

    Q = []

    S = set()

    heapq.heapify(Q)

    heapq.heappush(Q, (-A[0] - B[0] - C[0], 0, 0, 0))

    for i in range(K):

        m, a, b, c = heapq.heappop(Q)

        print((-m))

        if (a + 1, b, c) not in S and a + 1 < X:

            heapq.heappush(Q, (-A[a + 1] - B[b] - C[c], a + 1, b, c))

            S.add((a + 1, b, c))

        if (a, b + 1, c) not in S and b + 1 < Y:

            heapq.heappush(Q, (-A[a] - B[b + 1] - C[c], a, b + 1, c))

            S.add((a, b + 1, c))

        if (a, b, c + 1) not in S and c + 1 < Z:

            heapq.heappush(Q, (-A[a ] - B[b] - C[c+1], a, b, c + 1))

            S.add((a, b, c + 1))

if __name__ == "__main__":

    main()

import Ġsys ĊĊ import Ġheapq ĊĊĊĊĊĊ # Ġ\ n ĊĊ def Ġinput ():ĊĊ ĠĠĠ Ġreturn Ġsys .stdin .readline (). rstrip () ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ ĠX , ĠY , ĠZ , ĠK Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ ĠA Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ ĠB Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ ĠC Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ ĠĠĠ ĠA .sort (reverse =True )ĊĊ ĠĠĠ ĠB .sort (reverse =True )ĊĊ ĠĠĠ ĠC .sort (reverse =True )ĊĊĊĊ ĠĠĠ ĠQ Ġ= Ġ[]ĊĊ ĠĠĠ ĠS Ġ= Ġset ()ĊĊ ĠĠĠ Ġheapq .heap ify (Q )ĊĊ ĠĠĠ Ġheapq .he app ush (Q , Ġ(- A [ 0 ] Ġ- ĠB [ 0 ] Ġ- ĠC [ 0 ], Ġ 0 , Ġ 0 , Ġ 0 ))ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (K ):ĊĊ ĠĠĠĠĠĠĠ Ġm , Ġa , Ġb , Ġc Ġ= Ġheapq .he app op (Q )ĊĊ ĠĠĠĠĠĠĠ Ġprint ((- m ))ĊĊ ĠĠĠĠĠĠĠ Ġif Ġ( a Ġ+ Ġ 1 , Ġb , Ġc ) Ġnot Ġin ĠS Ġand Ġa Ġ+ Ġ 1 Ġ< ĠX :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġheapq .he app ush (Q , Ġ(- A [a Ġ+ Ġ 1 ] Ġ- ĠB [b ] Ġ- ĠC [c ], Ġa Ġ+ Ġ 1 , Ġb , Ġc ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠS .add (( a Ġ+ Ġ 1 , Ġb , Ġc ))ĊĊ ĠĠĠĠĠĠĠ Ġif Ġ( a , Ġb Ġ+ Ġ 1 , Ġc ) Ġnot Ġin ĠS Ġand Ġb Ġ+ Ġ 1 Ġ< ĠY :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġheapq .he app ush (Q , Ġ(- A [a ] Ġ- ĠB [b Ġ+ Ġ 1 ] Ġ- ĠC [c ], Ġa , Ġb Ġ+ Ġ 1 , Ġc ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠS .add (( a , Ġb Ġ+ Ġ 1 , Ġc ))ĊĊ ĠĠĠĠĠĠĠ Ġif Ġ( a , Ġb , Ġc Ġ+ Ġ 1 ) Ġnot Ġin ĠS Ġand Ġc Ġ+ Ġ 1 Ġ< ĠZ :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġheapq .he app ush (Q , Ġ(- A [a Ġ] Ġ- ĠB [b ] Ġ- ĠC [c + 1 ], Ġa , Ġb , Ġc Ġ+ Ġ 1 ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠS .add (( a , Ġb , Ġc Ġ+ Ġ 1 )) ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
def two_count(x):

	if int(str(x)[-1]) % 2 == 0:

		return 1 + two_count(x//2)

	else:

		return 0

n = int(input())

n_list = [int(n) for n in input().split(" ")]

n_two_count_list = [two_count(n) for n in n_list]

print((min(n_two_count_list)))

def Ġtwo _count (x ):ĊĊ ĉif Ġint (str (x )[- 1 ]) Ġ% Ġ 2 Ġ== Ġ 0 :ĊĊ ĉ ĉreturn Ġ 1 Ġ+ Ġtwo _count (x // 2 )ĊĊ ĉelse :ĊĊ ĉ ĉreturn Ġ 0 ĊĊĊĊ n Ġ= Ġint (input ())ĊĊ n _list Ġ= Ġ[ int (n ) Ġfor Ġn Ġin Ġinput (). split (" Ġ" )] ĊĊĊĊ n _two _count _list Ġ= Ġ[ two _count (n ) Ġfor Ġn Ġin Ġn _list ]ĊĊĊĊ print (( min (n _two _count _list )))


Input:
n=int(input())

a=[list(map(int,input().split()))for _ in range(n)]

def f():

 for i in range(n-1):

  d=a[i][:];d[3],d[4]=d[4],d[3]

  for j in range(i+1,n):

   e=a[j][:];e[3],e[4]=e[4],e[3]

   for p in('012345','152043','215304','302541','410352','514320'):

    f=[d[int(k)]for k in p]

    g=f[1:5]*2

    for k in range(4):

     if(g[k:k+4]==e[1:5])*(f[0]==e[0])*(f[5]==e[5]):return 'No'

 return 'Yes'

print((f()))

n =int (input ())ĊĊ a =[ list (map (int ,input (). split ())) for Ġ_ Ġin Ġrange (n )]ĊĊ def Ġf ():ĊĊ Ġfor Ġi Ġin Ġrange (n - 1 ):ĊĊ Ġ Ġd =a [i ][: ]; d [ 3 ], d [ 4 ]= d [ 4 ], d [ 3 ]ĊĊ Ġ Ġfor Ġj Ġin Ġrange (i + 1 ,n ):ĊĊ ĠĠ Ġe =a [j ][: ]; e [ 3 ], e [ 4 ]= e [ 4 ], e [ 3 ]ĊĊ ĠĠ Ġfor Ġp Ġin (' 0 1 2 3 4 5 ',' 1 5 2 0 4 3 ',' 2 1 5 3 0 4 ',' 3 0 2 5 4 1 ',' 4 1 0 3 5 2 ',' 5 1 4 3 2 0 ') :ĊĊ ĠĠĠ Ġf =[ d [int (k )] for Ġk Ġin Ġp ]ĊĊ ĠĠĠ Ġg =f [ 1 : 5 ]* 2 ĊĊ ĠĠĠ Ġfor Ġk Ġin Ġrange ( 4 ):ĊĊ ĠĠĠĠ Ġif (g [k :k + 4 ]== e [ 1 : 5 ]) *( f [ 0 ]== e [ 0 ]) *( f [ 5 ]== e [ 5 ]): return Ġ' No 'ĊĊ Ġreturn Ġ' Yes 'ĊĊ print (( f ()))Ċ


Input:
from math import gcd

n, m = list(map(int, input().split()))

a = [int(i) // 2 for i in input().split()]

x = 1

for i in range(n):

    x *= a[i] // gcd(x, a[i])

for i in a:

    if x // i % 2 == 0:

        print((0))

        exit()

print(((m // x + 1) // 2))

from Ġmath Ġimport Ġgcd ĊĊ n , Ġm Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ a Ġ= Ġ[ int (i ) Ġ// Ġ 2 Ġfor Ġi Ġin Ġinput (). split ()]ĊĊ x Ġ= Ġ 1 ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġx Ġ*= Ġa [i ] Ġ// Ġgcd (x , Ġa [i ])ĊĊ for Ġi Ġin Ġa :ĊĊ ĠĠĠ Ġif Ġx Ġ// Ġi Ġ% Ġ 2 Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (( 0 ))ĊĊ ĠĠĠĠĠĠĠ Ġexit ()ĊĊ print ((( m Ġ// Ġx Ġ+ Ġ 1 ) Ġ// Ġ 2 ))


Input:
import sys

input = lambda: sys.stdin.readline()[:-1]

n,m=list(map(int,input().split()))

a0=list(map(int,input().split()))

data=[list(map(int,input().split())) for i in range(m)]

for i in a0:

	data.append([1,i])

data.sort(key=lambda tup:-tup[1])

ans=0

for num,val in data:

	if n>=num:

		n-=num

		ans+=val*num

	else:

		ans+=val*n

		break

print(ans)

import Ġsys ĊĊ input Ġ= Ġlambda : Ġsys .stdin .readline () [:- 1 ]ĊĊ n ,m =list (map (int ,input (). split ()))ĊĊ a 0 =list (map (int ,input (). split ()))ĊĊ data =[ list (map (int ,input (). split ())) Ġfor Ġi Ġin Ġrange (m )]ĊĊ for Ġi Ġin Ġa 0 :ĊĊ ĉdata .append ([ 1 ,i ])ĊĊ data .sort (key =lambda Ġtup :- t up [ 1 ])ĊĊ ans = 0 ĊĊ for Ġnum ,val Ġin Ġdata :ĊĊ ĉif Ġn >= num :ĊĊ ĉ ĉn -= num ĊĊ ĉ ĉans += val *num ĊĊ ĉelse :ĊĊ ĉ ĉans += val *n ĊĊ ĉ ĉbreak ĊĊ print (ans )Ċ


Input:
import sys

sys.setrecursionlimit(10**6)

if sys.platform in (['ios','darwin','win32']):

	sys.stdin=open('Untitled.txt')

input = sys.stdin.readline

def INT(): return int(input())

def MAP(): return [int(s) for s in input().split()]

def main():

	S = input().rstrip()

	bcnt = 0

	A = []

	for i in range(len(S)):

		if S[i] == 'B': bcnt += 1

		if S[i] == 'W': A.append(bcnt)

	print((sum(A)))

if __name__ == '__main__':

	main()

import Ġsys ĊĊ sys .set rec ursion limit ( 1 0 ** 6 )ĊĊ if Ġsys .platform Ġin Ġ( [' ios ',' darwin ',' win 3 2 ']) :ĊĊ ĉsys .stdin =open (' Untitled .txt ')ĊĊ input Ġ= Ġsys .stdin .readline ĊĊ def ĠINT (): Ġreturn Ġint (input ())ĊĊ def ĠMAP (): Ġreturn Ġ[ int (s ) Ġfor Ġs Ġin Ġinput (). split ()] ĊĊĊĊ def Ġmain ():ĊĊ ĉS Ġ= Ġinput (). rstrip ()ĊĊ ĉb cnt Ġ= Ġ 0 ĊĊ ĉA Ġ= Ġ[]ĊĊ ĉfor Ġi Ġin Ġrange (len (S )) :ĊĊ ĉ ĉif ĠS [i ] Ġ== Ġ' B ': Ġb cnt Ġ+= Ġ 1 ĊĊ ĉ ĉif ĠS [i ] Ġ== Ġ' W ': ĠA .append (b cnt )ĊĊ ĉĊĊ ĉprint (( sum (A )) )ĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĉmain ()


Input:
a,b = list(map(int, input().split()))

n = 0

for i in range(a, b + 1):

    f = True

    s = str(i)

    l = len(s)

    for j in range(l//2 + 1):

        if s[j] != s[- j - 1]:

            f = False

            break

    if f:

        n += 1

print(n)

a ,b Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ n Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (a , Ġb Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġf Ġ= ĠTrue ĊĊ ĠĠĠ Ġs Ġ= Ġstr (i )ĊĊ ĠĠĠ Ġl Ġ= Ġlen (s )ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (l // 2 Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġs [j ] Ġ!= Ġs [- Ġj Ġ- Ġ 1 ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġf Ġ= ĠFalse ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġif Ġf :ĊĊ ĠĠĠĠĠĠĠ Ġn Ġ+= Ġ 1 ĊĊ print (n )


Input:
import sys

read = sys.stdin.read

readline = sys.stdin.readline

readlines = sys.stdin.readlines

sys.setrecursionlimit(10 ** 9)

INF = 1 << 60

def main():

    N, K, *A = list(map(int, read().split()))

    ans = INF

    for bit in range(1 << N):

        if (not (bit & 1)) or bin(bit).count('1') != K:

            continue

        total = 0

        max_height = A[0]

        for i, a in enumerate(A[1:], 1):

            if a <= max_height:

                if bit & (1 << i):

                    total += max_height - a + 1

                    max_height += 1

            else:

                max_height = a

        if ans > total:

            ans = total

    print(ans)

    return

if __name__ == '__main__':

    main()

import Ġsys ĊĊĊĊ read Ġ= Ġsys .stdin .read ĊĊ read line Ġ= Ġsys .stdin .readline ĊĊ read lines Ġ= Ġsys .stdin .readlines ĊĊ sys .set rec ursion limit ( 1 0 Ġ** Ġ 9 )ĊĊ INF Ġ= Ġ 1 Ġ<< Ġ 6 0 ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ ĠN , ĠK , Ġ* A Ġ= Ġlist (map (int , Ġread (). split ())) ĊĊĊĊ ĠĠĠ Ġans Ġ= ĠINF ĊĊ ĠĠĠ Ġfor Ġbit Ġin Ġrange ( 1 Ġ<< ĠN ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġ( not Ġ( bit Ġ& Ġ 1 )) Ġor Ġbin (bit ). count (' 1 ') Ġ!= ĠK :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcontinue ĊĊĊĊ ĠĠĠĠĠĠĠ Ġtotal Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġmax _height Ġ= ĠA [ 0 ]ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi , Ġa Ġin Ġenumerate (A [ 1 :], Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġa Ġ<= Ġmax _height :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġbit Ġ& Ġ( 1 Ġ<< Ġi ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġtotal Ġ+= Ġmax _height Ġ- Ġa Ġ+ Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġmax _height Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġmax _height Ġ= Ġa ĊĊĊĊ ĠĠĠĠĠĠĠ Ġif Ġans Ġ> Ġtotal :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ= Ġtotal ĊĊĊĊ ĠĠĠ Ġprint (ans )ĊĊĊĊ ĠĠĠ Ġreturn ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
import math

n = int(input())

cnt = 0

for i in range(1, n + 1):

    if math.floor(math.log10(i) + 1) % 2:

        cnt += 1

print(cnt)

import Ġmath ĊĊ n Ġ= Ġint (input ())ĊĊ cnt Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange ( 1 , Ġn Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġif Ġmath .floor (math .log 1 0 (i ) Ġ+ Ġ 1 ) Ġ% Ġ 2 :ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ print (cnt )


Input:
from collections import defaultdict

n = int(input())

d = defaultdict(int)

for _ in range(n):

    key = input()

    d[key] += 1

dict = sorted(list(d.items()), key=lambda x:x[1], reverse=True)

max_v = max(d.values())

dict_li = []

for a in dict:

    if a[1]==max_v:

        dict_li.append(a[0])

dict_li.sort()

for s in dict_li:

    print(s)

from Ġcollections Ġimport Ġdefaultdict ĊĊ n Ġ= Ġint (input ())ĊĊ ĊĊ d Ġ= Ġdefaultdict (int )ĊĊ for Ġ_ Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġkey Ġ= Ġinput ()ĊĊ ĠĠĠ Ġd [key ] Ġ+= Ġ 1 ĊĊĊĊ dict Ġ= Ġsorted (list (d .items ()), Ġkey =lambda Ġx :x [ 1 ], Ġreverse =True )ĊĊ max _v Ġ= Ġmax (d .values ())ĊĊ ĊĊ dict _li Ġ= Ġ[]ĊĊ for Ġa Ġin Ġdict :ĊĊ ĠĠĠ Ġif Ġa [ 1 ]== max _v :ĊĊ ĠĠĠĠĠĠĠ Ġdict _li .append (a [ 0 ])ĊĊ ĊĊ dict _li .sort ()ĊĊ for Ġs Ġin Ġdict _li :ĊĊ ĠĠĠ Ġprint (s )Ċ


Input:
n,k = list(map(int,input().split()))

l = [0]*(10**5+1)

for i in range(n):

    ai,bi = list(map(int,input().split()))

    l[ai]+=bi

for index,i in enumerate(l):

    if i:

        k-=i

        if k<=0:

            break

print(index)

n ,k Ġ= Ġlist (map (int ,input (). split ()))ĊĊ l Ġ= Ġ[ 0 ]*( 1 0 ** 5 + 1 )ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġai , bi Ġ= Ġlist (map (int ,input (). split ()))ĊĊ ĠĠĠ Ġl [ ai ]+= bi ĊĊ for Ġindex ,i Ġin Ġenumerate (l ):ĊĊ ĠĠĠ Ġif Ġi :ĊĊ ĠĠĠĠĠĠĠ Ġk -= i ĊĊ ĠĠĠĠĠĠĠ Ġif Ġk <= 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ print (index )


Input:
A, B = list(map(int, input().split()))

cnt = 0

for i in range(A, B+1):

    l = list(str(i))

    if l == list(reversed(l)):

        cnt += 1

print(cnt)

A , ĠB Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ cnt Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (A , ĠB + 1 ):ĊĊ ĠĠĠ Ġl Ġ= Ġlist (str (i )) ĊĊĊĊ ĠĠĠ Ġif Ġl Ġ== Ġlist (re versed (l )) :ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊĊĊ print (cnt )Ċ


Input:
n = int(input())

ary = list(map(int, input().split()))

#print(n,ary)

ary_2 = [ary[0]]

for i in range(1, n):

    ary_2.append(ary[i] + ary_2[i-1])

ary_2 = [0] + ary_2

#print(ary_2)

from collections import Counter

c = Counter(ary_2)

v = (list(c.values()))

#print(v)

from math import factorial

def combinations_count(n, r):

    return factorial(n) // (factorial(n - r) * factorial(r))

ans = 0

for j in v:

    if j >1:

        ans += combinations_count(j,2)

print(ans)

n Ġ= Ġint (input ())ĊĊ ary Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ #print (n , ary )ĊĊĊĊ ary _ 2 Ġ= Ġ[ ary [ 0 ]]ĊĊ for Ġi Ġin Ġrange ( 1 , Ġn ):ĊĊ ĠĠĠ Ġary _ 2 .append ( ary [i ] Ġ+ Ġary _ 2 [i - 1 ])ĊĊ ary _ 2 Ġ= Ġ[ 0 ] Ġ+ Ġary _ 2 ĊĊ #print ( ary _ 2 )ĊĊĊĊ from Ġcollections Ġimport ĠCounter ĊĊ c Ġ= ĠCounter ( ary _ 2 )ĊĊ v Ġ= Ġ( list (c .values ()))ĊĊ #print (v )ĊĊĊĊ from Ġmath Ġimport Ġfactorial ĊĊ def Ġcombinations _count (n , Ġr ):ĊĊ ĠĠĠ Ġreturn Ġfactorial (n ) Ġ// Ġ( factor ial (n Ġ- Ġr ) Ġ* Ġfactorial (r )) ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ for Ġj Ġin Ġv :ĊĊ ĠĠĠ Ġif Ġj Ġ> 1 :ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġcombinations _count (j , 2 )ĊĊĊĊ print (ans )


Input:
N = int(input())

mem = [[0]*10 for i in range(10)]

for i in range(1,N+1):

    a = int(str(i)[0])

    b = int(str(i)[-1])

    mem[a][b] += 1

ans = 0

for i in range(1,N+1):

    a = int(str(i)[0])

    b = int(str(i)[-1])

    ans += mem[b][a]

print(ans)

N Ġ= Ġint (input ())ĊĊ mem Ġ= Ġ[[ 0 ]* 1 0 Ġfor Ġi Ġin Ġrange ( 1 0 )] ĊĊĊĊ for Ġi Ġin Ġrange ( 1 ,N + 1 ):ĊĊ ĠĠĠ Ġa Ġ= Ġint (str (i )[ 0 ])ĊĊ ĠĠĠ Ġb Ġ= Ġint (str (i )[- 1 ])ĊĊ ĠĠĠ Ġmem [a ][ b ] Ġ+= Ġ 1 ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange ( 1 ,N + 1 ):ĊĊ ĠĠĠ Ġa Ġ= Ġint (str (i )[ 0 ])ĊĊ ĠĠĠ Ġb Ġ= Ġint (str (i )[- 1 ])ĊĊ ĠĠĠ Ġans Ġ+= Ġmem [b ][ a ]ĊĊ print (ans )


Input:
N = int(input())

p = 1

for i in range(N):

    p *= (i + 1)

    p %= (1e9 + 7)

print((int(p)))

N Ġ= Ġint (input ())ĊĊ p Ġ= Ġ 1 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġp Ġ*= Ġ( i Ġ+ Ġ 1 )ĊĊ ĠĠĠ Ġp Ġ%= Ġ( 1 e 9 Ġ+ Ġ 7 )ĊĊ print (( int (p )))


Input:
k, n = list(map(int, input().split()))

a = list(map(int, input().split()))

diff = []

for i in range(n - 1):

    diff.append(a[i + 1] - a[i])

diff.append(k - a[-1] + a[0])

print((k - max(diff)))

k , Ġn Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ a Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ diff Ġ= Ġ[] ĊĊĊĊ for Ġi Ġin Ġrange (n Ġ- Ġ 1 ):ĊĊ ĠĠĠ Ġdiff .append (a [i Ġ+ Ġ 1 ] Ġ- Ġa [i ])ĊĊ diff .append (k Ġ- Ġa [- 1 ] Ġ+ Ġa [ 0 ])ĊĊ ĊĊ print (( k Ġ- Ġmax (diff )))Ċ


Input:
class Calc:

    def __init__(self, max_value, mod):

        """combination(max_value, all)"""

        fact = [-1] * (max_value + 1)

        fact[0] = 1

        fact[1] = 1

        for x in range(2, max_value + 1):

            fact[x] = x * fact[x - 1] % mod

        invs = [1] * (max_value + 1)

        invs[max_value] = pow(fact[max_value], mod - 2, mod)

        for x in range(max_value - 1, 0, -1):

            invs[x] = invs[x + 1] * (x + 1) % mod

        self.fact = fact

        self.invs = invs

        self.mod = mod

    def combination(self, n, r):

        if n - r < r:

            return self.combination(n, n - r)

        if r < 0:

            return 0

        if r == 0:

            return 1

        if r == 1:

            return n

        return self.fact[n] * self.invs[r] * self.invs[n - r] % self.mod

def gen(n):

    x = n

    d = 2

    cnt = 0

    while x % d == 0:

        x //= d

        cnt += 1

    yield cnt

    d = 3

    ma = d * d

    while ma <= n:

        cnt = 0

        while x % d == 0:

            x //= d

            cnt += 1

        yield cnt

        ma += d * 4 + 4

        d += 2

    if x > 1:

        yield 1

def main():

    MOD = 10 ** 9 + 7

    N, M = list(map(int, input().split()))

    cal = Calc(max_value=N + 30, mod=MOD)

    ans = 1

    for cnt in gen(M):

        ans = (ans * cal.combination(N + cnt - 1, cnt)) % MOD

    print(ans)

if __name__ == '__main__':

    main()

class ĠCalc :ĊĊ ĠĠĠ Ġdef Ġ__ init __( self , Ġmax _value , Ġmod ):ĊĊ ĠĠĠĠĠĠĠ Ġ""" combination (max _value , Ġall ) """ĊĊ ĠĠĠĠĠĠĠ Ġfact Ġ= Ġ[- 1 ] Ġ* Ġ( max _value Ġ+ Ġ 1 )ĊĊ ĠĠĠĠĠĠĠ Ġfact [ 0 ] Ġ= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġfact [ 1 ] Ġ= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġx Ġin Ġrange ( 2 , Ġmax _value Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfact [x ] Ġ= Ġx Ġ* Ġfact [x Ġ- Ġ 1 ] Ġ% Ġmod ĊĊĊĊ ĠĠĠĠĠĠĠ Ġinv s Ġ= Ġ[ 1 ] Ġ* Ġ( max _value Ġ+ Ġ 1 )ĊĊ ĠĠĠĠĠĠĠ Ġinv s [max _value ] Ġ= Ġpow (f act [max _value ], Ġmod Ġ- Ġ 2 , Ġmod )ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġx Ġin Ġrange (max _value Ġ- Ġ 1 , Ġ 0 , Ġ- 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġinv s [x ] Ġ= Ġinv s [x Ġ+ Ġ 1 ] Ġ* Ġ( x Ġ+ Ġ 1 ) Ġ% Ġmod ĊĊĊĊ ĠĠĠĠĠĠĠ Ġself .f act Ġ= Ġfact ĊĊ ĠĠĠĠĠĠĠ Ġself .in vs Ġ= Ġinv s ĊĊ ĠĠĠĠĠĠĠ Ġself .mod Ġ= Ġmod ĊĊĊĊ ĠĠĠ Ġdef Ġcombination (self , Ġn , Ġr ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġn Ġ- Ġr Ġ< Ġr :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġself .com b ination (n , Ġn Ġ- Ġr )ĊĊ ĠĠĠĠĠĠĠ Ġif Ġr Ġ< Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġr Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġr Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġn ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġself .f act [n ] Ġ* Ġself .in vs [r ] Ġ* Ġself .in vs [n Ġ- Ġr ] Ġ% Ġself .mod ĊĊĊĊĊĊ def Ġgen (n ):ĊĊ ĠĠĠ Ġx Ġ= Ġn ĊĊ ĠĠĠ Ġd Ġ= Ġ 2 ĊĊ ĠĠĠ Ġcnt Ġ= Ġ 0 ĊĊ ĠĠĠ Ġwhile Ġx Ġ% Ġd Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġx Ġ//= Ġd ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġyield Ġcnt ĊĊĊĊ ĠĠĠ Ġd Ġ= Ġ 3 ĊĊ ĠĠĠ Ġma Ġ= Ġd Ġ* Ġd ĊĊ ĠĠĠ Ġwhile Ġma Ġ<= Ġn :ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġx Ġ% Ġd Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġx Ġ//= Ġd ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġyield Ġcnt ĊĊ ĠĠĠĠĠĠĠ Ġma Ġ+= Ġd Ġ* Ġ 4 Ġ+ Ġ 4 ĊĊ ĠĠĠĠĠĠĠ Ġd Ġ+= Ġ 2 ĊĊĊĊ ĠĠĠ Ġif Ġx Ġ> Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġyield Ġ 1 ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ ĠMOD Ġ= Ġ 1 0 Ġ** Ġ 9 Ġ+ Ġ 7 ĊĊĊĊ ĠĠĠ ĠN , ĠM Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ ĠĠĠ Ġcal Ġ= ĠCalc (max _value =N Ġ+ Ġ 3 0 , Ġmod = MOD )ĊĊĊĊ ĠĠĠ Ġans Ġ= Ġ 1 ĊĊ ĠĠĠ Ġfor Ġcnt Ġin Ġgen (M ):ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= Ġ( ans Ġ* Ġcal .com b ination (N Ġ+ Ġcnt Ġ- Ġ 1 , Ġcnt )) Ġ% ĠMOD ĊĊ ĠĠĠ Ġprint (ans )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
def c_remainder_minimization_2019(L, R):

    ans = float('inf')

    for i in range(L, min(R, L + 2019)):

        for j in range(i + 1, min(R + 1, L + 2020)):

            ans = min(ans, (i * j) % 2019)

    return ans

L, R = [int(i) for i in input().split()]

print((c_remainder_minimization_2019(L, R)))

def Ġc _remain der _min imization _ 2 0 1 9 (L , ĠR ):ĊĊ ĠĠĠ Ġans Ġ= Ġfloat (' inf ')ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (L , Ġmin (R , ĠL Ġ+ Ġ 2 0 1 9 )) :ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange (i Ġ+ Ġ 1 , Ġmin (R Ġ+ Ġ 1 , ĠL Ġ+ Ġ 2 0 2 0 )) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ= Ġmin (ans , Ġ( i Ġ* Ġj ) Ġ% Ġ 2 0 1 9 )ĊĊ ĠĠĠ Ġreturn Ġans ĊĊĊĊ L , ĠR Ġ= Ġ[ int (i ) Ġfor Ġi Ġin Ġinput (). split ()]ĊĊ print (( c _remain der _min imization _ 2 0 1 9 (L , ĠR )))


Input:
a, b, c, x, y = list(map(int, input().split()))

val = float('inf')

for k in range(10 ** 5 + 1):

    val = min(val, 2 * c * k + max(x - k, 0) * a + max(y - k, 0) * b)

print(val)

a , Ġb , Ġc , Ġx , Ġy Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ val Ġ= Ġfloat (' inf ')ĊĊ for Ġk Ġin Ġrange ( 1 0 Ġ** Ġ 5 Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġval Ġ= Ġmin (val , Ġ 2 Ġ* Ġc Ġ* Ġk Ġ+ Ġmax (x Ġ- Ġk , Ġ 0 ) Ġ* Ġa Ġ+ Ġmax (y Ġ- Ġk , Ġ 0 ) Ġ* Ġb )ĊĊ print (val )


Input:
from math import factorial as f

n = int(input())

print((f(n) % (10 ** 9 + 7)))

from Ġmath Ġimport Ġfactorial Ġas Ġf ĊĊ n Ġ= Ġint (input ())ĊĊ print (( f (n ) Ġ% Ġ( 1 0 Ġ** Ġ 9 Ġ+ Ġ 7 )))


Input:
n,m,k=list(map(int,input().split()))

mod=10**9+7

f=[1]

for i in range(2*10**5+7):f+=[f[-1]*(i+1)%mod]

def comb(a,b):return f[a]*pow(f[b],mod-2,mod)*pow(f[a-b],mod-2,mod)%mod

ans=0

for i in range(1,n):

  ans+=(i*(n-i)*m**2)*(comb(n*m-2,k-2))

  ans%=mod

for i in range(1,m):

  ans+=(i*(m-i)*n**2)*(comb(n*m-2,k-2))

  ans%=mod

print(ans)

n ,m ,k =list (map (int ,input (). split ()))ĊĊ mod = 1 0 ** 9 + 7 ĊĊ f =[ 1 ]ĊĊ for Ġi Ġin Ġrange ( 2 * 1 0 ** 5 + 7 ): f + =[ f [- 1 ]*( i + 1 )% mod ]ĊĊ def Ġcomb (a ,b ): return Ġf [a ]* pow (f [b ], mod - 2 , mod )* pow (f [a -b ], mod - 2 , mod )% mod ĊĊ ans = 0 ĊĊ for Ġi Ġin Ġrange ( 1 ,n ):ĊĊ Ġ Ġans +=( i *( n -i )* m ** 2 )*( comb (n *m - 2 ,k - 2 ))ĊĊ Ġ Ġans %= mod ĊĊ for Ġi Ġin Ġrange ( 1 ,m ):ĊĊ Ġ Ġans +=( i *( m -i )* n ** 2 )*( comb (n *m - 2 ,k - 2 ))ĊĊ Ġ Ġans %= mod ĊĊ print (ans )


Input:
import math

print((math.factorial(int(input()))%(10**9+7)))

import Ġmath ĊĊ print (( math .factor ial (int (input ())) %( 1 0 ** 9 + 7 )))


Input:
A, B, C, X, Y = [int(_) for _ in input().split()]

ans = A * X + B * Y

for i in range(max(X, Y) + 1):

    cost = 2 * C * i

    if X > i:

        cost += A * (X - i)

    if Y > i:

        cost += B * (Y - i)

    ans = min(ans, cost)

print(ans)

A , ĠB , ĠC , ĠX , ĠY Ġ= Ġ[ int (_) Ġfor Ġ_ Ġin Ġinput (). split ()]ĊĊ ans Ġ= ĠA Ġ* ĠX Ġ+ ĠB Ġ* ĠY ĊĊ for Ġi Ġin Ġrange (max (X , ĠY ) Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġcost Ġ= Ġ 2 Ġ* ĠC Ġ* Ġi ĊĊ ĠĠĠ Ġif ĠX Ġ> Ġi :ĊĊ ĠĠĠĠĠĠĠ Ġcost Ġ+= ĠA Ġ* Ġ( X Ġ- Ġi )ĊĊ ĠĠĠ Ġif ĠY Ġ> Ġi :ĊĊ ĠĠĠĠĠĠĠ Ġcost Ġ+= ĠB Ġ* Ġ( Y Ġ- Ġi )ĊĊ ĠĠĠ Ġans Ġ= Ġmin (ans , Ġcost )ĊĊ print (ans )


Input:
s = input()

len_s = len(s)

cnt = [0, 0]

for i in range(1, len(s)):

    memo_0 = s[i - 1]

    memo_1 = s[len_s - i]

    if s[i] != memo_0:

        cnt[0] += 1

    if s[len_s - i - 1] != memo_1:

        cnt[1] += 1

print((min(cnt)))

s Ġ= Ġinput ()ĊĊ len _s Ġ= Ġlen (s )ĊĊ cnt Ġ= Ġ[ 0 , Ġ 0 ]ĊĊ for Ġi Ġin Ġrange ( 1 , Ġlen (s )) :ĊĊ ĠĠĠ Ġmemo _ 0 Ġ= Ġs [i Ġ- Ġ 1 ]ĊĊ ĠĠĠ Ġmemo _ 1 Ġ= Ġs [len _s Ġ- Ġi ]ĊĊ ĠĠĠ Ġif Ġs [i ] Ġ!= Ġmemo _ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġcnt [ 0 ] Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġif Ġs [len _s Ġ- Ġi Ġ- Ġ 1 ] Ġ!= Ġmemo _ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġcnt [ 1 ] Ġ+= Ġ 1 ĊĊ print (( min (cnt )))Ċ


Input:
import heapq

K=int(input())

dist=[10**15 for i in range(K)]

dist[1]=1

q=[]

heapq.heappush(q,(0,1))

while (len(q)!=0):

    prc,src=heapq.heappop(q)

    if dist[src]<prc:

        continue

    if dist[(src+1)%K]>dist[src]+1:

        dist[(src+1)%K]=dist[src]+1

        heapq.heappush(q,(dist[(src+1)%K],(src+1)%K))

    if dist[(10*src)%K]>dist[src]:

        dist[(10*src)%K]=dist[src]

        heapq.heappush(q,(dist[(src*10)%K],(src*10)%K))

print((dist[0]))

import Ġheapq ĊĊ K =int (input ())ĊĊ dist =[ 1 0 ** 1 5 Ġfor Ġi Ġin Ġrange (K )]ĊĊ dist [ 1 ]= 1 ĊĊ q =[] ĊĊ heap q .he app ush (q ,( 0 , 1 ))ĊĊ while Ġ( len (q )!= 0 ):ĊĊ ĠĠĠ Ġpr c , src = heap q .he app op (q )ĊĊ ĠĠĠ Ġif Ġdist [src ]< pr c :ĊĊ ĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġif Ġdist [( src + 1 )% K ]> dist [src ]+ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġdist [( src + 1 )% K ]= dist [src ]+ 1 ĊĊ ĠĠĠĠĠĠĠ Ġheapq .he app ush (q ,( dist [( src + 1 )% K ], ( src + 1 )% K ))ĊĊ ĠĠĠ Ġif Ġdist [( 1 0 * src )% K ]> dist [src ]:ĊĊ ĠĠĠĠĠĠĠ Ġdist [( 1 0 * src )% K ]= dist [src ]ĊĊ ĠĠĠĠĠĠĠ Ġheapq .he app ush (q ,( dist [( src * 1 0 )% K ], ( src * 1 0 )% K ))ĊĊ print (( dist [ 0 ]))Ċ


Input:
n = int(input())

cnt = 0

for i in range(1, n+1):

    i_str = str(i)

    if len(i_str) == 1:

        cnt += 1

        continue

    if len(i_str) == 2:

        if int(i_str[0]) == int(i_str[1]):

            cnt += 3

        elif int(i_str[1]) != 0 and int(i_str[0]) > int(i_str[1]):

            cnt += 2

        continue

    if len(i_str) == 3:

        if int(i_str[0]) == int(i_str[2]):

            cnt += 4 + (2 * (int(i_str[1])+1) - 1)

        elif int(i_str[2]) != 0 and int(i_str[0]) > int(i_str[2]):

            cnt += 22

        elif int(i_str[0]) < int(i_str[2]):

            cnt += 2

        continue

    if len(i_str) == 4:

        if int(i_str[0]) == int(i_str[3]):

            cnt += 24 + 20 * int(i_str[1]) + 2 * (int(i_str[2])+1) - 1

        elif int(i_str[3]) != 0 and int(i_str[0]) > int(i_str[3]):

            cnt += 222

        elif int(i_str[0]) < int(i_str[3]):

            cnt += 22

        continue

    if len(i_str) == 5:

        if int(i_str[0]) == int(i_str[4]):

            cnt += 224 + 200 * int(i_str[1]) + 20 * int(i_str[2]) + 2 * (int(i_str[3])+1) - 1

        elif int(i_str[4]) != 0 and int(i_str[0]) > int(i_str[4]):

            cnt += 2222

        elif int(i_str[0]) < int(i_str[4]):

            cnt += 222

        continue

    if len(i_str) == 6:

        if int(i_str[0]) == int(i_str[5]):

            cnt += 2224 + 2000 * int(i_str[1]) + 200 * int(i_str[2]) + 20 * int(i_str[3]) + 2 * (int(i_str[4])+1) - 1

        elif int(i_str[5]) != 0 and int(i_str[0]) > int(i_str[5]):

            cnt += 22222

        elif int(i_str[0]) < int(i_str[5]):

            cnt += 2222

        continue

print(cnt)

n Ġ= Ġint (input ())ĊĊ ĊĊ cnt Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange ( 1 , Ġn + 1 ):ĊĊ ĠĠĠ Ġi _str Ġ= Ġstr (i )ĊĊ ĠĠĠ Ġif Ġlen (i _str ) Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġif Ġlen (i _str ) Ġ== Ġ 2 :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġint (i _str [ 0 ]) Ġ== Ġint (i _str [ 1 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 3 ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġint (i _str [ 1 ]) Ġ!= Ġ 0 Ġand Ġint (i _str [ 0 ]) Ġ> Ġint (i _str [ 1 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 2 ĊĊ ĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġif Ġlen (i _str ) Ġ== Ġ 3 :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġint (i _str [ 0 ]) Ġ== Ġint (i _str [ 2 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 4 Ġ+ Ġ( 2 Ġ* Ġ( int (i _str [ 1 ])+ 1 ) Ġ- Ġ 1 )ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġint (i _str [ 2 ]) Ġ!= Ġ 0 Ġand Ġint (i _str [ 0 ]) Ġ> Ġint (i _str [ 2 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 2 2 ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġint (i _str [ 0 ]) Ġ< Ġint (i _str [ 2 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 2 ĊĊ ĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġif Ġlen (i _str ) Ġ== Ġ 4 :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġint (i _str [ 0 ]) Ġ== Ġint (i _str [ 3 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 2 4 Ġ+ Ġ 2 0 Ġ* Ġint (i _str [ 1 ]) Ġ+ Ġ 2 Ġ* Ġ( int (i _str [ 2 ])+ 1 ) Ġ- Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġint (i _str [ 3 ]) Ġ!= Ġ 0 Ġand Ġint (i _str [ 0 ]) Ġ> Ġint (i _str [ 3 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 2 2 2 ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġint (i _str [ 0 ]) Ġ< Ġint (i _str [ 3 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 2 2 ĊĊ ĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġif Ġlen (i _str ) Ġ== Ġ 5 :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġint (i _str [ 0 ]) Ġ== Ġint (i _str [ 4 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 2 2 4 Ġ+ Ġ 2 0 0 Ġ* Ġint (i _str [ 1 ]) Ġ+ Ġ 2 0 Ġ* Ġint (i _str [ 2 ]) Ġ+ Ġ 2 Ġ* Ġ( int (i _str [ 3 ])+ 1 ) Ġ- Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġint (i _str [ 4 ]) Ġ!= Ġ 0 Ġand Ġint (i _str [ 0 ]) Ġ> Ġint (i _str [ 4 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 2 2 2 2 ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġint (i _str [ 0 ]) Ġ< Ġint (i _str [ 4 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 2 2 2 ĊĊ ĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġif Ġlen (i _str ) Ġ== Ġ 6 :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġint (i _str [ 0 ]) Ġ== Ġint (i _str [ 5 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 2 2 2 4 Ġ+ Ġ 2 0 0 0 Ġ* Ġint (i _str [ 1 ]) Ġ+ Ġ 2 0 0 Ġ* Ġint (i _str [ 2 ]) Ġ+ Ġ 2 0 Ġ* Ġint (i _str [ 3 ]) Ġ+ Ġ 2 Ġ* Ġ( int (i _str [ 4 ])+ 1 ) Ġ- Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġint (i _str [ 5 ]) Ġ!= Ġ 0 Ġand Ġint (i _str [ 0 ]) Ġ> Ġint (i _str [ 5 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 2 2 2 2 2 ĊĊ ĠĠĠĠĠĠĠ Ġelif Ġint (i _str [ 0 ]) Ġ< Ġint (i _str [ 5 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 2 2 2 2 ĊĊ ĠĠĠĠĠĠĠ Ġcontinue ĊĊĊĊ print (cnt )


Input:
import math

N = int(input())

ans = math.factorial(N) % (10**9 + 7)

print(ans)

import Ġmath ĊĊĊĊ N Ġ= Ġint (input ())ĊĊ ans Ġ= Ġmath .factor ial (N ) Ġ% Ġ( 1 0 ** 9 Ġ+ Ġ 7 )ĊĊ print (ans )


Input:
from heapq import heappop, heappush

n, m = list(map(int, input().split()))

a = tuple(map(int, input().split()))

hq = []

for aa in a:

    heappush(hq, (-aa, 1))

for _ in range(m):

    b, c = list(map(int, input().split()))

    heappush(hq, (-c, b))

rest = n

ans = 0

while rest > 0:

    num, cnt = heappop(hq)

    num *= (-1)

    use = min(rest, cnt)

    ans += use * num

    rest -= use

print(ans)

from Ġheapq Ġimport Ġhe app op , Ġhe app ush ĊĊĊĊ n , Ġm Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ a Ġ= Ġtuple (map (int , Ġinput (). split ())) ĊĊĊĊ hq Ġ= Ġ[]ĊĊ for Ġaa Ġin Ġa :ĊĊ ĠĠĠ Ġhe app ush (h q , Ġ(- aa , Ġ 1 )) ĊĊĊĊ for Ġ_ Ġin Ġrange (m ):ĊĊ ĠĠĠ Ġb , Ġc Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġhe app ush (h q , Ġ(- c , Ġb )) ĊĊĊĊ rest Ġ= Ġn ĊĊ ans Ġ= Ġ 0 ĊĊ while Ġrest Ġ> Ġ 0 :ĊĊ ĠĠĠ Ġnum , Ġcnt Ġ= Ġhe app op (h q )ĊĊĊĊ ĠĠĠ Ġnum Ġ*= Ġ(- 1 )ĊĊ ĠĠĠ Ġuse Ġ= Ġmin (rest , Ġcnt )ĊĊ ĠĠĠ Ġans Ġ+= Ġuse Ġ* Ġnum ĊĊ ĠĠĠ Ġrest Ġ-= Ġuse ĊĊĊĊ print (ans )Ċ


Input:
A,B,C,X,Y = list(map(int,input().split()))

l = []

for i in range(max(X,Y)+1):

    T = i * C * 2

    if i < X:

        T += (X-i)*A

    if i < Y:

        T += (Y-i)*B

    l.append(T)

l.sort()

print((l[0]))

A ,B ,C ,X ,Y Ġ= Ġlist (map (int ,input (). split ()))ĊĊ l Ġ= Ġ[]ĊĊ for Ġi Ġin Ġrange (max (X ,Y )+ 1 ):ĊĊ ĠĠĠ ĠT Ġ= Ġi Ġ* ĠC Ġ* Ġ 2 ĊĊ ĠĠĠ Ġif Ġi Ġ< ĠX : ĠĊĊ ĠĠĠĠĠĠĠ ĠT Ġ+= Ġ( X -i )* A ĊĊ ĠĠĠ Ġif Ġi Ġ< ĠY :ĊĊ ĠĠĠĠĠĠĠ ĠT Ġ+= Ġ( Y -i )* B ĊĊ ĠĠĠ Ġl .append (T )ĊĊ l .sort ()ĊĊ print (( l [ 0 ]))


Input:
import collections

import sys

a=input()

b=[]

for i in a:

  b.append(i)

b.sort()

c=collections.Counter(b)

c=list(c.values())

for i in range(len(c)):

  if int(c[i])%2==0:

    q=0

  else:

    q=1

    print('No')

    sys.exit()

print('Yes')

import Ġcollections ĊĊ import Ġsys ĊĊ a =input ()ĊĊ b =[] ĊĊĊĊ for Ġi Ġin Ġa :ĊĊ Ġ Ġb .append (i )ĊĊ ĠĠĊĊ b .sort ()ĊĊ c =c ollections .Counter (b )ĊĊ c =list (c .values ())ĊĊ ĊĊ for Ġi Ġin Ġrange (len (c )) :ĊĊ Ġ Ġif Ġint (c [i ]) % 2 == 0 :ĊĊ ĠĠĠ Ġq = 0 ĊĊ Ġ Ġelse :ĊĊ ĠĠĠ Ġq = 1 ĊĊ ĠĠĠ Ġprint (' No ')ĊĊ ĠĠĠ Ġsys .exit ()ĊĊ ĠĠĠĠĊĊ print (' Yes ')Ċ


Input:
#ABC951B/Sum_of_Three_Integers

K, S = list(map(int, input().split()))

ans = 0

for x in range(0, K+1):

    for y in range(0, K+1):

        z = S - x - y

        if 0 <= z and z <= K:

            ans += 1

print(ans)

# ABC 9 5 1 B / Sum _of _ Three _Int egers ĊĊĊĊ K , ĠS Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġx Ġin Ġrange ( 0 , ĠK + 1 ):ĊĊ ĠĠĠ Ġfor Ġy Ġin Ġrange ( 0 , ĠK + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġz Ġ= ĠS Ġ- Ġx Ġ- Ġy ĊĊ ĠĠĠĠĠĠĠ Ġif Ġ 0 Ġ<= Ġz Ġand Ġz Ġ<= ĠK :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans Ġ+= Ġ 1 ĊĊ print (ans )


Input:
n=int(input())-1

A=list(map(int,input().split()))

i=0

for j in range(n):

 if A[j]<=A[-1]:A[i],A[j]=A[j],A[i];i+=1

A[i],A[n]=A[n],A[i]

print((" ".join(map(str,A[:i]))+" ["+str(A[i])+"] "+" ".join(map(str,A[i+1:]))))

n =int (input ()) - 1 ĊĊ A =list (map (int ,input (). split ()))ĊĊ i = 0 ĊĊ for Ġj Ġin Ġrange (n ):ĊĊ Ġif ĠA [j ]<= A [- 1 ]: A [i ], A [j ]= A [j ], A [i ]; i += 1 ĊĊ A [i ], A [n ]= A [n ], A [i ]ĊĊ print ((" Ġ". join (map (str ,A [: i ])) +" Ġ[" + str (A [i ])+ "] Ġ"+" Ġ". join (map (str ,A [i + 1 : ])) ))Ċ


Input:
N = int(input())

mem = [[0]*10 for _ in range(10)]

for i in range(1,N+1):

    a = int(str(i)[0])

    b = int(str(i)[-1])

    mem[a][b] += 1

ans = 0

for i in range(1,N+1):

    a = int(str(i)[0])

    b = int(str(i)[-1])

    ans += mem[b][a]

print(ans)

N Ġ= Ġint (input ())ĊĊ mem Ġ= Ġ[[ 0 ]* 1 0 Ġfor Ġ_ Ġin Ġrange ( 1 0 )] ĊĊĊĊ for Ġi Ġin Ġrange ( 1 ,N + 1 ):ĊĊ ĠĠĠ Ġa Ġ= Ġint (str (i )[ 0 ])ĊĊ ĠĠĠ Ġb Ġ= Ġint (str (i )[- 1 ])ĊĊ ĠĠĠ Ġmem [a ][ b ] Ġ+= Ġ 1 ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange ( 1 ,N + 1 ):ĊĊ ĠĠĠ Ġa Ġ= Ġint (str (i )[ 0 ])ĊĊ ĠĠĠ Ġb Ġ= Ġint (str (i )[- 1 ])ĊĊ ĠĠĠ Ġans Ġ+= Ġmem [b ][ a ]ĊĊ print (ans )Ċ


Input:
w = input()

for l in w:

	if w.count(l) % 2 == 1:

		print("No")

		break

else:

	print("Yes")

w Ġ= Ġinput ()ĊĊ for Ġl Ġin Ġw :ĊĊ ĉif Ġw .count (l ) Ġ% Ġ 2 Ġ== Ġ 1 :ĊĊ ĉ ĉprint (" No ")ĊĊ ĉ ĉbreak ĊĊ else :ĊĊ ĉprint (" Yes ")


Input:
a, b = list(map(int, input().split()))

tmp=str(a)

c=0

for i in range(a,b+1):

    tmp=str(i)

    tmp2=""

    for s in range(len(tmp)):

        tmp2=tmp2+tmp[len(tmp)-1-s]

    if tmp==tmp2:

        c=c+1

print(c)

a , Ġb Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ tmp =str (a )ĊĊ c = 0 ĊĊ for Ġi Ġin Ġrange (a ,b + 1 ):ĊĊ ĠĠĠ Ġtmp =str (i )ĊĊ ĠĠĠ Ġtmp 2 =" "ĊĊ ĠĠĠ Ġfor Ġs Ġin Ġrange (len (tmp )) :ĊĊ ĠĠĠĠĠĠĠ Ġtmp 2 =tmp 2 + tmp [len (tmp )- 1 -s ]ĊĊ ĠĠĠ Ġif Ġtmp == tmp 2 :ĊĊ ĠĠĠĠĠĠĠ Ġc =c + 1 ĊĊ print (c )


Input:
k,s=list(map(int,input().split()))

ans=0

for i in range(k+1):

    for j in range(k+1):

        z=s-i-j

        if 0<=z<=k:

            ans+=1

print(ans)

k ,s =list (map (int ,input (). split ()))ĊĊ ans = 0 ĊĊ for Ġi Ġin Ġrange (k + 1 ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (k + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġz =s -i -j ĊĊ ĠĠĠĠĠĠĠ Ġif Ġ 0 <= z <= k :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġans += 1 ĊĊ print (ans )Ċ


Input:
import sys, re

from collections import deque, defaultdict, Counter

from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd

from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby

from operator import itemgetter, mul

from copy import deepcopy

from string import ascii_lowercase, ascii_uppercase, digits

from bisect import bisect, bisect_left, insort, insort_left

from heapq import heappush, heappop

from functools import reduce, lru_cache

def input(): return sys.stdin.readline().strip()

def INT(): return int(input())

def MAP(): return map(int, input().split())

def LIST(): return list(map(int, input().split()))

def TUPLE(): return tuple(map(int, input().split()))

def ZIP(n): return zip(*(MAP() for _ in range(n)))

sys.setrecursionlimit(10 ** 9)

INF = float('inf')

mod = 10 ** 9 + 7

#mod = 998244353

from decimal import *

#import numpy as np

#decimal.getcontext().prec = 10

X, Y, Z, K = MAP()

A = sorted(LIST(), reverse = True)

B = sorted(LIST(), reverse = True)

C = sorted(LIST(), reverse = True)

AB = []

for i in range(X):

	for j in range(Y):

		AB.append(A[i]+B[j])

AB.sort(reverse = True)

AB = AB[:3000]

ABC = sorted([C[0]+AB[i] for i in range(min(3000, X*Y))], reverse = True)

for j in range(1, Z):

	ABC_tmp = sorted([C[j]+AB[i] for i in range(min(3000, X*Y))])

	ABC += ABC_tmp

	ABC.sort(reverse = True)

	ABC = ABC[:3000]

print(*ABC[:K], sep= "\n")

import Ġsys , Ġre ĊĊ from Ġcollections Ġimport Ġdeque , Ġdefaultdict , ĠCounter ĊĊ from Ġmath Ġimport Ġceil , Ġsqrt , Ġhyp ot , Ġfactorial , Ġpi , Ġsin , Ġcos , Ġtan , Ġas in , Ġacos , Ġatan , Ġradians , Ġdegrees , Ġlog 2 , Ġgcd ĊĊ from Ġitertools Ġimport Ġaccumulate , Ġpermutations , Ġcombinations , Ġcombinations _with _re placement , Ġproduct , Ġgroup by ĊĊ from Ġoperator Ġimport Ġitem getter , Ġmul ĊĊ from Ġcopy Ġimport Ġdeepcopy ĊĊ from Ġstring Ġimport Ġascii _lowercase , Ġascii _upper case , Ġdigits ĊĊ from Ġbis ect Ġimport Ġbis ect , Ġbis ect _left , Ġins ort , Ġins ort _left ĊĊ from Ġheapq Ġimport Ġhe app ush , Ġhe app op ĊĊ from Ġfunctools Ġimport Ġreduce , Ġl ru _cache ĊĊ def Ġinput (): Ġreturn Ġsys .stdin .readline (). strip ()ĊĊ def ĠINT (): Ġreturn Ġint (input ())ĊĊ def ĠMAP (): Ġreturn Ġmap (int , Ġinput (). split ())ĊĊ def ĠLIST (): Ġreturn Ġlist (map (int , Ġinput (). split ()))ĊĊ def ĠT UPLE (): Ġreturn Ġtuple (map (int , Ġinput (). split ()))ĊĊ def ĠZIP (n ): Ġreturn Ġzip (*( MAP () Ġfor Ġ_ Ġin Ġrange (n )))ĊĊ sys .set rec ursion limit ( 1 0 Ġ** Ġ 9 )ĊĊ INF Ġ= Ġfloat (' inf ')ĊĊ mod Ġ= Ġ 1 0 Ġ** Ġ 9 Ġ+ Ġ 7 ĠĊĊ # mod Ġ= Ġ 9 9 8 2 4 4 3 5 3 ĊĊ from Ġdecimal Ġimport Ġ*ĊĊ #import Ġnumpy Ġas Ġnp ĊĊ # decimal .get context (). prec Ġ= Ġ 1 0 ĊĊĊĊ X , ĠY , ĠZ , ĠK Ġ= ĠMAP ()ĊĊ A Ġ= Ġsorted (L IST (), Ġreverse Ġ= ĠTrue )ĊĊ B Ġ= Ġsorted (L IST (), Ġreverse Ġ= ĠTrue )ĊĊ C Ġ= Ġsorted (L IST (), Ġreverse Ġ= ĠTrue )ĊĊĊĊ AB Ġ= Ġ[]ĊĊ for Ġi Ġin Ġrange (X ):ĊĊ ĉfor Ġj Ġin Ġrange (Y ):ĊĊ ĉ ĉ AB .append (A [i ]+ B [j ])ĊĊ ĊĊ AB .sort (reverse Ġ= ĠTrue )ĊĊ AB Ġ= ĠAB [: 3 0 0 0 ]ĊĊ ABC Ġ= Ġsorted ([ C [ 0 ]+ AB [i ] Ġfor Ġi Ġin Ġrange (min ( 3 0 0 0 , ĠX * Y )) ], Ġreverse Ġ= ĠTrue )ĊĊĊĊ for Ġj Ġin Ġrange ( 1 , ĠZ ):ĊĊ ĉ ABC _tmp Ġ= Ġsorted ([ C [j ]+ AB [i ] Ġfor Ġi Ġin Ġrange (min ( 3 0 0 0 , ĠX * Y )) ])ĊĊ ĉ ABC Ġ+= ĠABC _tmp ĊĊ ĉ ABC .sort (reverse Ġ= ĠTrue )ĊĊ ĉ ABC Ġ= ĠABC [: 3 0 0 0 ]ĊĊĊĊ print (* ABC [: K ], Ġsep = Ġ"\ n ")ĊĊĊ


Input:
import collections

import math

class Dinic:

    """Dinic Algorithm: find max-flow

       complexity: O(EV^2)

       used in GRL6A(AOJ)

    """

    class edge:

        def __init__(self, to, cap, rev):

            self.to, self.cap, self.rev = to, cap, rev

    def __init__(self, V, E, source, sink):

        """ V: the number of vertexes

            E: adjacency list

            source: start point

            sink: goal point

        """

        self.V = V

        self.E = [[] for _ in range(V)]

        for fr in range(V):

            for to, cap in E[fr]:

                self.E[fr].append(self.edge(to, cap, len(self.E[to])))

                self.E[to].append(self.edge(fr, 0, len(self.E[fr])-1))

        self.maxflow = self.dinic(source, sink)

    def dinic(self, source, sink):

        """find max-flow"""

        INF = float('inf')

        maxflow = 0

        while True:

            self.bfs(source)

            if self.level[sink] < 0:

                return maxflow

            self.itr = [0] * self.V

            while True:

                flow = self.dfs(source, sink, INF)

                if flow > 0:

                    maxflow += flow

                else:

                    break

    def dfs(self, vertex, sink, flow):

        """find augmenting path"""

        if vertex == sink:

            return flow

        for i in range(self.itr[vertex], len(self.E[vertex])):

            self.itr[vertex] = i

            e = self.E[vertex][i]

            if e.cap > 0 and self.level[vertex] < self.level[e.to]:

                d = self.dfs(e.to, sink, min(flow, e.cap))

                if d > 0:

                    e.cap -= d

                    self.E[e.to][e.rev].cap += d

                    return d

        return 0

    def bfs(self, start):

        """find shortest path from start"""

        que = collections.deque()

        self.level = [-1] * self.V

        que.append(start)

        self.level[start] = 0

        while que:

            fr = que.popleft()

            for e in self.E[fr]:

                if e.cap > 0 and self.level[e.to] < 0:

                    self.level[e.to] = self.level[fr] + 1

                    que.append(e.to)

while True:

    M, N = list(map(int, input().split()))

    if M == 0 and N == 0:

        break

    blue, red = [], []

    while True:

        for x in input().split():

            blue.append(int(x))

        if len(blue) == M:

            break

    while True:

        for x in input().split():

            red.append(int(x))

        if len(red) == N:

            break

    V = M + N + 2

    edge = [set() for _ in range(V)]

    for i, b in enumerate(blue):

        if b != 1:

            for j, r in enumerate(red):

                if r % b == 0:

                    edge[i].add((M+j, 1))

        for j in range(2, int(math.sqrt(b)) + 1):

            if b % j == 0:

                for k, r in enumerate(red):

                    if r % j == 0 or r % (b // j) == 0:

                        edge[i].add((M+k, 1))

    for i in range(M):

        edge[M+N].add((i, 1))

    for j in range(N):

        edge[M+j].add((M+N+1, 1))

    d = Dinic(V, edge, M+N, M+N+1)

    print((d.maxflow))

import Ġcollections ĊĊ import Ġmath ĊĊĊĊĊĊ class ĠDin ic :ĊĊ ĠĠĠ Ġ""" D inic ĠAlgorithm : Ġfind Ġmax -flow ĊĊ ĠĠĠĠĠĠ Ġcomplexity : ĠO (E V ^ 2 )ĊĊ ĠĠĠĠĠĠ Ġused Ġin ĠG RL 6 A (A O J )ĊĊ ĠĠĠ Ġ"""ĊĊ ĠĠĠ Ġclass Ġedge :ĊĊ ĠĠĠĠĠĠĠ Ġdef Ġ__ init __( self , Ġto , Ġcap , Ġrev ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġself .to , Ġself .cap , Ġself .rev Ġ= Ġto , Ġcap , Ġrev ĊĊĊĊ ĠĠĠ Ġdef Ġ__ init __( self , ĠV , ĠE , Ġsource , Ġsink ):ĊĊ ĠĠĠĠĠĠĠ Ġ""" ĠV : Ġthe Ġnumber Ġof Ġvertex es ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠE : Ġadjacency Ġlist ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġsource : Ġstart Ġpoint ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġsink : Ġgoal Ġpoint ĊĊ ĠĠĠĠĠĠĠ Ġ"""ĊĊ ĠĠĠĠĠĠĠ Ġself .V Ġ= ĠV ĊĊ ĠĠĠĠĠĠĠ Ġself .E Ġ= Ġ[[] Ġfor Ġ_ Ġin Ġrange (V )]ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġfr Ġin Ġrange (V ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġto , Ġcap Ġin ĠE [ fr ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġself .E [ fr ]. append (self .edge (to , Ġcap , Ġlen (self .E [to ])) )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġself .E [to ]. append (self .edge (fr , Ġ 0 , Ġlen (self .E [ fr ])- 1 ))ĊĊ ĠĠĠĠĠĠĠ Ġself .max flow Ġ= Ġself .d inic (source , Ġsink )ĊĊĊĊ ĠĠĠ Ġdef Ġdin ic (self , Ġsource , Ġsink ):ĊĊ ĠĠĠĠĠĠĠ Ġ""" find Ġmax -flow """ĊĊ ĠĠĠĠĠĠĠ ĠINF Ġ= Ġfloat (' inf ')ĊĊ ĠĠĠĠĠĠĠ Ġmax flow Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠ Ġwhile ĠTrue :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġself .b fs (source )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġself .level [s ink ] Ġ< Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġmax flow ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġself .it r Ġ= Ġ[ 0 ] Ġ* Ġself .V ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġwhile ĠTrue :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġflow Ġ= Ġself .d fs (source , Ġsink , ĠINF )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġflow Ġ> Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġmax flow Ġ+= Ġflow ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊĊĊ ĠĠĠ Ġdef Ġdfs (self , Ġvertex , Ġsink , Ġflow ):ĊĊ ĠĠĠĠĠĠĠ Ġ""" find Ġaugment ing Ġpath """ĊĊ ĠĠĠĠĠĠĠ Ġif Ġvertex Ġ== Ġsink :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġflow ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange (self .it r [vertex ], Ġlen (self .E [vertex ])) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġself .it r [vertex ] Ġ= Ġi ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġe Ġ= Ġself .E [vertex ][ i ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġe .cap Ġ> Ġ 0 Ġand Ġself .level [vertex ] Ġ< Ġself .level [e .to ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġd Ġ= Ġself .d fs (e .to , Ġsink , Ġmin (flow , Ġe .cap ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġd Ġ> Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġe .cap Ġ-= Ġd ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġself .E [e .to ][ e .rev ]. cap Ġ+= Ġd ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġreturn Ġd ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġ 0 ĊĊĊĊ ĠĠĠ Ġdef Ġbfs (self , Ġstart ):ĊĊ ĠĠĠĠĠĠĠ Ġ""" find Ġshortest Ġpath Ġfrom Ġstart """ĊĊ ĠĠĠĠĠĠĠ Ġque Ġ= Ġcollections .de que ()ĊĊ ĠĠĠĠĠĠĠ Ġself .level Ġ= Ġ[- 1 ] Ġ* Ġself .V ĊĊ ĠĠĠĠĠĠĠ Ġque .append (start )ĊĊ ĠĠĠĠĠĠĠ Ġself .level [start ] Ġ= Ġ 0 ĊĊĊĊ ĠĠĠĠĠĠĠ Ġwhile Ġque :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfr Ġ= Ġque .p opleft ()ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġe Ġin Ġself .E [ fr ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġe .cap Ġ> Ġ 0 Ġand Ġself .level [e .to ] Ġ< Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġself .level [e .to ] Ġ= Ġself .level [ fr ] Ġ+ Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġque .append (e .to )ĊĊĊĊ while ĠTrue :ĊĊ ĠĠĠ ĠM , ĠN Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġif ĠM Ġ== Ġ 0 Ġand ĠN Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġblue , Ġred Ġ= Ġ[], Ġ[]ĊĊ ĠĠĠ Ġwhile ĠTrue :ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġx Ġin Ġinput (). split ():ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġblue .append (int (x ))ĊĊ ĠĠĠĠĠĠĠ Ġif Ġlen (bl ue ) Ġ== ĠM :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ Ġwhile ĠTrue :ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġx Ġin Ġinput (). split ():ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġred .append (int (x ))ĊĊ ĠĠĠĠĠĠĠ Ġif Ġlen (red ) Ġ== ĠN :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠ ĠV Ġ= ĠM Ġ+ ĠN Ġ+ Ġ 2 ĊĊ ĠĠĠ Ġedge Ġ= Ġ[ set () Ġfor Ġ_ Ġin Ġrange (V )]ĊĊ ĠĠĠ Ġfor Ġi , Ġb Ġin Ġenumerate (bl ue ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġb Ġ!= Ġ 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġj , Ġr Ġin Ġenumerate (red ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġr Ġ% Ġb Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġedge [i ]. add (( M +j , Ġ 1 ))ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġj Ġin Ġrange ( 2 , Ġint (math .sqrt (b )) Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġb Ġ% Ġj Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġk , Ġr Ġin Ġenumerate (red ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġr Ġ% Ġj Ġ== Ġ 0 Ġor Ġr Ġ% Ġ( b Ġ// Ġj ) Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġedge [i ]. add (( M +k , Ġ 1 ))ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (M ):ĊĊ ĠĠĠĠĠĠĠ Ġedge [M +N ]. add (( i , Ġ 1 ))ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (N ):ĊĊ ĠĠĠĠĠĠĠ Ġedge [M +j ]. add (( M +N + 1 , Ġ 1 ))ĊĊ ĠĠĠ Ġd Ġ= ĠDin ic (V , Ġedge , ĠM +N , ĠM +N + 1 )ĊĊ ĠĠĠ Ġprint (( d .max flow ))


Input:
while True:

    try:

        for i in range(3):

            line = input().strip()

            if line == '0':

                raise Exception

            a = b = 0

            for i, s in enumerate(line):

                if i != 0:

                    if s == 'A':

                        a += 1

                    else:

                        b += 1

            if a > b:

                a += 1

            else:

                b += 1

            print(a, b)

    except:

        break

while ĠTrue :ĊĊ ĠĠĠ Ġtry :ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange ( 3 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġline Ġ= Ġinput (). strip ()ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġline Ġ== Ġ' 0 ':ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġraise ĠException ĊĊĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġa Ġ= Ġb Ġ= Ġ 0 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġfor Ġi , Ġs Ġin Ġenumerate (line ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġi Ġ!= Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġs Ġ== Ġ' A ':ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġa Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġb Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġa Ġ> Ġb :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġa Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġb Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (a , Ġb )ĊĊĊĊ ĠĠĠ Ġexcept :ĊĊ ĠĠĠĠĠĠĠ Ġbreak


Input:
from bisect import *

n = int(input())

a = list(map(int,input().split()))

b = list(map(int,input().split()))

c = list(map(int,input().split()))

a = sorted(a)

c = sorted(c)

rec = 0

for i in range(n):

    temp = b[i]

    l = bisect_left(a, temp)

    r = bisect_right(c, temp)

    rec += l * (n - r)

print(rec)

from Ġbis ect Ġimport Ġ*ĊĊ n Ġ= Ġint (input ())ĊĊ a Ġ= Ġlist (map (int ,input (). split ()))ĊĊ b Ġ= Ġlist (map (int ,input (). split ()))ĊĊ c Ġ= Ġlist (map (int ,input (). split ())) ĊĊĊĊ a Ġ= Ġsorted (a )ĊĊ c Ġ= Ġsorted (c )ĊĊĊĊ rec Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġtemp Ġ= Ġb [i ]ĊĊ ĠĠĠ Ġl Ġ= Ġbis ect _left (a , Ġtemp )ĊĊ ĠĠĠ Ġr Ġ= Ġbis ect _right (c , Ġtemp )ĊĊ ĠĠĠ Ġrec Ġ+= Ġl Ġ* Ġ( n Ġ- Ġr )ĊĊ print (rec )


Input:
N,M,K = list(map(int,input().split()))

for i in range(N+1):

    for j in range(M+1):

        t = i*M + j*N - i*j*2

        if t==K:

            print('Yes')

            exit()

print('No')

N ,M ,K Ġ= Ġlist (map (int ,input (). split ())) ĊĊĊĊ for Ġi Ġin Ġrange (N + 1 ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (M + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġt Ġ= Ġi *M Ġ+ Ġj *N Ġ- Ġi *j * 2 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġt == K :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (' Yes ')ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġexit ()ĊĊ print (' No ')


Input:
a,b,c,d,e,f=[int(input()) for _ in range(6)]

print((sum([a,b,c,d,max(e,f)])-min([a,b,c,d])))

a ,b ,c ,d ,e ,f =[ int (input ()) Ġfor Ġ_ Ġin Ġrange ( 6 )]ĊĊ print (( sum ([ a ,b ,c ,d ,max (e ,f )]) - min ([ a ,b ,c ,d ])))


Input:
# AtCoder Beginner Contest 095 C - Half and Half

import sys

A, B, C, X, Y = list(map(int, sys.stdin.readline().strip().split()))

ans = A * X + B * Y

for z in range(2, 2 * 10 ** 5 + 1, 2):

    x = max(X - int(z / 2), 0)

    y = max(Y - int(z / 2), 0)

    price = A * x + B * y + C * z

    ans = min(price, ans)

print(ans)

# ĠAt Coder ĠBeginner ĠContest Ġ 0 9 5 ĠC Ġ- ĠHalf Ġand ĠHalf ĊĊ import Ġsys ĊĊĊĊ A , ĠB , ĠC , ĠX , ĠY Ġ= Ġlist (map (int , Ġsys .stdin .readline (). strip (). split ())) ĊĊĊĊ ans Ġ= ĠA Ġ* ĠX Ġ+ ĠB Ġ* ĠY ĊĊ for Ġz Ġin Ġrange ( 2 , Ġ 2 Ġ* Ġ 1 0 Ġ** Ġ 5 Ġ+ Ġ 1 , Ġ 2 ):ĊĊ ĠĠĠ Ġx Ġ= Ġmax (X Ġ- Ġint (z Ġ/ Ġ 2 ), Ġ 0 )ĊĊ ĠĠĠ Ġy Ġ= Ġmax (Y Ġ- Ġint (z Ġ/ Ġ 2 ), Ġ 0 )ĊĊĊĊ ĠĠĠ Ġprice Ġ= ĠA Ġ* Ġx Ġ+ ĠB Ġ* Ġy Ġ+ ĠC Ġ* Ġz ĊĊ ĠĠĠ Ġans Ġ= Ġmin (price , Ġans )ĊĊĊĊ print (ans )Ċ


Input:
from collections import defaultdict

N = int(input())

d = defaultdict(int)

for i in range(N):

    S = input()

    d[S] += 1

m = 0

for k in list(d.keys()):

    m = max(d[k],m)

li = []

for k in list(d.keys()):

    if d[k] == m:

        li.append(k)

li.sort()

for l in li:

    print(l)

from Ġcollections Ġimport Ġdefaultdict ĊĊ N Ġ= Ġint (input ())ĊĊ d Ġ= Ġdefaultdict (int )ĊĊĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ ĠS Ġ= Ġinput ()ĊĊ ĠĠĠ Ġd [S ] Ġ+= Ġ 1 ĊĊĊĊ m Ġ= Ġ 0 ĊĊ for Ġk Ġin Ġlist (d .keys ()) :ĊĊ ĠĠĠ Ġm Ġ= Ġmax (d [k ], m )ĊĊĊĊ li Ġ= Ġ[]ĊĊ for Ġk Ġin Ġlist (d .keys ()) :ĊĊ ĠĠĠ Ġif Ġd [k ] Ġ== Ġm :ĊĊ ĠĠĠĠĠĠĠ Ġli .append (k )ĊĊĊĊ li .sort ()ĊĊ for Ġl Ġin Ġli :ĊĊ ĠĠĠ Ġprint (l )


Input:
N,M = list(map(int,input().split()))

L,R = [],[]

for i in range(M):

    l,r = list(map(int,input().split()))

    L.append(l)

    R.append(r)

ans = min(R)-max(L)+1

print((ans if ans >= 0 else 0))

N ,M Ġ= Ġlist (map (int ,input (). split ()))ĊĊ L ,R Ġ= Ġ[], [] ĊĊ for Ġi Ġin Ġrange (M ):ĊĊ ĠĠĠ Ġl ,r Ġ= Ġlist (map (int ,input (). split ()))ĊĊ ĠĠĠ ĠL .append (l )ĊĊ ĠĠĠ ĠR .append (r )ĊĊ ans Ġ= Ġmin (R )- max (L )+ 1 ĊĊ print (( ans Ġif Ġans Ġ>= Ġ 0 Ġelse Ġ 0 ))


Input:
n = int(input())

l = []

for i in range(1,1000001):

    a = n / i

    if a.is_integer():

        l.append(i+n/i)

print((int(min(l)-2)))

n Ġ= Ġint (input ())ĊĊ l Ġ= Ġ[]ĊĊ for Ġi Ġin Ġrange ( 1 , 1 0 0 0 0 0 1 ):ĊĊ ĠĠĠ Ġa Ġ= Ġn Ġ/ Ġi ĊĊ ĠĠĠ Ġif Ġa .is _integer ():ĊĊ ĠĠĠĠĠĠĠ Ġl .append (i +n /i )ĊĊ print (( int (min (l )- 2 )))


Input:
n = int(input())

import math

m = int(math.sqrt(n))+1

anss = []

for x in range(1, m+1):

  y = n//x

  z = n%x

  if z == 0:

    anss.append(abs(x-1)+abs(y-1))

print((min(anss)))

n Ġ= Ġint (input ())ĊĊ import Ġmath ĊĊ m Ġ= Ġint (math .sqrt (n ))+ 1 ĊĊ ans s Ġ= Ġ[]ĊĊ for Ġx Ġin Ġrange ( 1 , Ġm + 1 ):ĊĊ Ġ Ġy Ġ= Ġn // x ĊĊ Ġ Ġz Ġ= Ġn %x ĊĊ Ġ Ġif Ġz Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġan ss .append (abs (x - 1 )+ abs (y - 1 ))ĊĊ print (( min (ans s )))Ċ


Input:
a, b = list(map(int, input().split()))

if a*b%2 == 1:

    print("Odd")

else:

    print("Even")

a , Ġb Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ if Ġa *b % 2 Ġ== Ġ 1 :ĊĊ ĠĠĠ Ġprint (" Odd ")ĊĊ else :ĊĊ ĠĠĠ Ġprint (" Even ")


Input:
n = int(input())

m = 10**9 + 7

# ans = [0] * (n + 1)

ans = [0] * 2200

ans[0] = 1

# ans[3] = 1

# ans[4] = 1

# ans[5] = 1

for i in range(3, n + 1):

    for j in range(i - 2):

        ans[i] += ans[j]

        ans[i] %= m

print((ans[n]))

# print(ans[:10])

n Ġ= Ġint (input ())ĊĊ m Ġ= Ġ 1 0 ** 9 Ġ+ Ġ 7 ĊĊ # Ġans Ġ= Ġ[ 0 ] Ġ* Ġ( n Ġ+ Ġ 1 )ĊĊ ans Ġ= Ġ[ 0 ] Ġ* Ġ 2 2 0 0 ĊĊ ans [ 0 ] Ġ= Ġ 1 ĊĊ # Ġans [ 3 ] Ġ= Ġ 1 ĊĊ # Ġans [ 4 ] Ġ= Ġ 1 ĊĊ # Ġans [ 5 ] Ġ= Ġ 1 ĊĊ for Ġi Ġin Ġrange ( 3 , Ġn Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (i Ġ- Ġ 2 ):ĊĊ ĠĠĠĠĠĠĠ Ġans [i ] Ġ+= Ġans [j ]ĊĊ ĠĠĠĠĠĠĠ Ġans [i ] Ġ%= Ġm ĊĊ print (( ans [n ]))ĊĊ # Ġprint (ans [: 1 0 ])Ċ


Input:
import sys

input = sys.stdin.readline

read = sys.stdin.read

n = int(input())

A = list(map(int, read().split()))

L = sorted([(j, i) for i, j in enumerate(A)])

count = 0

for i in range(n):

  if (L[i][1]-i)%2:

    count += 1

ans = (count+1) // 2

print(ans)

import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊ read Ġ= Ġsys .stdin .read ĊĊĊĊ n Ġ= Ġint (input ())ĊĊ A Ġ= Ġlist (map (int , Ġread (). split ()))ĊĊ L Ġ= Ġsorted ([( j , Ġi ) Ġfor Ġi , Ġj Ġin Ġenumerate (A )])ĊĊ count Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ Ġ Ġif Ġ( L [i ][ 1 ]- i )% 2 :ĊĊ ĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊ ans Ġ= Ġ( count + 1 ) Ġ// Ġ 2 ĊĊ print (ans )


Input:
# Acceptance of input

import sys

file_input = sys.stdin

X, Y, E = list(map(int, file_input.readline().split()))

v_num = X + Y + 2

adj_mat = [[0] * (v_num) for i in range(v_num)]

for line in file_input:

    x, y = list(map(int, line.split()))

    adj_mat[x][X + y] = 1

s = X + Y

t = s + 1

for i in range(X):

    adj_mat[s][i] = 1

for i in range(X, s):

    adj_mat[i][t] = 1

# Dinic's algorithm

import collections

# BFS for residual capacity network to construct level graph

def bfs(start, goal, parent):

    unvisited = [True] * v_num

    queue = collections.deque()

    queue.append(start)

    unvisited[start] = False

    while queue:

        u = queue.popleft()

        for v, r_capacity in enumerate(adj_mat[u]):

            if unvisited[v] and (r_capacity > 0):

                parent[v].append(u)

                queue.append(v)

                unvisited[v] = False

    return unvisited[goal]

# DFS for level graph and construct blocking flow

def dfs(goal, path, parent, blocking_flow):

    v = path[-1]

    if v == goal:

        aug_path_flow = 10000

        for x, y in zip(path[1:], path[:-1]):

            aug_path_flow = min(aug_path_flow, adj_mat[x][y])

        for x, y in zip(path[1:], path[:-1]):

            adj_mat[x][y] -= aug_path_flow

            adj_mat[y][x] += aug_path_flow

        blocking_flow[0] += aug_path_flow

    else:

        for u in parent[v]:

            path.append(u)

            dfs(goal, path, parent, blocking_flow)

            path.pop()

def dinic(source, sink):

    max_flow = 0

    parent = [[] for i in range(v_num)]

    while not bfs(source, sink, parent):

        blocking_flow = [0]

        path = [sink]

        # search in reverse direction from sink

        dfs(source, path, parent, blocking_flow)

        max_flow += blocking_flow[0]

        parent = [[] for i in range(v_num)]

    return max_flow

# output

print((dinic(s, t)))

# ĠAccept ance Ġof Ġinput ĊĊĊĊ import Ġsys ĊĊĊĊ file _input Ġ= Ġsys .stdin ĊĊĊĊ X , ĠY , ĠE Ġ= Ġlist (map (int , Ġfile _input .readline (). split ())) ĊĊĊĊ v _num Ġ= ĠX Ġ+ ĠY Ġ+ Ġ 2 ĊĊĊĊ adj _mat Ġ= Ġ[[ 0 ] Ġ* Ġ( v _num ) Ġfor Ġi Ġin Ġrange (v _num )] ĊĊĊĊ for Ġline Ġin Ġfile _input :ĊĊ ĠĠĠ Ġx , Ġy Ġ= Ġlist (map (int , Ġline .split ()))ĊĊ ĠĠĠ Ġadj _mat [x ][ X Ġ+ Ġy ] Ġ= Ġ 1 ĊĊĊĊ s Ġ= ĠX Ġ+ ĠY ĊĊ t Ġ= Ġs Ġ+ Ġ 1 ĊĊĊĊ for Ġi Ġin Ġrange (X ):ĊĊ ĠĠĠ Ġadj _mat [s ][ i ] Ġ= Ġ 1 ĊĊĊĊ for Ġi Ġin Ġrange (X , Ġs ):ĊĊ ĠĠĠ Ġadj _mat [i ][ t ] Ġ= Ġ 1 ĊĊĊĊ # ĠDin ic 's Ġalgorithm ĊĊĊĊ import Ġcollections ĊĊĊĊ # ĠBFS Ġfor Ġresidual Ġcapacity Ġnetwork Ġto Ġconstruct Ġlevel Ġgraph ĊĊ def Ġbfs (start , Ġgoal , Ġparent ):ĊĊ ĠĠĠ Ġun visited Ġ= Ġ[ True ] Ġ* Ġv _num ĊĊ ĠĠĠ Ġqueue Ġ= Ġcollections .de que ()ĊĊ ĠĠĠ Ġqueue .append (start )ĊĊ ĠĠĠ Ġun visited [start ] Ġ= ĠFalse ĊĊ ĠĠĠ Ġwhile Ġqueue :ĊĊ ĠĠĠĠĠĠĠ Ġu Ġ= Ġqueue .p opleft ()ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġv , Ġr _capacity Ġin Ġenumerate (adj _mat [u ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġun visited [v ] Ġand Ġ( r _capacity Ġ> Ġ 0 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġparent [v ]. append (u )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġqueue .append (v )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġun visited [v ] Ġ= ĠFalse ĊĊ ĠĠĠ Ġreturn Ġun visited [ goal ]ĊĊĊĊ # ĠDFS Ġfor Ġlevel Ġgraph Ġand Ġconstruct Ġblocking Ġflow ĊĊ def Ġdfs (goal , Ġpath , Ġparent , Ġblocking _flow ):ĊĊ ĠĠĠ Ġv Ġ= Ġpath [- 1 ]ĊĊ ĠĠĠ Ġif Ġv Ġ== Ġgoal :ĊĊ ĠĠĠĠĠĠĠ Ġaug _path _flow Ġ= Ġ 1 0 0 0 0 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġx , Ġy Ġin Ġzip (path [ 1 :], Ġpath [:- 1 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġaug _path _flow Ġ= Ġmin (a ug _path _flow , Ġadj _mat [x ][ y ])ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġx , Ġy Ġin Ġzip (path [ 1 :], Ġpath [:- 1 ]) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġadj _mat [x ][ y ] Ġ-= Ġaug _path _flow ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġadj _mat [y ][ x ] Ġ+= Ġaug _path _flow ĊĊ ĠĠĠĠĠĠĠ Ġblocking _flow [ 0 ] Ġ+= Ġaug _path _flow ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġu Ġin Ġparent [v ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġpath .append (u )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdfs (goal , Ġpath , Ġparent , Ġblocking _flow )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġpath .pop ()ĊĊĊĊ def Ġdin ic (source , Ġsink ):ĊĊ ĠĠĠ Ġmax _flow Ġ= Ġ 0 ĊĊ ĠĠĠ Ġparent Ġ= Ġ[[] Ġfor Ġi Ġin Ġrange (v _num )]ĊĊ ĠĠĠ Ġwhile Ġnot Ġbfs (source , Ġsink , Ġparent ):ĊĊ ĠĠĠĠĠĠĠ Ġblocking _flow Ġ= Ġ[ 0 ]ĊĊ ĠĠĠĠĠĠĠ Ġpath Ġ= Ġ[ sink ]ĊĊ ĠĠĠĠĠĠĠ Ġ# Ġsearch Ġin Ġreverse Ġdirection Ġfrom Ġsink ĊĊ ĠĠĠĠĠĠĠ Ġdfs (source , Ġpath , Ġparent , Ġblocking _flow )ĊĊ ĠĠĠĠĠĠĠ Ġmax _flow Ġ+= Ġblocking _flow [ 0 ]ĊĊ ĠĠĠĠĠĠĠ Ġparent Ġ= Ġ[[] Ġfor Ġi Ġin Ġrange (v _num )]ĊĊ ĠĠĠ Ġreturn Ġmax _flow ĊĊĊĊ # Ġoutput ĊĊ print (( din ic (s , Ġt )))


Input:
import sys, re

from collections import deque, defaultdict, Counter

from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2, log

from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby

from operator import itemgetter, mul

from copy import deepcopy

from string import ascii_lowercase, ascii_uppercase, digits

from bisect import bisect, bisect_left, insort, insort_left

from math import gcd

from heapq import heappush, heappop

from functools import reduce

from decimal import Decimal

def input(): return sys.stdin.readline().strip()

def INT(): return int(input())

def MAP(): return list(map(int, input().split()))

def LIST(): return list(map(int, input().split()))

def ZIP(n): return list(zip(*(MAP() for _ in range(n))))

sys.setrecursionlimit(10 ** 9)

INF = float('inf')

mod = 10**9 + 7

from decimal import *

N = INT()

xy = []

for i in range(N):

	A = INT()

	xy.append([LIST() for _ in range(A)])

ans = 0

for i in range(1<<N):

	i = list("{:b}".format(i).zfill(N))

	for j in range(N):

		if i[j] == "1":

			for x, y in xy[j]:

				if y != int(i[x-1]):

					break

			else:

				continue

			break

	else:

		tmp = sum([int(x) for x in i])

		ans = max(ans, tmp)

print(ans)

import Ġsys , Ġre ĊĊ from Ġcollections Ġimport Ġdeque , Ġdefaultdict , ĠCounter ĊĊ from Ġmath Ġimport Ġceil , Ġsqrt , Ġhyp ot , Ġfactorial , Ġpi , Ġsin , Ġcos , Ġtan , Ġas in , Ġacos , Ġatan , Ġradians , Ġdegrees #, Ġlog 2 , Ġlog ĊĊ from Ġitertools Ġimport Ġaccumulate , Ġpermutations , Ġcombinations , Ġcombinations _with _re placement , Ġproduct , Ġgroup by ĊĊ from Ġoperator Ġimport Ġitem getter , Ġmul ĊĊ from Ġcopy Ġimport Ġdeepcopy ĊĊ from Ġstring Ġimport Ġascii _lowercase , Ġascii _upper case , Ġdigits ĊĊ from Ġbis ect Ġimport Ġbis ect , Ġbis ect _left , Ġins ort , Ġins ort _left ĊĊ from Ġmath Ġimport Ġgcd ĊĊ from Ġheapq Ġimport Ġhe app ush , Ġhe app op ĊĊ from Ġfunctools Ġimport Ġreduce ĊĊ from Ġdecimal Ġimport ĠDecimal ĊĊ def Ġinput (): Ġreturn Ġsys .stdin .readline (). strip ()ĊĊ def ĠINT (): Ġreturn Ġint (input ())ĊĊ def ĠMAP (): Ġreturn Ġlist (map (int , Ġinput (). split ()))ĊĊ def ĠLIST (): Ġreturn Ġlist (map (int , Ġinput (). split ()))ĊĊ def ĠZIP (n ): Ġreturn Ġlist (zip (*( MAP () Ġfor Ġ_ Ġin Ġrange (n ))))ĊĊ sys .set rec ursion limit ( 1 0 Ġ** Ġ 9 )ĊĊ INF Ġ= Ġfloat (' inf ')ĊĊ mod Ġ= Ġ 1 0 ** 9 Ġ+ Ġ 7 ĊĊ from Ġdecimal Ġimport Ġ* ĊĊĊĊ N Ġ= ĠINT ()ĊĊ xy Ġ= Ġ[] ĊĊĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĉA Ġ= ĠINT ()ĊĊ ĉ xy .append ([ LIST () Ġfor Ġ_ Ġin Ġrange (A )] )ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange ( 1 << N ):ĊĊ ĉi Ġ= Ġlist ("{ : b }". format (i ). z fill (N ))ĊĊ ĉfor Ġj Ġin Ġrange (N ):ĊĊ ĉ ĉif Ġi [j ] Ġ== Ġ" 1 ":ĊĊ ĉĉ ĉfor Ġx , Ġy Ġin Ġxy [j ]:ĊĊ ĉĉĉ ĉif Ġy Ġ!= Ġint (i [x - 1 ]) :ĊĊ ĉĉĉĉ ĉbreak ĊĊ ĉĉ ĉelse :ĊĊ ĉĉĉ ĉcontinue ĊĊ ĉĉ ĉbreak ĊĊ ĉelse :ĊĊ ĉ ĉtmp Ġ= Ġsum ([ int (x ) Ġfor Ġx Ġin Ġi ])ĊĊ ĉ ĉans Ġ= Ġmax (ans , Ġtmp )ĊĊ print (ans )Ċ


Input:
w = input()

y = list(set(w))

for i in range(len(y)):

    if w.count(y[i]) % 2 != 0:

        print('No')

        exit(0)

print('Yes')

w Ġ= Ġinput ()ĊĊ y Ġ= Ġlist (set (w )) ĊĊĊĊ for Ġi Ġin Ġrange (len (y )) :ĊĊ ĠĠĠ Ġif Ġw .count (y [i ]) Ġ% Ġ 2 Ġ!= Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (' No ')ĊĊ ĠĠĠĠĠĠĠ Ġexit ( 0 )ĊĊĊĊ print (' Yes ')


Input:
from collections import defaultdict

N, K, *A = list(map(int, open(0).read().split()))

S = [0] * (N + 1)

for i in range(N):

    S[i + 1] = S[i] + A[i]

d = defaultdict(int)

ans = 0

for j in range(N + 1):

    v = (S[j] - j) % K

    ans += d[v]

    d[v] += 1

    if j >= K - 1:

        d[(S[j - K + 1] - (j - K + 1)) % K] -= 1

print(ans)

from Ġcollections Ġimport Ġdefaultdict ĊĊĊĊ N , ĠK , Ġ* A Ġ= Ġlist (map (int , Ġopen ( 0 ). read (). split ())) ĊĊĊĊ S Ġ= Ġ[ 0 ] Ġ* Ġ( N Ġ+ Ġ 1 )ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ ĠS [i Ġ+ Ġ 1 ] Ġ= ĠS [i ] Ġ+ ĠA [i ]ĊĊĊĊ d Ġ= Ġdefaultdict (int )ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġj Ġin Ġrange (N Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġv Ġ= Ġ( S [j ] Ġ- Ġj ) Ġ% ĠK ĊĊ ĠĠĠ Ġans Ġ+= Ġd [v ]ĊĊ ĠĠĠ Ġd [v ] Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġif Ġj Ġ>= ĠK Ġ- Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġd [( S [j Ġ- ĠK Ġ+ Ġ 1 ] Ġ- Ġ( j Ġ- ĠK Ġ+ Ġ 1 )) Ġ% ĠK ] Ġ-= Ġ 1 ĊĊ ĠĠĠĠĠĠĠĠĊĊ print (ans )Ċ


Input:
n=int(input())

x=list(map(int,input().split()))

x.sort()

for p in range(x[0],x[len(x)-1]+1):

    psum=0

    for i in range(len(x)):

        psum=psum+(x[0]-x[i])**2

#    print(psum)

    pmin=psum

    for j in range(x[0]+1,x[len(x)-1]):

        psum=0

        for i in range(len(x)):

            psum=psum+(j-x[i])**2

#        print(psum)

        if pmin>psum:

            pmin=psum

print(pmin)

n =int (input ())ĊĊ x =list (map (int ,input (). split ())) ĊĊĊĊ x .sort ()ĊĊĊĊ for Ġp Ġin Ġrange (x [ 0 ], x [len (x )- 1 ]+ 1 ):ĊĊ ĠĠĠ Ġp sum = 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (len (x )) :ĊĊ ĠĠĠĠĠĠĠ Ġp sum =p sum +( x [ 0 ]- x [i ])** 2 ĊĊ # ĠĠĠ Ġprint (p sum )ĊĊ ĠĠĠ Ġp min =p sum ĠĠĠĠĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (x [ 0 ]+ 1 ,x [len (x )- 1 ]) :ĊĊ ĠĠĠĠĠĠĠ Ġp sum = 0 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġi Ġin Ġrange (len (x )) :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġp sum =p sum +( j -x [i ])** 2 ĊĊ # ĠĠĠĠĠĠĠ Ġprint (p sum )ĊĊ ĠĠĠĠĠĠĠ Ġif Ġp min >p sum :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġp min =p sum ĊĊ print (p min ) ĠĠĠĠ


Input:
import re

S = input()

max = 0

for i in range(len(S)) :

    for j in range(i + 1, len(S) + 1) :

        pattern = re.compile(r'[A|T|C|G]{%d}' % int(j - i))

        subStr = S[i:j]

        if pattern.match(subStr) and j - i > max :

            max = j - i

print(max)

import Ġre ĊĊĊĊ S Ġ= Ġinput ()ĊĊ max Ġ= Ġ 0 ĊĊĊĊ for Ġi Ġin Ġrange (len (S )) Ġ:ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (i Ġ+ Ġ 1 , Ġlen (S ) Ġ+ Ġ 1 ) Ġ:ĊĊ ĠĠĠĠĠĠĠ Ġpattern Ġ= Ġre .compile (r '[ A | T | C | G ]{ % d }' Ġ% Ġint (j Ġ- Ġi ))ĊĊ ĠĠĠĠĠĠĠ Ġsub Str Ġ= ĠS [i :j ]ĊĊĊĊ ĠĠĠĠĠĠĠ Ġif Ġpattern .match (sub Str ) Ġand Ġj Ġ- Ġi Ġ> Ġmax Ġ:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġmax Ġ= Ġj Ġ- Ġi ĊĊĊĊ print (max )Ċ


Input:
import itertools

N = int(input())

Nketa = len(str(N))

range_count = [[0 for j in range(10)]for i in range(10)]

for p in range(1,N+1):

    mae = int(str(p)[0])

    ato = int(str(p)[-1])

    range_count[mae][ato] += 1

count = 0

for j in range(1,N+1):

    a_mae = int(str(j)[0])

    a_ato = int(str(j)[-1])

    b_mae = a_ato

    b_ato = a_mae

    if b_mae == 0:

        continue

    else:

        count += range_count[b_mae][b_ato]

print(count)

import Ġitertools ĊĊ N Ġ= Ġint (input ())ĊĊ N k eta Ġ= Ġlen (str (N )) ĊĊĊĊ range _count Ġ= Ġ[[ 0 Ġfor Ġj Ġin Ġrange ( 1 0 )] for Ġi Ġin Ġrange ( 1 0 )] ĊĊĊĊĊĊ for Ġp Ġin Ġrange ( 1 ,N + 1 ):ĊĊ ĠĠĠ Ġm ae Ġ= Ġint (str (p )[ 0 ])ĊĊ ĠĠĠ Ġat o Ġ= Ġint (str (p )[- 1 ])ĊĊ ĠĠĠ Ġrange _count [ ma e ][ ato ] Ġ+= Ġ 1 ĊĊĊĊ ĠĠĠĠ ĊĊĊĊ count Ġ= Ġ 0 ĊĊ for Ġj Ġin Ġrange ( 1 ,N + 1 ):ĊĊ ĠĠĠ Ġa _m ae Ġ= Ġint (str (j )[ 0 ])ĊĊ ĠĠĠ Ġa _at o Ġ= Ġint (str (j )[- 1 ])ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġb _m ae Ġ= Ġa _at o ĊĊ ĠĠĠ Ġb _at o Ġ= Ġa _m ae ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġif Ġb _m ae Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠ Ġcount Ġ+= Ġrange _count [b _m ae ][ b _at o ]ĊĊ print (count )ĊĊ ĠĠ


Input:
s=input()

t=input()

ans=0

if s[0]==t[0]:

    ans+=1

if s[1]==t[1]:

    ans+=1

if s[2]==t[2]:

    ans+=1

print(ans)

s =input ()ĊĊ t =input ()ĊĊ ans = 0 ĊĊ if Ġs [ 0 ]== t [ 0 ]:ĊĊ ĠĠĠ Ġans += 1 ĊĊ if Ġs [ 1 ]== t [ 1 ]:ĊĊ ĠĠĠ Ġans += 1 ĊĊ if Ġs [ 2 ]== t [ 2 ]:ĊĊ ĠĠĠ Ġans += 1 ĊĊ print (ans )Ċ


Input:
k,s=list(map(int,input().split()))

cnt=0

for i in range(k+1):

    for j in range(k+1):

        if 0 <= s-i-j <= k:

            cnt+=1

print(cnt)

k ,s =list (map (int ,input (). split ()))ĊĊ cnt = 0 ĊĊ for Ġi Ġin Ġrange (k + 1 ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (k + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġ 0 Ġ<= Ġs -i -j Ġ<= Ġk :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt += 1 ĊĊ print (cnt )


Input:
N,Ma,Mb = list(map(int, input().split()))

arr=[list(map(int,input().split())) for _ in range(N)]

dp=[[[5000]*401 for _ in range(401)] for _ in range(41)]

dp[0][0][0] = 0

for i in range(N):

    a,b,c=arr[i]

    for j in range(10*N+1):

        for k in range(10*N+1):

            if dp[i][j][k] == 5000:

                continue

            dp[i+1][j][k]=min(dp[i+1][j][k],dp[i][j][k])

            dp[i+1][j+a][k+b]=min(dp[i+1][j+a][k+b],dp[i][j][k]+c)

ans=5000

for i in range(1,401):

        if i*Ma>400 or i*Mb>400:

            break

        ans = min(ans, dp[N][i*Ma][i*Mb])

if ans == 5000:

    print((-1))

else:

    print(ans)

N ,M a ,M b Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ arr =[ list (map (int ,input (). split ())) Ġfor Ġ_ Ġin Ġrange (N )]ĊĊ dp =[ [[ 5 0 0 0 ]* 4 0 1 Ġfor Ġ_ Ġin Ġrange ( 4 0 1 )] Ġfor Ġ_ Ġin Ġrange ( 4 1 )]ĊĊ dp [ 0 ][ 0 ][ 0 ] Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ ĠĠĠ Ġa ,b ,c = arr [i ]ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange ( 1 0 *N + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġk Ġin Ġrange ( 1 0 *N + 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġdp [i ][ j ][ k ] Ġ== Ġ 5 0 0 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġcontinue ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdp [i + 1 ][ j ][ k ]= min (dp [i + 1 ][ j ][ k ], dp [i ][ j ][ k ])ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdp [i + 1 ][ j +a ][ k +b ]= min (dp [i + 1 ][ j +a ][ k +b ], dp [i ][ j ][ k ]+ c )ĊĊĊĊ ans = 5 0 0 0 ĊĊ for Ġi Ġin Ġrange ( 1 , 4 0 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġi * Ma > 4 0 0 Ġor Ġi *M b > 4 0 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ= Ġmin (ans , Ġdp [N ][ i * Ma ][ i *M b ])ĊĊ if Ġans Ġ== Ġ 5 0 0 0 :ĊĊ ĠĠĠ Ġprint ((- 1 ))ĊĊ else :ĊĊ ĠĠĠ Ġprint (ans )


Input:
from math import gcd

N, M = list(map(int, input().split()))

A = list([int(x) for x in input().split()])

cnt = [0 for _ in range(N)]

for i in range(N):

  a = A[i]

  while a%2 == 0:

    a = a // 2

    cnt[i] += 1

if max(cnt) > min(cnt):

  print((0))

  exit(0)

C = max(cnt)

A = list([x // pow(2,C) for x in A])

def gcd(a,b):

  if a<b:

    a,b = b,a

  while a%b > 0:

    a,b = b,a%b

  return b

def lcm(a,b):

  return a*b//gcd(a,b)

x = A[0]

for a in A[1:]:

  x = lcm(x,a)

x = x * pow(2,C-1)

print(((M // x + 1) // 2))

from Ġmath Ġimport Ġgcd ĊĊ N , ĠM Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ A Ġ= Ġlist ([ int (x ) Ġfor Ġx Ġin Ġinput (). split () ])ĊĊ ĊĊ cnt Ġ= Ġ[ 0 Ġfor Ġ_ Ġin Ġrange (N )]ĊĊ for Ġi Ġin Ġrange (N ):ĊĊ Ġ Ġa Ġ= ĠA [i ]ĊĊ Ġ Ġwhile Ġa % 2 Ġ== Ġ 0 :ĊĊ ĠĠĠ Ġa Ġ= Ġa Ġ// Ġ 2 ĊĊ ĠĠĠ Ġcnt [i ] Ġ+= Ġ 1 ĊĊĊĊ if Ġmax (cnt ) Ġ> Ġmin (cnt ):ĊĊ Ġ Ġprint (( 0 ))ĊĊ Ġ Ġexit ( 0 )ĊĊ C Ġ= Ġmax (cnt )ĊĊĊĊ A Ġ= Ġlist ([ x Ġ// Ġpow ( 2 ,C ) Ġfor Ġx Ġin ĠA ])ĊĊ def Ġgcd (a ,b ):ĊĊ Ġ Ġif Ġa <b :ĊĊ ĠĠĠ Ġa ,b Ġ= Ġb ,a ĊĊ Ġ Ġwhile Ġa % b Ġ> Ġ 0 :ĊĊ ĠĠĠ Ġa ,b Ġ= Ġb ,a % b ĊĊ Ġ Ġreturn Ġb ĊĊĊĊ def Ġlcm (a ,b ):ĊĊ Ġ Ġreturn Ġa *b // gcd (a ,b )ĊĊĊĊ x Ġ= ĠA [ 0 ]ĊĊ for Ġa Ġin ĠA [ 1 :] :ĊĊ Ġ Ġx Ġ= Ġlcm (x ,a )ĊĊ x Ġ= Ġx Ġ* Ġpow ( 2 ,C - 1 )ĊĊĊĊ print ((( M Ġ// Ġx Ġ+ Ġ 1 ) Ġ// Ġ 2 ))


Input:
from heapq import *

n, m = list(map(int, input().split()))

PAIRS = [[-a, -1] for a in map(int, input().split())]

heapify(PAIRS)

for _ in range(m):

    b, c = list(map(int, input().split()))

    heappush(PAIRS, [-c, -b])

answer = 0

for _ in range(n):

    pair = heappop(PAIRS)

    answer += -pair[0]

    pair[1] += 1

    if pair[1] != 0:

        heappush(PAIRS, pair)

print(answer)

from Ġheapq Ġimport Ġ* ĊĊĊĊĊĊ n , Ġm Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ PAIR S Ġ= Ġ[[ - a , Ġ- 1 ] Ġfor Ġa Ġin Ġmap (int , Ġinput (). split ()) ]ĊĊ heap ify (P AIR S )ĊĊĊĊ for Ġ_ Ġin Ġrange (m ):ĊĊ ĠĠĠ Ġb , Ġc Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġhe app ush (P AIR S , Ġ[- c , Ġ- b ])ĊĊ ĊĊ answer Ġ= Ġ 0 ĊĊ for Ġ_ Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġpair Ġ= Ġhe app op (P AIR S )ĊĊ ĠĠĠ Ġanswer Ġ+= Ġ- pair [ 0 ]ĊĊ ĠĠĠ Ġpair [ 1 ] Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġif Ġpair [ 1 ] Ġ!= Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġhe app ush (P AIR S , Ġpair )ĊĊĊĊ print (answer )Ċ


Input:
import math

n = int(input())

ans = math.factorial(n) % (pow(10, 9) + 7)

print(ans)

import Ġmath ĊĊĊĊ n Ġ= Ġint (input ())ĊĊ ans Ġ= Ġmath .factor ial (n ) Ġ% Ġ( pow ( 1 0 , Ġ 9 ) Ġ+ Ġ 7 )ĊĊ print (ans )


Input:
k = int(input())

x = 1

if k%7 != 0:

    mod = 9*k

else:

    mod = 9*k//7

for i in range(10**6):

    x = x*10%mod

    if x == 1:

        print((i + 1))

        exit()

print((-1))

k Ġ= Ġint (input ())ĊĊ x Ġ= Ġ 1 ĊĊĊĊ if Ġk % 7 Ġ!= Ġ 0 :ĊĊ ĠĠĠ Ġmod Ġ= Ġ 9 *k ĊĊ else :ĊĊ ĠĠĠ Ġmod Ġ= Ġ 9 *k // 7 ĊĊĊĊ for Ġi Ġin Ġrange ( 1 0 ** 6 ):ĊĊ ĠĠĠ Ġx Ġ= Ġx * 1 0 % mod ĊĊ ĠĠĠ Ġif Ġx Ġ== Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (( i Ġ+ Ġ 1 ))ĊĊ ĠĠĠĠĠĠĠ Ġexit ()ĊĊĊĊ print ((- 1 ))


Input:
s = input()

cnt = 0

ans = 0

for c in s:

    if c == 'B':

        cnt += 1

    elif c == 'W':

        ans += cnt

print(ans)

s Ġ= Ġinput ()ĊĊĊĊ cnt Ġ= Ġ 0 ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġc Ġin Ġs :ĊĊ ĠĠĠ Ġif Ġc Ġ== Ġ' B ':ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġelif Ġc Ġ== Ġ' W ':ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġcnt ĊĊ print (ans )Ċ


Input:
import math

def pri(n):

    if n < 2:

        return False

    elif n == 2:

        return True

    elif n % 2 == 0:

        return False

    i = 3

    while i <= math.sqrt(n):

        if n % i == 0:

            return False

        i += 2

    return True

l=[i for i in range(110000)if pri(i) ]

while True:

    n = int(input())

    if n == 0: break

    print((sum(l[:n])))

import Ġmath ĊĊ def Ġpri (n ):ĊĊ ĠĠĠ Ġif Ġn Ġ< Ġ 2 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn ĠFalse ĊĊ ĠĠĠ Ġelif Ġn Ġ== Ġ 2 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn ĠTrue ĊĊ ĠĠĠ Ġelif Ġn Ġ% Ġ 2 Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn ĠFalse ĊĊĊĊ ĠĠĠ Ġi Ġ= Ġ 3 ĊĊ ĠĠĠ Ġwhile Ġi Ġ<= Ġmath .sqrt (n ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġn Ġ% Ġi Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġreturn ĠFalse ĊĊ ĠĠĠĠĠĠĠ Ġi Ġ+= Ġ 2 ĊĊ ĠĠĠ Ġreturn ĠTrue ĊĊĊĊ l =[ i Ġfor Ġi Ġin Ġrange ( 1 1 0 0 0 0 ) if Ġpri (i ) Ġ] ĊĊĊĊ while ĠTrue :ĊĊ ĠĠĠ Ġn Ġ= Ġint (input ())ĊĊ ĠĠĠ Ġif Ġn Ġ== Ġ 0 : Ġbreak ĊĊ ĠĠĠ Ġprint (( sum (l [: n ])))


Input:
n = int(input())

l = list(map(int, input().split()))

print((sum(l[i]<l[i+1]<l[i+2] or l[i]>l[i+1]>l[i+2] for i in range(n-2))))

n Ġ= Ġint (input ())ĊĊ l Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ print (( sum (l [i ]< l [i + 1 ]< l [i + 2 ] Ġor Ġl [i ]> l [i + 1 ]> l [i + 2 ] Ġfor Ġi Ġin Ġrange (n - 2 ))))


Input:
N = int(input())

A = list(map(int, input().split()))

ans, s = 0, 0

d = {0:1}

for i in A:

    s += i

    ans += d.get(s, 0)

    d[s] = d.get(s, 0) + 1

print(ans)

N Ġ= Ġint (input ())ĊĊ A Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ ans , Ġs Ġ= Ġ 0 , Ġ 0 ĊĊ d Ġ= Ġ{ 0 : 1 }ĊĊĊĊ for Ġi Ġin ĠA :ĊĊ ĠĠĠ Ġs Ġ+= Ġi ĊĊ ĠĠĠ Ġans Ġ+= Ġd .get (s , Ġ 0 )ĊĊ ĠĠĠ Ġd [s ] Ġ= Ġd .get (s , Ġ 0 ) Ġ+ Ġ 1 ĊĊĊĊ print (ans )


Input:
import numpy as np

n=int(input())

ABC=[list(map(int,input().split())) for _ in range(n)]

dp=np.zeros((n,3),int)

for i in range(3):

  dp[0][i]=ABC[0][i]

for i in range(n-1):

  for j in range(3):

    dp[i+1][j]=max(dp[i][(j+1)%3]+ABC[i+1][j], dp[i][(j+2)%3]+ABC[i+1][j])

print((max(dp[-1])))

import Ġnumpy Ġas Ġnp ĊĊ n =int (input ())ĊĊ ABC =[ list (map (int ,input (). split ())) Ġfor Ġ_ Ġin Ġrange (n )] ĊĊĊĊ dp =np .zeros (( n , 3 ), int )ĊĊ for Ġi Ġin Ġrange ( 3 ):ĊĊ Ġ Ġdp [ 0 ][ i ]= ABC [ 0 ][ i ]ĊĊ for Ġi Ġin Ġrange (n - 1 ):ĊĊ Ġ Ġfor Ġj Ġin Ġrange ( 3 ):ĊĊ ĠĠĠ Ġdp [i + 1 ][ j ]= max (dp [i ][( j + 1 )% 3 ]+ ABC [i + 1 ][ j ], Ġdp [i ][( j + 2 )% 3 ]+ ABC [i + 1 ][ j ])ĊĊ print (( max (dp [- 1 ])))


Input:
N = int(input())

l = [list(map(int, input().split())) for _ in range(N)]

dp = [[0 for i in range(3)] for j in range(N+1)]

for i in range(1, N+1):

    for j in range(3):

        for k in range(3):

            if j != k:

                dp[i][j] = max(dp[i][j], dp[i-1][k]+l[i-1][k])

print((max(dp[N][0], dp[N][1], dp[N][2])))

N Ġ= Ġint (input ())ĊĊ l Ġ= Ġ[ list (map (int , Ġinput (). split ())) Ġfor Ġ_ Ġin Ġrange (N )] ĊĊĊĊ dp Ġ= Ġ[[ 0 Ġfor Ġi Ġin Ġrange ( 3 )] Ġfor Ġj Ġin Ġrange (N + 1 )] ĊĊĊĊĊĊ for Ġi Ġin Ġrange ( 1 , ĠN + 1 ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange ( 3 ):ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġk Ġin Ġrange ( 3 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġj Ġ!= Ġk :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġdp [i ][ j ] Ġ= Ġmax (dp [i ][ j ], Ġdp [i - 1 ][ k ]+ l [i - 1 ][ k ])ĊĊ ĊĊ print (( max (dp [N ][ 0 ], Ġdp [N ][ 1 ], Ġdp [N ][ 2 ])) )ĊĊĊ


Input:
import sys

input = sys.stdin.readline

def main():

    ans = 0

    n = int(input())

    o = list(map(int, input().split()))

    l = [0]*n

    for i in range(n):

        l[o[i]-1] = i+1

    for i in range(len(l)):

        if  i != len(l)-1:

            print("{} ".format(l[i]), end='')

        else:

            print(l[i])

if __name__ == '__main__':

    main()

import Ġsys ĊĊĊĊ input Ġ= Ġsys .stdin .readline ĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġans Ġ= Ġ 0 ĊĊ ĠĠĠ Ġn Ġ= Ġint (input ())ĊĊ ĠĠĠ Ġo Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġl Ġ= Ġ[ 0 ]* n ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠĠĠĠĠ Ġl [o [i ]- 1 ] Ġ= Ġi + 1 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (len (l )) :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġ Ġi Ġ!= Ġlen (l )- 1 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint ("{} Ġ". format (l [i ]), Ġend =' ')ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (l [i ])ĊĊ ĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
N,L = list(map(int, input().split()))

taste = [L+i-1 for i in range(1,N+1)]

if taste[-1] < 0:

  print((sum(taste) + min([abs(x) for x in taste])))

else:

  print((sum(taste) - min([abs(x) for x in taste])))

N ,L Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ t aste Ġ= Ġ[ L +i - 1 Ġfor Ġi Ġin Ġrange ( 1 ,N + 1 )]ĊĊ if Ġtaste [- 1 ] Ġ< Ġ 0 :ĊĊ Ġ Ġprint (( sum (t aste ) Ġ+ Ġmin ([ abs (x ) Ġfor Ġx Ġin Ġtaste ])) )ĊĊ else :ĊĊ Ġ Ġprint (( sum (t aste ) Ġ- Ġmin ([ abs (x ) Ġfor Ġx Ġin Ġtaste ])))


Input:
# ABC090B - Palindromic Numbers

a, b = list(map(int, input().rstrip().split()))

count = 0

for i in range(a, b + 1):

    lst = list(map(int, list(str(i))))

    if lst[0] == lst[4] and lst[1] == lst[3]:

        count += 1

print(count)

# ĠABC 0 9 0 B Ġ- ĠPal ind rom ic ĠNumbers ĊĊ a , Ġb Ġ= Ġlist (map (int , Ġinput (). rstrip (). split ()))ĊĊ count Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (a , Ġb Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġlst Ġ= Ġlist (map (int , Ġlist (str (i ))))ĊĊ ĠĠĠ Ġif Ġlst [ 0 ] Ġ== Ġlst [ 4 ] Ġand Ġlst [ 1 ] Ġ== Ġlst [ 3 ]:ĊĊ ĠĠĠĠĠĠĠ Ġcount Ġ+= Ġ 1 ĊĊ print (count )


Input:
n, m = list(map(int, input().split()))

dp = [0] * n

for i in range(m):

    x, y = list(map(int, input().split()))

    dp[x - 1] += 1

    dp[y - 1] += 1

for i in range(n):

    print((dp[i]))

n , Ġm Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ dp Ġ= Ġ[ 0 ] Ġ* Ġn ĊĊ for Ġi Ġin Ġrange (m ):ĊĊ ĠĠĠ Ġx , Ġy Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġdp [x Ġ- Ġ 1 ] Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġdp [y Ġ- Ġ 1 ] Ġ+= Ġ 1 ĊĊ for Ġi Ġin Ġrange (n ):ĊĊ ĠĠĠ Ġprint (( dp [i ]))


Input:
import sys

sys.setrecursionlimit(2147483647)

INF=float("inf")

MOD=10**9+7

input=lambda :sys.stdin.readline().rstrip()

from collections import deque

def resolve():

    k=int(input())

    E=[[] for _ in range(k)]

    for i in range(k):

        E[i].append(((i+1)%k,1))

        E[i].append(((10*i)%k,0))

    # 0-1 BFS

    dist=[INF]*k

    dist[1]=0

    Q=deque([1])

    while(Q):

        v=Q.popleft()

        for nv,w in E[v]:

            if(dist[nv]<=dist[v]+w): continue

            dist[nv]=dist[v]+w

            if(w==0): Q.appendleft(nv)

            else: Q.append(nv)

    print((dist[0]+1))

resolve()

import Ġsys ĊĊ sys .set rec ursion limit ( 2 1 4 7 4 8 3 6 4 7 )ĊĊ INF =float (" inf ")ĊĊ MOD = 1 0 ** 9 + 7 ĊĊ input =lambda Ġ: sys .stdin .readline (). rstrip ()ĊĊĊĊ from Ġcollections Ġimport Ġdeque ĊĊ def Ġresolve ():ĊĊ ĠĠĠ Ġk =int (input ())ĊĊ ĠĠĠ ĠE =[ [] Ġfor Ġ_ Ġin Ġrange (k )]ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (k ):ĊĊ ĠĠĠĠĠĠĠ ĠE [i ]. append ((( i + 1 )% k , 1 ))ĊĊ ĠĠĠĠĠĠĠ ĠE [i ]. append ((( 1 0 *i )% k , 0 )) ĊĊĊĊ ĠĠĠ Ġ# Ġ 0 - 1 ĠBFS ĊĊ ĠĠĠ Ġdist =[ INF ]* k ĊĊ ĠĠĠ Ġdist [ 1 ]= 0 ĊĊ ĠĠĠ ĠQ = deque ([ 1 ])ĊĊ ĠĠĠ Ġwhile (Q ):ĊĊ ĠĠĠĠĠĠĠ Ġv = Q .p opleft ()ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġnv ,w Ġin ĠE [v ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif (dist [n v ]<= dist [v ]+ w ): Ġcontinue ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdist [n v ]= dist [v ]+ w ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif (w == 0 ): ĠQ .append left (n v )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġelse : ĠQ .append (n v )ĊĊ ĠĠĠ Ġprint (( dist [ 0 ]+ 1 ))ĊĊ resolve ()


Input:
import math

n = int(input())

print((math.factorial(n) % (10**9 + 7)))

import Ġmath ĊĊĊĊ n Ġ= Ġint (input ())ĊĊ ĊĊ print (( math .factor ial (n ) Ġ% Ġ( 1 0 ** 9 Ġ+ Ġ 7 )))Ċ


Input:
N,K = list(map(int,input().split()))

src = list(map(int,input().split()))

cums = [0]

cump = [0]

for a in src:

    cums.append(cums[-1] + a)

    cump.append(cump[-1] + max(0,a))

ans = 0

for i in range(N-K+1):

    tmp = cump[i]

    tmp += max(0, cums[i+K] - cums[i])

    tmp += cump[N] - cump[i+K]

    ans = max(tmp, ans)

print(ans)

N ,K Ġ= Ġlist (map (int ,input (). split ()))ĊĊ src Ġ= Ġlist (map (int ,input (). split ())) ĊĊĊĊ c ums Ġ= Ġ[ 0 ]ĊĊ c ump Ġ= Ġ[ 0 ]ĊĊ for Ġa Ġin Ġsrc :ĊĊ ĠĠĠ Ġc ums .append (c ums [- 1 ] Ġ+ Ġa )ĊĊ ĠĠĠ Ġc ump .append (c ump [- 1 ] Ġ+ Ġmax ( 0 ,a )) ĊĊĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange (N -K + 1 ):ĊĊ ĠĠĠ Ġtmp Ġ= Ġc ump [i ]ĊĊ ĠĠĠ Ġtmp Ġ+= Ġmax ( 0 , Ġc ums [i + K ] Ġ- Ġc ums [i ])ĊĊ ĠĠĠ Ġtmp Ġ+= Ġc ump [N ] Ġ- Ġc ump [i + K ]ĊĊ ĠĠĠ Ġans Ġ= Ġmax (tmp , Ġans )ĊĊ print (ans )Ċ


Input:
def factorial(N):

    power_r = 1

    for n in range(2,N+1):

        power_r *= n

        power_r %= 10**9+7

    return power_r

if __name__ == '__main__':

    N = int(input())

    print((factorial(N)))

def Ġfactorial (N ):ĊĊ ĠĠĠ Ġpower _r Ġ= Ġ 1 ĊĊ ĠĠĠ Ġfor Ġn Ġin Ġrange ( 2 ,N + 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġpower _r Ġ*= Ġn ĊĊ ĠĠĠĠĠĠĠ Ġpower _r Ġ%= Ġ 1 0 ** 9 + 7 ĊĊ ĠĠĠ Ġreturn Ġpower _r ĊĊĊĊ if Ġ__ name __ Ġ== Ġ'__ main __ ':ĊĊ ĠĠĠ ĠN Ġ= Ġint (input ())ĊĊ ĠĠĠ Ġprint (( factor ial (N )))


Input:
import sys

K = int(input())

power = 7

SUM = 0

for i in range(1, 10 ** 6):

    SUM += power

    if SUM % K == 0:

        print(i)

        sys.exit()

    power *= 10

    power %= K

print((-1))

import Ġsys ĊĊ K Ġ= Ġint (input ())ĊĊ ĊĊ power Ġ= Ġ 7 ĊĊ SUM Ġ= Ġ 0 ĊĊĊĊ for Ġi Ġin Ġrange ( 1 , Ġ 1 0 Ġ** Ġ 6 ):ĊĊ ĠĠĠ ĠSUM Ġ+= Ġpower ĊĊ ĠĠĠ Ġif ĠSUM Ġ% ĠK Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġprint (i )ĊĊ ĠĠĠĠĠĠĠ Ġsys .exit ()ĊĊ ĠĠĠ Ġpower Ġ*= Ġ 1 0 ĊĊ ĠĠĠ Ġpower Ġ%= ĠK ĊĊĊĊ print ((- 1 ))


Input:
#E

from itertools import accumulate

from bisect import bisect_left

def main():

    n,m=list(map(int,input().split()))

    A=list(map(int,input().split()))

    A.sort()

    def count(k):

        cnt=0

        for a in A:

            cnt+=bisect_left(A,k-a)

        return cnt

    ok=0

    ng=10**10+1

    while ng-ok>1:

        mid=(ok+ng)//2

        if count(mid)<n**2-m:

            ok=mid

        else:

            ng=mid

    border=ok

    k=n**2-count(border)

    Acc=[0]+list(accumulate(A))

    s=Acc[-1]

    ans=0

    for a in A:

        idx=bisect_left(A,border-a)

        ans+=a*(n-idx)+(s-Acc[idx])

    ans-=border*(k-m)

    print(ans)

if __name__=='__main__':

    main()

# E ĊĊ from Ġitertools Ġimport Ġaccumulate ĊĊ from Ġbis ect Ġimport Ġbis ect _left ĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġn ,m =list (map (int ,input (). split ()))ĊĊ ĠĠĠ ĠA =list (map (int ,input (). split ()))ĊĊ ĠĠĠ ĠA .sort ()ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġdef Ġcount (k ):ĊĊ ĠĠĠĠĠĠĠ Ġcnt = 0 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġa Ġin ĠA :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġcnt += bis ect _left (A ,k -a )ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġcnt ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġok = 0 ĊĊ ĠĠĠ Ġng = 1 0 ** 1 0 + 1 ĊĊ ĠĠĠ Ġwhile Ġng -ok > 1 :ĊĊ ĠĠĠĠĠĠĠ Ġmid =( ok + ng )// 2 ĊĊ ĠĠĠĠĠĠĠ Ġif Ġcount (mid )< n ** 2 -m :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġok = mid ĊĊ ĠĠĠĠĠĠĠ Ġelse :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġng = mid ĊĊ ĠĠĠ Ġborder = ok ĊĊ ĠĠĠĠĊĊ ĠĠĠ Ġk =n ** 2 -count (border )ĊĊ ĠĠĠ ĠAcc =[ 0 ]+ list ( accumulate (A ))ĊĊ ĠĠĠ Ġs = Acc [- 1 ]ĊĊ ĠĠĠ Ġans = 0 ĊĊ ĠĠĠ Ġfor Ġa Ġin ĠA :ĊĊ ĠĠĠĠĠĠĠ Ġidx =b is ect _left (A ,b order -a )ĊĊ ĠĠĠĠĠĠĠ Ġans += a *( n - idx )+( s -A cc [idx ])ĊĊ ĠĠĠ Ġans -= border *( k -m )ĊĊ ĠĠĠ Ġprint (ans )ĊĊ ĠĠĠĠĊĊ if Ġ__ name __ ==' __ main __ ':ĊĊ ĠĠĠ Ġmain ()


Input:
import sys

input = sys.stdin.readline

n = int(input())

v = [[0]+[]*(n+1) for i in range(n+1)]

for i in range(n-1):

    a,b,c = list(map(int,input().split()))

    v[a].append([b,c])

    v[b].append([a,c])

q,k = list(map(int,input().split()))

l = [k]

while l:

    now = l.pop()

    for i in v[now][1:]:

        if v[i[0]][0] == 0:

            v[i[0]][0] = i[1]+v[now][0]

            l.append(i[0])

for i in range(q):

    x,y = list(map(int,input().split()))

    print((v[x][0]+v[y][0]))

import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊ n Ġ= Ġint (input ())ĊĊ v Ġ= Ġ[[ 0 ]+ [] *( n + 1 ) Ġfor Ġi Ġin Ġrange (n + 1 )]ĊĊ for Ġi Ġin Ġrange (n - 1 ):ĊĊ ĠĠĠ Ġa ,b ,c Ġ= Ġlist (map (int ,input (). split ()))ĊĊ ĠĠĠ Ġv [a ]. append ([ b ,c ])ĊĊ ĠĠĠ Ġv [b ]. append ([ a ,c ])ĊĊ ĊĊ q ,k Ġ= Ġlist (map (int ,input (). split ()))ĊĊ l Ġ= Ġ[ k ]ĊĊ while Ġl :ĊĊ ĠĠĠ Ġnow Ġ= Ġl .pop ()ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġv [now ][ 1 :] :ĊĊ ĠĠĠĠĠĠĠ Ġif Ġv [i [ 0 ]][ 0 ] Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġv [i [ 0 ]][ 0 ] Ġ= Ġi [ 1 ]+ v [now ][ 0 ]ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġl .append (i [ 0 ])ĊĊ ĊĊ for Ġi Ġin Ġrange (q ):ĊĊ ĠĠĠ Ġx ,y Ġ= Ġlist (map (int ,input (). split ()))ĊĊ ĠĠĠ Ġprint (( v [x ][ 0 ]+ v [y ][ 0 ]))


Input:
from functools import reduce

from itertools import product

N = int(input())

*A, = list(map(int, input().split()))

ans = 0

for t in product([-1, 0, 1], repeat=N):

    prod = reduce(lambda x, y: x*y, [a + t[i] for i, a in enumerate(A)])

    if prod % 2 == 0: ans += 1

print(ans)

from Ġfunctools Ġimport Ġreduce ĊĊ from Ġitertools Ġimport Ġproduct ĊĊĊĊ N Ġ= Ġint (input ())ĊĊ *A , Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġt Ġin Ġproduct ([- 1 , Ġ 0 , Ġ 1 ], Ġrepeat =N ):ĊĊ ĠĠĠ Ġprod Ġ= Ġreduce (lambda Ġx , Ġy : Ġx *y , Ġ[ a Ġ+ Ġt [i ] Ġfor Ġi , Ġa Ġin Ġenumerate (A )])ĊĊ ĠĠĠ Ġif Ġprod Ġ% Ġ 2 Ġ== Ġ 0 : Ġans Ġ+= Ġ 1 ĊĊ print (ans )


Input:
a, b, m = list(map(int,input().split()))

dr = list(map(int,input().split()))

wa = list(map(int,input().split()))

xyc = [list(map(int,input().split())) for i in range(m)]

low = 200001

for i in range(m):

    f = xyc[i][0] - 1

    d = xyc[i][1] - 1

    if low >= dr[f]+wa[d]-xyc[i][2]:

        low = dr[f]+wa[d]-xyc[i][2]

dr.sort()

wa.sort()

if low >= (dr[0] + wa[0]):

    print((dr[0] + wa[0]))

else:

    print(low)

a , Ġb , Ġm Ġ= Ġlist (map (int ,input (). split ()))ĊĊ dr Ġ= Ġlist (map (int ,input (). split ()))ĊĊ wa Ġ= Ġlist (map (int ,input (). split ()))ĊĊ x yc Ġ= Ġ[ list (map (int ,input (). split ())) Ġfor Ġi Ġin Ġrange (m )]ĊĊ low Ġ= Ġ 2 0 0 0 0 1 ĊĊĊĊ for Ġi Ġin Ġrange (m ):ĊĊ ĠĠĠ Ġf Ġ= Ġx yc [i ][ 0 ] Ġ- Ġ 1 ĊĊ ĠĠĠ Ġd Ġ= Ġx yc [i ][ 1 ] Ġ- Ġ 1 ĊĊ ĠĠĠ Ġif Ġlow Ġ>= Ġdr [f ]+ wa [d ]- x yc [i ][ 2 ]:ĊĊ ĠĠĠĠĠĠĠ Ġlow Ġ= Ġdr [f ]+ wa [d ]- x yc [i ][ 2 ]ĊĊĊĊ dr .sort ()ĊĊ wa .sort ()ĊĊĊĊ if Ġlow Ġ>= Ġ( dr [ 0 ] Ġ+ Ġwa [ 0 ]) :ĊĊ ĠĠĠ Ġprint (( dr [ 0 ] Ġ+ Ġwa [ 0 ]))ĊĊ else :ĊĊ ĠĠĠ Ġprint (low )


Input:
l, r=list(map(int, input().split()))

if r-l>672:

	p=0

else:

	p=2019

	for i in range(l, r):

		for j in range(i+1, r+1):

			p=min(p, (((i%2019)*(j%2019))%2019))

			if not p:

				break

		if not p:

			break

print(p)

l , Ġr =list (map (int , Ġinput (). split ()))ĊĊ if Ġr -l > 6 7 2 :ĊĊ ĉp = 0 ĊĊ else :ĊĊ ĉp = 2 0 1 9 ĊĊ ĉfor Ġi Ġin Ġrange (l , Ġr ):ĊĊ ĉ ĉfor Ġj Ġin Ġrange (i + 1 , Ġr + 1 ):ĊĊ ĉĉ ĉp =min (p , Ġ((( i % 2 0 1 9 )*( j % 2 0 1 9 )) % 2 0 1 9 ))ĊĊ ĉĉ ĉif Ġnot Ġp :ĊĊ ĉĉĉ ĉbreak ĊĊ ĉ ĉif Ġnot Ġp :ĊĊ ĉĉ ĉbreak ĊĊ print (p )


Input:
a,b,c,x,y = list(map(int,input().split()))

price = 10**10

for k in range(10**5+1):

    re = 2*c*k + max(0,x-k)*a + max(0,y-k)*b

    price = min(re,price)

print(price)

a ,b ,c ,x ,y Ġ= Ġlist (map (int ,input (). split ()))ĊĊ price Ġ= Ġ 1 0 ** 1 0 ĊĊ for Ġk Ġin Ġrange ( 1 0 ** 5 + 1 ):ĊĊ ĠĠĠ Ġre Ġ= Ġ 2 *c *k Ġ+ Ġmax ( 0 ,x -k )* a Ġ+ Ġmax ( 0 ,y -k )* b ĊĊ ĠĠĠ Ġprice Ġ= Ġmin (re , price )ĊĊ print (price )


Input:
import math

print((math.factorial(int(input()))%(10**9+7)))

import Ġmath ĊĊ print (( math .factor ial (int (input ())) %( 1 0 ** 9 + 7 )))


Input:
import sys

input = sys.stdin.readline

n = int(input())

ab = sorted([list(map(int, input().split()))[::-1] for _ in range(n)])

cnt = 0

for b, a in ab:

    cnt += a

    if cnt > b:

        print('No')

        break

else:

    print('Yes')

import Ġsys ĊĊ input Ġ= Ġsys .stdin .readline ĊĊĊĊ n Ġ= Ġint (input ())ĊĊ ab Ġ= Ġsorted ([ list (map (int , Ġinput (). split ())) [::- 1 ] Ġfor Ġ_ Ġin Ġrange (n )] )ĊĊĊĊ cnt Ġ= Ġ 0 ĊĊ for Ġb , Ġa Ġin Ġab :ĊĊ ĠĠĠ Ġcnt Ġ+= Ġa ĊĊ ĠĠĠ Ġif Ġcnt Ġ> Ġb :ĊĊ ĠĠĠĠĠĠĠ Ġprint (' No ')ĊĊ ĠĠĠĠĠĠĠ Ġbreak ĊĊ else :ĊĊ ĠĠĠ Ġprint (' Yes ')Ċ


Input:
from collections import Counter

N = int(input())

div = []

for i in range(2,N+1):

    while i != 1:

        for d in range(2,i+1):

            while i%d==0:

                i = i//d

                div.append(d)

C = Counter(div).most_common()

Ans = 1

for k,v in C:

    Ans = Ans*(v+1) % (10**9+7)

print(Ans)

from Ġcollections Ġimport ĠCounter ĊĊ N Ġ= Ġint (input ())ĊĊ div Ġ= Ġ[]ĊĊ for Ġi Ġin Ġrange ( 2 ,N + 1 ):ĊĊ ĠĠĠ Ġwhile Ġi Ġ!= Ġ 1 :ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġd Ġin Ġrange ( 2 ,i + 1 ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġwhile Ġi %d == 0 :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġi Ġ= Ġi // d ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġdiv .append (d )ĊĊ C Ġ= ĠCounter (div ). most _common ()ĊĊ Ans Ġ= Ġ 1 ĊĊ for Ġk ,v Ġin ĠC :ĊĊ ĠĠĠ ĠAns Ġ= ĠAns *( v + 1 ) Ġ% Ġ( 1 0 ** 9 + 7 )ĊĊĊĊ print ( Ans )Ċ


Input:
from collections import deque

from copy import deepcopy, copy

dy = [-1, 0, 0, 1]

dx = [0, -1, 1, 0]

N = 3

def g(i, j, a):

    t = a // (10 ** j) % 10

    return a - t * (10 ** j) + t * (10 ** i)

def MAIN():

    m = {8:{7, 5}, 7:{8, 6, 4}, 6:{7, 3}, 5:{8, 4, 2}, 4:{7, 5, 3, 1}, 3:{6, 4, 0}, 2:{5, 1}, 1:{4, 2, 0}, 0:{3, 1}}

    MAP = "".join(input().replace(" ", "") for _ in range(N))

    start = 8 - MAP.find("0")

    MAP = int(MAP)

    goal = ('1', '2', '3', '4', '5', '6', '7', '8', '0')

    goal = 123456780

    dp = deque([(0, start, MAP)])

    LOG = {MAP}

    while dp:

        cnt, yx, M = dp.popleft()

        if M == goal:

            print(cnt)

            break

        cnt += 1

        for nyx in m[yx]:

            CM = g(yx, nyx, M)

            if not CM in LOG:

                dp.append((cnt, nyx, CM))

                LOG.add(CM)

MAIN()

from Ġcollections Ġimport Ġdeque ĊĊ from Ġcopy Ġimport Ġdeepcopy , Ġcopy ĊĊ dy Ġ= Ġ[- 1 , Ġ 0 , Ġ 0 , Ġ 1 ]ĊĊ dx Ġ= Ġ[ 0 , Ġ- 1 , Ġ 1 , Ġ 0 ]ĊĊ N Ġ= Ġ 3 ĊĊ def Ġg (i , Ġj , Ġa ):ĊĊ ĠĠĠ Ġt Ġ= Ġa Ġ// Ġ( 1 0 Ġ** Ġj ) Ġ% Ġ 1 0 ĊĊ ĠĠĠ Ġreturn Ġa Ġ- Ġt Ġ* Ġ( 1 0 Ġ** Ġj ) Ġ+ Ġt Ġ* Ġ( 1 0 Ġ** Ġi )ĊĊ def ĠMAIN ():ĊĊ ĠĠĠ Ġm Ġ= Ġ{ 8 :{ 7 , Ġ 5 }, Ġ 7 :{ 8 , Ġ 6 , Ġ 4 }, Ġ 6 :{ 7 , Ġ 3 }, Ġ 5 :{ 8 , Ġ 4 , Ġ 2 }, Ġ 4 :{ 7 , Ġ 5 , Ġ 3 , Ġ 1 }, Ġ 3 :{ 6 , Ġ 4 , Ġ 0 }, Ġ 2 :{ 5 , Ġ 1 }, Ġ 1 :{ 4 , Ġ 2 , Ġ 0 }, Ġ 0 :{ 3 , Ġ 1 }}ĊĊ ĠĠĠ ĠMAP Ġ= Ġ"". join (input (). replace (" Ġ", Ġ"") Ġfor Ġ_ Ġin Ġrange (N ))ĊĊ ĠĠĠ Ġstart Ġ= Ġ 8 Ġ- ĠMAP .find (" 0 ")ĊĊ ĠĠĠ ĠMAP Ġ= Ġint (M AP )ĊĊ ĠĠĠ Ġgoal Ġ= Ġ(' 1 ', Ġ' 2 ', Ġ' 3 ', Ġ' 4 ', Ġ' 5 ', Ġ' 6 ', Ġ' 7 ', Ġ' 8 ', Ġ' 0 ')ĊĊ ĠĠĠ Ġgoal Ġ= Ġ 1 2 3 4 5 6 7 8 0 ĊĊ ĠĠĠ Ġdp Ġ= Ġdeque ([( 0 , Ġstart , ĠMAP )])ĊĊ ĠĠĠ ĠLOG Ġ= Ġ{ MAP }ĊĊ ĠĠĠ Ġwhile Ġdp :ĊĊ ĠĠĠĠĠĠĠ Ġcnt , Ġy x , ĠM Ġ= Ġdp .p opleft ()ĊĊ ĠĠĠĠĠĠĠ Ġif ĠM Ġ== Ġgoal :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġprint (cnt )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠ Ġcnt Ġ+= Ġ 1 ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġny x Ġin Ġm [y x ]:ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠCM Ġ= Ġg (y x , Ġny x , ĠM )ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġnot ĠCM Ġin ĠLOG :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġdp .append (( cnt , Ġny x , ĠCM ))ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ ĠLOG .add (C M )ĊĊ MAIN ()ĊĊĊ


Input:
# vim: fileencoding=utf-8

def main():

    a, b = list(map(int, input().split()))

    c = 0

    for i in range(a, b + 1):

        s = str(i)

        r = "".join(reversed(list(s)))

        if s == r:

            c += 1

    print(c)

if __name__ == "__main__":

    main()

# Ġvim : Ġfile encoding =utf - 8 ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġa , Ġb Ġ= Ġlist (map (int , Ġinput (). split ()))ĊĊ ĠĠĠ Ġc Ġ= Ġ 0 ĊĊ ĠĠĠ Ġfor Ġi Ġin Ġrange (a , Ġb Ġ+ Ġ 1 ):ĊĊ ĠĠĠĠĠĠĠ Ġs Ġ= Ġstr (i )ĊĊ ĠĠĠĠĠĠĠ Ġr Ġ= Ġ"". join (re versed (list (s )))ĊĊ ĠĠĠĠĠĠĠ Ġif Ġs Ġ== Ġr :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġc Ġ+= Ġ 1 ĊĊ ĠĠĠ Ġprint (c )ĊĊĊĊĊĊ if Ġ__ name __ Ġ== Ġ"__ main __ ":ĊĊ ĠĠĠ Ġmain ()Ċ


Input:
A, B, C, X, Y = list(map(int, input().split()))

ans = float('inf')

for i in range(10 ** 5 + 1):

    ans = min(ans, A * max(X - i, 0) + B * max(Y - i, 0) + 2 * C * i)

print(ans)

A , ĠB , ĠC , ĠX , ĠY Ġ= Ġlist (map (int , Ġinput (). split ())) ĊĊĊĊ ans Ġ= Ġfloat (' inf ')ĊĊĊĊ for Ġi Ġin Ġrange ( 1 0 Ġ** Ġ 5 Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġans Ġ= Ġmin (ans , ĠA Ġ* Ġmax (X Ġ- Ġi , Ġ 0 ) Ġ+ ĠB Ġ* Ġmax (Y Ġ- Ġi , Ġ 0 ) Ġ+ Ġ 2 Ġ* ĠC Ġ* Ġi )ĊĊ print (ans )


Input:
k,m=list(map(int,input().split()))

l=[0 for i in range(k+1)]

for i in range(m):

  a,s=list(map(int,input().split()))

  l[a-1]+=1;l[s]-=1

ans=0

f=0

for j in range(k):

  l[j]+=f

  f=l[j]

print((len([1 for i in l if i==m])))

k ,m =list (map (int ,input (). split ()))ĊĊ l =[ 0 Ġfor Ġi Ġin Ġrange (k + 1 )]ĊĊ for Ġi Ġin Ġrange (m ):ĊĊ Ġ Ġa ,s =list (map (int ,input (). split ()))ĊĊ Ġ Ġl [a - 1 ]+= 1 ;l [s ]- = 1 ĊĊ ans = 0 ĊĊ f = 0 ĊĊ for Ġj Ġin Ġrange (k ):ĊĊ Ġ Ġl [j ]+= f ĊĊ Ġ Ġf =l [j ]ĊĊ print (( len ([ 1 Ġfor Ġi Ġin Ġl Ġif Ġi == m ])))


Input:
N = int(input())

count = [[0 for _ in range(9)] for _ in range(9)]

for i in range(1, N + 1):

    if str(i)[0] != "0" and str(i)[-1] != "0":

        count[int(str(i)[0]) - 1][int(str(i)[-1]) - 1] += 1

ans = 0

for i in range(0, 9):

    for k in range(0, 9):

        ans += count[i][k] * count[k][i]

print(ans)

N Ġ= Ġint (input ())ĊĊ count Ġ= Ġ[[ 0 Ġfor Ġ_ Ġin Ġrange ( 9 )] Ġfor Ġ_ Ġin Ġrange ( 9 )]ĊĊ for Ġi Ġin Ġrange ( 1 , ĠN Ġ+ Ġ 1 ):ĊĊ ĠĠĠ Ġif Ġstr (i )[ 0 ] Ġ!= Ġ" 0 " Ġand Ġstr (i )[- 1 ] Ġ!= Ġ" 0 ":ĊĊ ĠĠĠĠĠĠĠ Ġcount [int (str (i )[ 0 ]) Ġ- Ġ 1 ][ int (str (i )[- 1 ]) Ġ- Ġ 1 ] Ġ+= Ġ 1 ĊĊ ans Ġ= Ġ 0 ĊĊ for Ġi Ġin Ġrange ( 0 , Ġ 9 ):ĊĊ ĠĠĠ Ġfor Ġk Ġin Ġrange ( 0 , Ġ 9 ):ĊĊ ĠĠĠĠĠĠĠ Ġans Ġ+= Ġcount [i ][ k ] Ġ* Ġcount [k ][ i ]ĊĊ print (ans )


Input:
# -*- coding: utf-8 -*-

import sys

def input(): return sys.stdin.readline().strip()

def list2d(a, b, c): return [[c] * b for i in range(a)]

def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]

def ceil(x, y=1): return int(-(-x // y))

def INT(): return int(input())

def MAP(): return list(map(int, input().split()))

def LIST(): return list(map(int, input().split()))

def Yes(): print('Yes')

def No(): print('No')

def YES(): print('YES')

def NO(): print('NO')

sys.setrecursionlimit(10 ** 9)

INF = float('inf')

MOD = 10 ** 9 + 7

X,Y,Z,K=MAP()

A=sorted(LIST(), reverse=True)

B=sorted(LIST(), reverse=True)

C=sorted(LIST(), reverse=True)

ABC=[]

for i in range(X):

    for j in range(Y):

        if (i+1)*(j+1)>K:

            break

        for k in range(Z):

            if (i+1)*(j+1)*(k+1)>K:

                break

            ABC.append(A[i]+B[j]+C[k])

ABC.sort(reverse=True)

for i in range(K):

    print((ABC[i]))

# Ġ-*- Ġcoding : Ġutf - 8 Ġ-*- ĊĊĊĊ import Ġsys ĊĊĊĊ def Ġinput (): Ġreturn Ġsys .stdin .readline (). strip ()ĊĊ def Ġlist 2 d (a , Ġb , Ġc ): Ġreturn Ġ[[ c ] Ġ* Ġb Ġfor Ġi Ġin Ġrange (a )]ĊĊ def Ġlist 3 d (a , Ġb , Ġc , Ġd ): Ġreturn Ġ[[[ d ] Ġ* Ġc Ġfor Ġj Ġin Ġrange (b )] Ġfor Ġi Ġin Ġrange (a )]ĊĊ def Ġceil (x , Ġy = 1 ): Ġreturn Ġint (- (- x Ġ// Ġy ))ĊĊ def ĠINT (): Ġreturn Ġint (input ())ĊĊ def ĠMAP (): Ġreturn Ġlist (map (int , Ġinput (). split ()))ĊĊ def ĠLIST (): Ġreturn Ġlist (map (int , Ġinput (). split ()))ĊĊ def ĠYes (): Ġprint (' Yes ')ĊĊ def ĠNo (): Ġprint (' No ')ĊĊ def ĠYES (): Ġprint (' YES ')ĊĊ def ĠNO (): Ġprint (' NO ')ĊĊ sys .set rec ursion limit ( 1 0 Ġ** Ġ 9 )ĊĊ INF Ġ= Ġfloat (' inf ')ĊĊ MOD Ġ= Ġ 1 0 Ġ** Ġ 9 Ġ+ Ġ 7 ĊĊĊĊ X ,Y ,Z ,K = MAP ()ĊĊ A = sorted (L IST (), Ġreverse =True )ĊĊ B = sorted (L IST (), Ġreverse =True )ĊĊ C = sorted (L IST (), Ġreverse =True )ĊĊĊĊ ABC =[] ĊĊ for Ġi Ġin Ġrange (X ):ĊĊ ĠĠĠ Ġfor Ġj Ġin Ġrange (Y ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġ( i + 1 )*( j + 1 )> K :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠ Ġfor Ġk Ġin Ġrange (Z ):ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġif Ġ( i + 1 )*( j + 1 )*( k + 1 )> K :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠĠĠĠĠ Ġbreak ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ ĠABC .append (A [i ]+ B [j ]+ C [k ])ĊĊ ABC .sort (reverse =True )ĊĊ for Ġi Ġin Ġrange (K ):ĊĊ ĠĠĠ Ġprint (( ABC [i ])) ĊĊĊ


Input:
#!/usr/bin/env python3

import sys

sys.setrecursionlimit(10**6)

INF = 10 ** 9 + 1  # sys.maxsize # float("inf")

MOD = 10 ** 9 + 7

def floor_sum(n, m, a, b):

    ret = 0

    if a >= m:

        ret += (n - 1) * n * (a // m) // 2

        a %= m

    if b >= m:

        ret += n * (b // m)

        b %= m

    y_max = (a * n + b) // m

    x_max = y_max * m - b

    if y_max == 0:

        return ret

    ret += (n - (x_max + a - 1) // a) * y_max

    ret += floor_sum(y_max, a, m, (a - x_max % a) % a)

    return ret

def debug(*x):

    print(*x, file=sys.stderr)

def solve(SOLVE_PARAMS):

    pass

def main():

    # parse input

    T = int(input())

    for _t in range(T):

        N, M, A, B = map(int, input().split())

        print(floor_sum(N, M, A, B))

# tests

T1 = """

5

4 10 6 3

6 5 4 3

1 1 0 0

31415 92653 58979 32384

1000000000 1000000000 999999999 999999999

"""

TEST_T1 = """

>>> as_input(T1)

>>> main()

3

13

0

314095480

499999999500000000

"""

def _test():

    import doctest

    doctest.testmod()

    g = globals()

    for k in sorted(g):

        if k.startswith("TEST_"):

            doctest.run_docstring_examples(g[k], g, name=k)

def as_input(s):

    "use in test, use given string as input file"

    import io

    f = io.StringIO(s.strip())

    g = globals()

    g["input"] = lambda: bytes(f.readline(), "ascii")

    g["read"] = lambda: bytes(f.read(), "ascii")

input = sys.stdin.buffer.readline

read = sys.stdin.buffer.read

if sys.argv[-1] == "-t":

    print("testing")

    _test()

    sys.exit()

main()

#!/ usr /bin /env Ġpython 3 ĊĊ import Ġsys ĊĊ sys .set rec ursion limit ( 1 0 ** 6 )ĊĊ INF Ġ= Ġ 1 0 Ġ** Ġ 9 Ġ+ Ġ 1 Ġ Ġ# Ġsys .max size Ġ# Ġfloat (" inf ")ĊĊ MOD Ġ= Ġ 1 0 Ġ** Ġ 9 Ġ+ Ġ 7 ĊĊĊĊĊĊ def Ġfloor _sum (n , Ġm , Ġa , Ġb ):ĊĊ ĠĠĠ Ġret Ġ= Ġ 0 ĊĊ ĠĠĠ Ġif Ġa Ġ>= Ġm :ĊĊ ĠĠĠĠĠĠĠ Ġret Ġ+= Ġ( n Ġ- Ġ 1 ) Ġ* Ġn Ġ* Ġ( a Ġ// Ġm ) Ġ// Ġ 2 ĊĊ ĠĠĠĠĠĠĠ Ġa Ġ%= Ġm ĊĊ ĠĠĠ Ġif Ġb Ġ>= Ġm :ĊĊ ĠĠĠĠĠĠĠ Ġret Ġ+= Ġn Ġ* Ġ( b Ġ// Ġm )ĊĊ ĠĠĠĠĠĠĠ Ġb Ġ%= Ġm ĊĊ ĠĠĠ Ġy _max Ġ= Ġ( a Ġ* Ġn Ġ+ Ġb ) Ġ// Ġm ĊĊ ĠĠĠ Ġx _max Ġ= Ġy _max Ġ* Ġm Ġ- Ġb ĊĊ ĠĠĠ Ġif Ġy _max Ġ== Ġ 0 :ĊĊ ĠĠĠĠĠĠĠ Ġreturn Ġret ĊĊ ĠĠĠ Ġret Ġ+= Ġ( n Ġ- Ġ( x _max Ġ+ Ġa Ġ- Ġ 1 ) Ġ// Ġa ) Ġ* Ġy _max ĊĊ ĠĠĠ Ġret Ġ+= Ġfloor _sum (y _max , Ġa , Ġm , Ġ( a Ġ- Ġx _max Ġ% Ġa ) Ġ% Ġa )ĊĊ ĠĠĠ Ġreturn Ġret ĊĊĊĊĊĊ def Ġdebug (* x ):ĊĊ ĠĠĠ Ġprint (* x , Ġfile =sys .stderr )ĊĊĊĊĊĊ def Ġsolve (S OLVE _PARAMS ):ĊĊ ĠĠĠ Ġpass ĊĊĊĊĊĊ def Ġmain ():ĊĊ ĠĠĠ Ġ# Ġparse Ġinput ĊĊ ĠĠĠ ĠT Ġ= Ġint (input ())ĊĊ ĠĠĠ Ġfor Ġ_ t Ġin Ġrange (T ):ĊĊ ĠĠĠĠĠĠĠ ĠN , ĠM , ĠA , ĠB Ġ= Ġmap (int , Ġinput (). split ())ĊĊ ĠĠĠĠĠĠĠ Ġprint (floor _sum (N , ĠM , ĠA , ĠB )) ĊĊĊĊĊĊ # Ġtests ĊĊ T 1 Ġ= Ġ"""ĊĊ 5 ĊĊ 4 Ġ 1 0 Ġ 6 Ġ 3 ĊĊ 6 Ġ 5 Ġ 4 Ġ 3 ĊĊ 1 Ġ 1 Ġ 0 Ġ 0 ĊĊ 3 1 4 1 5 Ġ 9 2 6 5 3 Ġ 5 8 9 7 9 Ġ 3 2 3 8 4 ĊĊ 1 0 0 0 0 0 0 0 0 0 Ġ 1 0 0 0 0 0 0 0 0 0 Ġ 9 9 9 9 9 9 9 9 9 Ġ 9 9 9 9 9 9 9 9 9 ĊĊ """ĊĊ TEST _T 1 Ġ= Ġ"""ĊĊ >>> Ġas _input (T 1 )ĊĊ >>> Ġmain ()ĊĊ 3 ĊĊ 1 3 ĊĊ 0 ĊĊ 3 1 4 0 9 5 4 8 0 ĊĊ 4 9 9 9 9 9 9 9 9 5 0 0 0 0 0 0 0 0 ĊĊ """ ĊĊĊĊĊĊ def Ġ_ test ():ĊĊ ĠĠĠ Ġimport Ġdo ctest ĊĊ ĠĠĠ Ġdo ctest .test mod ()ĊĊ ĠĠĠ Ġg Ġ= Ġglobals ()ĊĊ ĠĠĠ Ġfor Ġk Ġin Ġsorted (g ):ĊĊ ĠĠĠĠĠĠĠ Ġif Ġk .startswith (" TEST _ ") :ĊĊ ĠĠĠĠĠĠĠĠĠĠĠ Ġdo ctest .run _doc string _examples (g [k ], Ġg , Ġname =k )ĊĊĊĊĊĊ def Ġas _input (s ):ĊĊ ĠĠĠ Ġ" use Ġin Ġtest , Ġuse Ġgiven Ġstring Ġas Ġinput Ġfile "ĊĊ ĠĠĠ Ġimport Ġio ĊĊ ĠĠĠ Ġf Ġ= Ġio .String IO (s .strip ())ĊĊ ĠĠĠ Ġg Ġ= Ġglobals ()ĊĊ ĠĠĠ Ġg [" input "] Ġ= Ġlambda : Ġbytes (f .readline (), Ġ" ascii ")ĊĊ ĠĠĠ Ġg [" read "] Ġ= Ġlambda : Ġbytes (f .read (), Ġ" ascii ")ĊĊ ĊĊĊĊ input Ġ= Ġsys .stdin .buffer .readline ĊĊ read Ġ= Ġsys .stdin .buffer .read ĊĊĊĊ if Ġsys .argv [- 1 ] Ġ== Ġ"- t ":ĊĊ ĠĠĠ Ġprint (" testing ")ĊĊ ĠĠĠ Ġ_ test ()ĊĊ ĠĠĠ Ġsys .exit ()ĊĊĊĊ main ()Ċ


Input:
import math

N = int(input())

ans = 10**12

for i in range(1,10**6+1):

  j = math.ceil(N/(i+1))

  if (1+i)*j == N:

    ans = min(i+j-1,ans)

  if i == 10**6 and ans == 10**12:

    ans = N-1

    break

print(ans)

import Ġmath ĊĊ N Ġ= Ġint (input ())ĊĊ ans Ġ= Ġ 1 0 ** 1 2 ĊĊ for Ġi Ġin Ġrange ( 1 , 1 0 ** 6 + 1 ):ĊĊ Ġ Ġj Ġ= Ġmath .ceil (N /( i + 1 ))ĊĊ Ġ Ġif Ġ( 1 +i )* j Ġ== ĠN :ĊĊ ĠĠĠ Ġans Ġ= Ġmin (i +j - 1 , ans )ĊĊ Ġ Ġif Ġi Ġ== Ġ 1 0 ** 6 Ġand Ġans Ġ== Ġ 1 0 ** 1 2 :ĊĊ ĠĠĠ Ġans Ġ= ĠN - 1 ĊĊ ĠĠĠ Ġbreak ĊĊ print (ans )