2180adbf072beeac5a609527434db063adc375c2097e1bd148e9e0e7876f938b

python_code_instructions_filtered_569.txt

@@ -0,0 +1,3086 @@
+    return prod
+
+
+n = 7
+print(multiply_by_fifteen(n))
+
+def check(a, n):
+    """
+    Modify a binary array to Bitwise AND of all elements as 1
+    """
+    for i in range(n):
+        if (a[i]):
+            return True
+    return False
+
+
+if __name__ == '__main__':
+    a = [0, 1, 0, 1]
+    n = len(a)
+    if (check(a, n)):
+        print("YES")
+    else:
+        print("NO")
+
+def is_equal_block(n):
+    """
+    Check if the binary representation of a number has equal number of 0 s and 1 s in blocks
+    """
+    first_bit = n % 2
+    first_count = 1
+    n = n // 2
+    while n % 2 == first_bit and n > 0:
+        n = n // 2
+        first_count += 1
+    if n == 0:
+        return False
+    while n > 0:
+        first_bit = n % 2
+        curr_count = 1
+        n = n // 2
+        while n % 2 == first_bit:
+            n = n // 2
+            curr_count += 1
+        if curr_count != first_count:
+            return False
+    return True
+
+
+if __name__ == "__main__":
+    n = 51
+    if is_equal_block(n):
+        print("Yes")
+    else:
+        print("No")
+
+def calculate(X):
+    """
+    Find a value whose XOR with given number is maximum
+    """
+    number_of_bits = 8
+    return ((1 << number_of_bits) - 1) ^ X
+
+
+if __name__ == "__main__":
+    X = 4
+    print("Required Number is:", calculate(X))
+
+def count_zeros(x):
+    """
+    Number of leading zeros in binary representation of a given number
+    """
+    total_bits = 32
+    res = 0
+    while ((x & (1 << (total_bits - 1))) == 0):
+        x = (x << 1)
+        res += 1
+    return res
+
+
+x = 101
+print(count_zeros(x))
+
+def set_rightmost_unset_bit(n):
+    """
+    Set the rightmost off bit
+    """
+    if n & (n + 1) == 0:
+        return n
+    return n | (n + 1)
+
+
+if __name__ == "__main__":
+    n = 21
+    print(set_rightmost_unset_bit(n))
+
+def increment(i):
+    """
+    Increment a number without using ++ or +
+    """
+    i = -(~i)
+    return i
+
+
+if __name__ == "__main__":
+    n = 3
+    print(increment(n))
+
+def xor_pair_sum(ar, n):
+    """
+    Sum of XOR of sum of all pairs in an array
+    """
+    total = 0
+    for i in range(n):
+        total = total ^ ar[i]
+    return 2 * total
+
+
+if __name__ == "__main__":
+    data = [1, 2, 3]
+    print(xor_pair_sum(data, len(data)))
+
+def kth_character(m, n, k):
+    """
+    Find iâ €™ th index character in a binary string obtained after n iterations
+    """
+    distance = pow(2, n)
+    Block_number = int(k / distance)
+    remaining = k % distance
+    s = [0] * 32
+    x = 0
+    while (m > 0):
+        s[x] = m % 2
+        m = int(m / 2)
+        x += 1
+    root = s[x - 1 - Block_number]
+    if (remaining == 0):
+        print(root)
+        return
+    flip = True
+    while (remaining > 1):
+        if (remaining & 1):
+            flip = not (flip)
+        remaining = remaining >> 1
+    if (flip):
+        print(not (root))
+    else:
+        print(root)
+
+
+m = 5
+k = 5
+n = 3
+kth_character(m, n, k)
+
+from math import pow
+
+
+def get_integer(L, R):
+    """
+    Number with set bits only between L
+    """
+    number = 0
+    for i in range(L, R + 1, 1):
+        number += pow(2, i)
+    return number
+
+
+if __name__ == '__main__':
+    L = 2
+    R = 5
+    print(int(get_integer(L, R)))
+
+def find_eletobe_inserted(A, n, k):
+    """
+    Number whose XOR sum with given array is a given number k
+    """
+    ans = k
+    for i in range(n):
+    return ans
+
+
+if __name__ == '__main__':
+    A = [1, 2, 3, 4, 5]
+    n = len(A)
+    k = 10
+    print(
+        find_eletobe_inserted(
+            A,
+            n,
+            k),
+        "has to be inserted in the given",
+        "array to make xor sum of",
+        k)
+
+def minimize(a):
+    """
+    Minimum number using set bits of a given number
+    """
+    n = bin(a).count("1")
+    return (pow(2, n) - 1)
+
+
+a = 11
+print(minimize(a))
+
+def count_set_bits(n):
+    """
+    Maximum steps to transform 0 to X with bitwise AND
+    """
+    count = 0
+    while (n):
+        count += n & 1
+        n >>= 1
+    return count
+
+
+i = 3
+print(count_set_bits(i))
+
+def is_even(n):
+    """
+    Check a number is odd or even without modulus operator
+    """
+    return (int(n / 2) * 2 == n)
+
+
+n = 101
+if (is_even(n)):
+    print("Even")
+else:
+    print("Odd")
+
+def add(x, y):
+    """
+    Bitwise recursive addition of two integers
+    """
+    keep = (x & y) << 1
+    res = x ^ y
+    if (keep == 0):
+        return res
+    return add(keep, res)
+
+
+print(add(15, 38))
+
+def divide(dividend, divisor):
+    """
+    Divide two integers without using multiplication , division and mod operator
+    """
+    sign = (-1 if ((dividend < 0) ^ (divisor < 0))else 1)
+    dividend = abs(dividend)
+    divisor = abs(divisor)
+    quotient = 0
+    temp = 0
+    for i in range(31, -1, -1):
+        if (temp + (divisor << i) <= dividend):
+            temp += divisor << i
+            quotient |= 1 << i
+    if sign == -1:
+    quotient = -quotient
+    return quotient
+
+
+a = 10
+b = 3
+print(divide(a, b))
+a = 43
+b = -8
+print(divide(a, b))
+
+def toggle_bits(n1, n2):
+    """
+    For every set bit of a number toggle bits of other
+    """
+    return (n1 ^ n2)
+
+
+n1 = 2
+n2 = 5
+print(toggle_bits(n1, n2))
+
+def max_xor_sum(n, k):
+    """
+    Maximum XOR using K numbers from 1 to n
+    """
+    if k == 1:
+        return n
+    res = 1
+    while res <= n:
+        res <<= 1
+    return res - 1
+
+
+n = 4
+k = 3
+print(max_xor_sum(n, k))
+
+def maximum_sum(a, b, n):
+    """
+    Maximum OR sum of sub
+    """
+    sum1 = 0
+    sum2 = 0
+    for i in range(0, n):
+        sum1 |= a[i]
+        sum2 |= b[i]
+    print(sum1 + sum2)
+
+
+A = [1, 2, 4, 3, 2]
+B = [2, 3, 3, 12, 1]
+n = len(A)
+maximum_sum(A, B, n)
+
+def multiply(x, n):
+    """
+    Multiplication with a power of 2
+    """
+    return x << n
+
+
+x = 70
+n = 2
+print(multiply(x, n))
+
+def adjacent_set(n):
+    """
+    Check if a number has two adjacent set bits
+    """
+    return (n & (n >> 1))
+
+
+if __name__ == '__main__':
+    n = 3
+    if (adjacent_set(n)):
+        print("Yes")
+    else:
+        print("No")
+
+def multiply(n, m):
+    """
+    Multiplication of two numbers with shift operator
+    """
+    ans = 0
+    count = 0
+    while (m):
+        if (m % 2 == 1):
+            ans += n << count
+        count += 1
+        m = int(m / 2)
+    return ans
+
+
+if __name__ == '__main__':
+    n = 20
+    m = 13
+    print(multiply(n, m))
+
+def equal_number(A, B):
+    """
+    Compare two integers without using any Comparison operator
+    """
+    return (A ^ B)
+
+
+A = 5
+B = 6
+print(int(not (equal_number(A, B))))
+
+def multiply_ten(n):
+    """
+    Multiply a number with 10 without using multiplication operator
+    """
+    return (n << 1) + (n << 3)
+
+
+n = 50
+print(multiply_ten(n))
+
+def count_values(n):
+    """
+    Equal Sum and XOR
+    """
+    unset_bits = 0
+    while (n):
+        if n & 1 == 0:
+            unset_bits += 1
+        n = n >> 1
+    return 1 << unset_bits
+
+
+if __name__ == '__main__':
+    n = 12
+    print(count_values(n))
+
+def swap_bits(n, p1, p2):
+    """
+    How to swap two bits in a given integer ?
+    """
+    bit1 = (n >> p1) & 1
+    bit2 = (n >> p2) & 1
+    x = (bit1 ^ bit2)
+    x = (x << p1) | (x << p2)
+    result = n ^ x
+    return result
+
+
+if __name__ == '__main__':
+    res = swap_bits(28, 0, 3)
+    print("Result = ", res)
+
+def invert(x):
+    """
+    Write a function that returns 2 for input 1 and returns 1 for 2 |
+    """
+    if (x == 1):
+        return 2
+        else:
+        return 1
+
+def invert_sub(x):
+    """
+    Write a function that returns 2 for input 1 and returns 1 for 2 |
+    """
+    return (3 - x)
+
+def calc__expectation(a, n):
+    """
+    Expectation or expected value of an array
+    """
+    prb = 1 / n
+    sum = 0
+    for i in range(0, n):
+        sum += (a[i] * prb)
+    return float(sum)
+
+
+n = 6
+a = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
+expect = calc__expectation(a, n)
+print("Expectation of array E(X) is : ", expect)
+
+def maximum_updates(arr):
+    """
+    Number of times Maximum and minimum value updated during traversal of array
+    """
+    min = arr[0]
+    max = arr[0]
+    minCount, maxCount = 1, 1
+    for arr in arr:
+        if arr > max:
+            maxCount += 1
+            max = arr
+        if arr < min:
+            minCount += 1
+            min = arr
+    print("Number of times maximum ", end="")
+    print("value updated = ", maxCount)
+    print("Number of times minimum ", end="")
+    print("value updated = ", minCount)
+
+
+if __name__ == "__main__":
+    arr = [10, 5, 20, 22]
+    maximum_updates(arr)
+
+def max_sum(a, n):
+    """
+    Maximize sum of given array by rearranging array such that the difference between adjacent elements is atmost 1
+    """
+    count = [0] * (n + 1)
+    for i in range(0, n):
+        count[min(a[i], n)] += 1
+    size = 0
+    ans = 0
+    for k in range(1, n + 1):
+        while (count[k] > 0 and size < k):
+            size += 1
+            ans += size
+            count[k] -= 1
+        ans += k * count[k]
+    return ans
+
+
+if __name__ == '__main__':
+    arr = [3, 5, 1]
+    n = len(arr)
+    print(max_sum(arr, n))
+
+def count_triplets(N, K):
+    """
+    Count triplets ( a , b , c ) such that a + b , b + c and a + c are all divisible by K
+    """
+    if (K % 2 == 0):
+        x = N // K
+        y = (N + (K // 2)) // K
+        return x * x * x + y * y * y
+    else:
+        x = N // K
+        return x * x * x
+
+
+if __name__ == "__main__":
+    N = 2
+    K = 2
+    print(count_triplets(N, K))
+
+def maximum_result(a, b, c):
+    """
+    Maximize the value of the given expression
+    """
+    countOfNegative = 0
+    Sum = a + b + c
+    product = a * b * c
+    largest = max(a, b, c)
+    smallest = min(a, b, c)
+    if a < 0:
+        countOfNegative += 1
+    if b < 0:
+        countOfNegative += 1
+    if c < 0:
+        countOfNegative += 1
+    if countOfNegative == 0:
+        return (Sum - largest) * largest
+    elif countOfNegative == 1:
+        return (product // smallest) + smallest
+    elif countOfNegative == 2:
+        return (product // largest) + largest
+    elif countOfNegative == 3:
+        return (Sum - smallest) * smallest
+
+
+if __name__ == "__main__":
+    a, b, c = -2, -1, -4
+    print(maximum_result(a, b, c))
+
+'
+
+
+def solve(n, lookup={}):
+    """
+    How to solve a Dynamic Programming Problem ?
+    """
+    if n < 0:
+        return 0
+    if n == 0:
+        return 1
+    if n not in lookup:
+        lookup[n] = (solve(n - 1) + solve(n - 3) + solve(n - 5))
+    return lookup[n]
+
+def number_of_paths(p, q):
+    """
+    Count all possible paths from top left to bottom right of a mXn matrix
+    """
+    dp = [1 for i in range(q)]
+    for i in range(p - 1):
+        for j in range(1, q):
+            dp[j] += dp[j - 1]
+    return dp[q - 1]
+
+
+print(number_of_paths(3, 3))
+
+class Solution:
+
+    """
+    Longest Arithmetic Progression
+    """
+
+    def solve(self, A):
+        ans = 2
+        n = len(A)
+        if n <= 2:
+            return n
+        llap = [2] * n
+        A.sort()
+        for j in range(n - 2, -1, -1):
+            i = j - 1
+            k = j + 1
+            while (i >= 0 and k < n):
+                if A[i] + A[k] == 2 * A[j]:
+                    llap[j] = max(llap[k] + 1, llap[j])
+                    ans = max(ans, llap[j])
+                    i -= 1
+                    k += 1
+                elif A[i] + A[k] < 2 * A[j]:
+                    k += 1
+                else:
+                    i -= 1
+        return ans
+
+
+obj = Solution()
+a = [9, 4, 7, 2, 10]
+print(obj.solve(a))
+
+def ending_with(str, suff):
+    """
+    Count of words ending at the given suffix in Java
+    """
+    c = 0
+    wrd = str.split(" ")
+    for l in wrd:
+        if l.endswith(suff):
+            c += 1
+    return c
+
+
+str = "GeeksForGeeks is a computer science portal for geeks"
+suff = "ks"
+print(ending_with(str, suff))
+
+def is_frequency_equal(string, length):
+    """
+    Character whose frequency is equal to the sum of frequencies of other characters of the given string
+    """
+    if length % 2 == 1:
+        return False
+    freq = [0] * 26
+    for i in range(0, length):
+        freq[ord(string[i]) - ord('a')] += 1
+    for i in range(0, 26):
+        if freq[i] == length // 2:
+            return True
+    return False
+
+
+if __name__ == "__main__":
+    string = "geeksforgeeks"
+    length = len(string)
+    if is_frequency_equal(string, length):
+        print("Yes")
+    else:
+        print("No")
+
+def round(n):
+    """
+    Round the given number to nearest multiple of 10
+    """
+    a = (n // 10) * 10
+    b = a + 10
+    return (b if n - a > b - n else a)
+
+
+n = 4722
+print(round(n))
+
+def decode(string):
+    """
+    Null Cipher
+    """
+    res = ""
+    found = False
+    for character in string:
+        if character == ' ':
+            found = False
+            continue
+        if not found:
+            if character >= 'A' and character <= 'Z' or character >= 'a' and character <= 'z':
+                res += character
+                found = True
+    return res.lower()
+
+
+if __name__ == "__main__":
+    input = "A Step by Step Guide for Placement Preparation by GeeksforGeeks"
+    print("Enciphered Message:", decode(input))
+
+def count9s(number):
+    """
+    Given a number as a string , find the number of contiguous subsequences which recursively add up to 9
+    """
+    n = len(number)
+    for i in range(n):
+        sum = ord(number[i]) - ord('0')
+        if (number[i] == '9'):
+            count += 1
+        for j in range(i + 1, n):
+            sum = (sum + ord(number[j]) - ord('0')) % 9
+            if (sum == 0):
+                count += 1
+    return count
+
+
+if __name__ == "__main__":
+    print(count9s("4189"))
+    print(count9s("1809"))
+
+def count_direct_path(N):
+    """
+    Count of Unique Direct Path Between N Points On a Plane
+    """
+    return N + (N * (N - 3)) // 2
+
+
+if __name__ == "__main__":
+    N = 5
+    print(count_direct_path(N))
+
+def triacontagonal_num(n):
+    """
+    Triacontagon Number
+    """
+    return (28 * n * n - 26 * n) // 2
+
+
+n = 3
+print("3rd triacontagonal Number is = ", triacontagonal_num(n))
+
+def hexacontagon_num(n):
+    """
+    Hexacontagon Number
+    """
+    return (58 * n * n - 56 * n) // 2
+
+
+n = 3
+print("3rd hexacontagon Number is = ", hexacontagon_num(n))
+
+def icosihexagonal_num(n):
+    """
+    Icosihexagonal Number
+    """
+    return (24 * n * n - 22 * n) // 2
+
+
+n = 3
+print("3rd Icosihexagonal Number is = ", icosihexagonal_num(n))
+
+def icosikaioctagonal_num(n):
+    """
+    Icosikaioctagon or Icosioctagon Number
+    """
+    return (26 * n * n - 24 * n) // 2
+
+
+n = 3
+print("3rd icosikaioctagonal Number is = ", icosikaioctagonal_num(n))
+
+def octacontagon_num(n):
+    """
+    Octacontagon Number
+    """
+    return (78 * n * n - 76 * n) // 2
+
+
+n = 3
+print("3rd octacontagon Number is = ", octacontagon_num(n))
+
+from math import sqrt
+
+
+def perimeter(a, b):
+    """
+    perimeter of an Ellipse
+    """
+    perimeter = 0
+    perimeter = (2 * 3.14 * sqrt((a * a + b * b) / (2 * 1.0)))
+    print(perimeter)
+
+
+a = 3
+b = 2
+perimeter(a, b)
+
+def reuleaux_area(a):
+    """
+    Biggest Reuleaux Triangle within A Square
+    """
+    if (a < 0):
+        return -1
+    A = 0.70477 * pow(a, 2)
+    return A
+
+
+if __name__ == "__main__":
+    a = 6
+    print(reuleaux_area(a))
+
+def hexagonside(a):
+    """
+    Largest hexagon that can be inscribed within a square
+    """
+    if (a < 0):
+        return -1
+    x = 0.5176 * a
+    return x
+
+
+a = 6
+print(hexagonside(a))
+
+def hexagonside(a):
+    """
+    Largest hexagon that can be inscribed within an equilateral triangle
+    """
+    if a < 0:
+        return -1
+    x = a // 3
+    return x
+
+
+a = 6
+print(hexagonside(a))
+
+def find_segment(n, m, segment_length):
+    """
+    Find middle point segment from given segment lengths
+    """
+    meet_point = (1.0 * n) / 2.0
+    sum = 0
+    segment_number = 0
+    for i in range(0, m, 1):
+        sum += segment_length[i]
+        if (sum == meet_point):
+            segment_number = -1
+            break
+        if (sum > meet_point):
+            segment_number = i + 1
+            break
+    return segment_number
+
+
+if __name__ == '__main__':
+    n = 13
+    m = 3
+    segment_length = [3, 2, 8]
+    ans = find_segment(n, m, segment_length)
+    print(ans)
+
+def count_max_intersect(n):
+    """
+    Maximum points of intersection n lines
+    """
+    return int(n * (n - 1) / 2)
+
+
+if __name__ == '__main__':
+    n = 8
+    print(count_max_intersect(n))
+
+def checkpoint(h, k, x, y, a):
+    """
+    Check if a point is inside , outside or on the parabola
+    """
+    p = pow((y - k), 2) - 4 * a * (x - h)
+    return p
+
+
+if __name__ == "__main__":
+    h = 0
+    k = 0
+    x = 2
+    y = 1
+    a = 4
+    if checkpoint(h, k, x, y, a) > 0:
+        print("Outside")
+    elif checkpoint(h, k, x, y, a) == 0:
+        print("Ontheparabola")
+    else:
+        print("Inside")
+
+import math
+
+
+def checkpoint(h, k, x, y, a, b):
+    """
+    Check if a point is inside , outside or on the ellipse
+    """
+    p = ((math.pow((x - h), 2) // math.pow(a, 2)) +
+         (math.pow((y - k), 2) // math.pow(b, 2)))
+    return p
+
+
+if __name__ == "__main__":
+    h = 0
+    k = 0
+    x = 2
+    y = 1
+    a = 4
+    b = 5
+    if (checkpoint(h, k, x, y, a, b) > 1):
+        print("Outside")
+    elif (checkpoint(h, k, x, y, a, b) == 1):
+        print("On the ellipse")
+    else:
+        print("Inside")
+
+def circlearea(a, b):
+    """
+    Area of circle inscribed within rhombus
+    """
+    if (a < 0 or b < 0):
+        return -1
+    A = ((3.14 * pow(a, 2) * pow(b, 2)) / (4 * (pow(a, 2) + pow(b, 2))))
+    return A
+
+
+if __name__ == "__main__":
+    a = 8
+    b = 10
+    print(circlearea(a, b))
+
+def circlearea(l, b):
+    """
+    The biggest possible circle that can be inscribed in a rectangle
+    """
+    if (l < 0 or b < 0):
+        return -1
+    if (l < b):
+        return 3.14 * pow(l // 2, 2)
+    else:
+        return 3.14 * pow(b // 2, 2)
+
+
+if __name__ == "__main__":
+    l = 4
+    b = 8
+    print(circlearea(l, b))
+
+def centered_cube(n):
+    """
+    Centered cube number
+    """
+    return (2 * n + 1) * (n * n + n + 1)
+
+
+if __name__ == '__main__':
+    n = 3
+    print(n, "th Centered cube " + "number : ", centered_cube(n))
+    n = 10
+    print(n, "th Centered cube " + "number : ", centered_cube(n))
+
+def center(x1, x2, y1, y2):
+    """
+    Find the center of the circle using endpoints of diameter
+    """
+    print(int((x1 + x2) / 2), end="")
+    print(",", int((y1 + y2) / 2))
+
+
+x1 = -9
+y1 = 3
+x2 = 5
+y2 = -7
+center(x1, x2, y1, y2)
+
+import math
+
+
+def vol_of_octahedron(side):
+    """
+    Program to calculate volume of Octahedron
+    """
+    return ((side * side * side) * (math.sqrt(2) / 3))
+
+
+side = 3
+print("Volume of octahedron =", round(vol_of_octahedron(side), 4))
+
+def count(N):
+    """
+    Minimum count of consecutive integers till N whose bitwise AND is 0 with N
+    """
+    a = bin(N)
+    a = a[2:]
+    m = len(a) - 1
+    res = N - (2 ** m - 1)
+    return res
+
+
+N = 18
+print(count(N))
+
+def find_cycles(N):
+    """
+    Number of cycles formed by joining vertices of n sided polygon at the center
+    """
+    res = 0
+    finalResult = 0
+    val = 2 * N - 1
+    s = val
+    res = (N - 1) * (N - 2)
+    finalResult = res + s
+    return finalResult
+
+
+if __name__ == '__main__':
+    N = 5
+    print(find_cycles(N))
+
+def find(a, n, k):
+    """
+    Split a given array into K subarrays minimizing the difference between their maximum and minimum
+    """
+    v = []
+    for i in range(1, n):
+        v.append(a[i - 1] - a[i])
+    v.sort()
+    res = a[n - 1] - a[0]
+    for i in range(k - 1):
+        res += v[i]
+    return res
+
+
+arr = [4, 8, 15, 16, 23, 42]
+N = len(arr)
+K = 3
+print(find(arr, N, K))
+
+def smallest_div(n):
+    """
+    Find the Smallest number that divides X ^ X
+    """
+    i = 2
+    while i * i <= n:
+        if (n % i == 0):
+            return i
+        i += 1
+    return n
+
+
+if __name__ == "__main__":
+    X = 385
+    ans = smallest_div(X)
+    print(ans)
+
+def power(x, y, p):
+    """
+    Find number of magical pairs of string of length L
+    """
+    res = 1
+    x = x % p
+    while (y > 0):
+        if (y % 2 == 1):
+            res = (res * x) % p
+        x = (x * x) % p
+    return res
+
+
+L = 2
+P = pow(10, 9)
+ans = power(325, L, P)
+print(ans)
+
+MAXN = 30
+
+
+def count_max_length(N):
+    """
+    Longest substring of only 4 's from the first N characters of the infinite string
+    """
+    pre = [0 for i in range(MAXN)]
+    p = 1
+    pre[0] = 0
+    for i in range(1, MAXN, 1):
+        p *= 2
+        pre[i] = pre[i - 1] + i * p
+    for i in range(1, MAXN, 1):
+        if (pre[i] >= N):
+            ind = i
+            break
+    x = N - pre[ind - 1]
+    y = 2 * ind - 1
+    if (x >= y):
+        res = min(x, y)
+    else:
+        res = max(x, 2 * (ind - 2) + 1)
+    return res
+
+
+if __name__ == '__main__':
+    N = 25
+    print(count_max_length(N))
+
+def minimum(N, K):
+    """
+    minimum count of numbers needed from 1 to N that yields the sum as K
+    """
+    sum = N * (N + 1) // 2
+    if (K > sum):
+        return -1
+    if (K <= N):
+        return 1
+    sum = 0
+    count = 0
+    while (N >= 1 and sum < K):
+        count += 1
+        sum += N
+        N -= 1
+    return count
+
+
+if __name__ == '__main__':
+    N = 5
+    K = 10
+    print(minimum(N, K))
+
+def count(N, K):
+    """
+    Maximize X such that sum of numbers in range [ 1 , X ] is at most K
+    """
+    if (K == 0):
+        return 0
+    res = 0
+    low = 1
+    high = N
+    while (low <= high):
+        mid = (low + high) // 2
+        sum = (mid * mid + mid) // 2
+        if (sum <= K):
+            res = max(res, mid)
+            low = mid + 1
+        else:
+            high = mid - 1
+    return res
+
+
+if __name__ == '__main__':
+    N = 6
+    K = 14
+    print(count(N, K))
+
+def find_element(A, N, X):
+    """
+    Check if an element is present in an array using at most floor ( N / 2 ) + 2 comparisons
+    """
+    i = 0
+    Comparisons = 0
+    T = 1
+    Found = "No"
+    Comparisons += 1
+    if (N % 2 == 1):
+        i = 1
+        T *= (A[0] - X)
+    while (i < N):
+        Comparisons += 1
+        T *= (A[i] - X)
+        T *= (A[i + 1] - X)
+        i += 2
+    Comparisons += 1
+    if (T == 0):
+        print("Yes", Comparisons)
+    else:
+        print("No")
+
+
+if __name__ == '__main__':
+    A = [-3, 5, 11, 3, 100, 2, 88, 22, 7, 900, 23, 4, 1]
+    N = len(A)
+    X = 1
+    find_element(A, N, X)
+
+def find(arr, N, key):
+    """
+    Search an element in a sorted array formed by reversing subarrays from a random index
+    """
+    l = 0
+    h = N - 1
+    while l <= h:
+        mid = (l + h) // 2
+        if arr[mid] == key:
+            return mid
+        if arr[l] >= arr[mid]:
+            if arr[l] >= key >= arr[mid]:
+                h = mid - 1
+            else:
+                l = mid + 1
+        else:
+            if arr[mid] >= key >= arr[h]:
+                l = mid + 1
+            else:
+                h = mid - 1
+    return -1
+
+
+if __name__ == "__main__":
+    arr = [10, 8, 6, 5, 2, 1, 13, 12]
+    N = len(arr)
+    key = 8
+    ans = find(arr, N, key)
+    print(ans)
+
+def max_items(n, m, a, b, K):
+    """
+    Maximum elements that can be removed from front of two arrays such that their sum is at most K
+    """
+    count = 0
+    A = [0 for i in range(n + 1)]
+    B = [0 for i in range(m + 1)]
+    for i in range(1, n + 1, 1):
+        A[i] = a[i - 1] + A[i - 1]
+    for i in range(1, m + 1, 1):
+        B[i] = b[i - 1] + B[i - 1]
+    for i in range(n + 1):
+        if (A[i] > K):
+            break
+        rem = K - A[i]
+        j = 0
+        lo = 0
+        hi = m
+        while (lo <= hi):
+            mid = (lo + hi) // 2
+            if (B[mid] <= rem):
+                j = mid
+                lo = mid + 1
+            else:
+                hi = mid - 1
+        count = max(j + i, count)
+    print(count)
+
+
+if __name__ == '__main__':
+    n = 4
+    m = 5
+    K = 7
+    A = [2, 4, 7, 3]
+    B = [1, 9, 3, 4, 5]
+    max_items(n, m, A, B, K)
+
+def minimum_swaps(arr, n):
+    """
+    Minimize swaps required to make the first and last elements the largest and smallest elements in the array respectively
+    """
+    count = 0
+    max_el = max(arr)
+    min_el = min(arr)
+    if (min_el == max_el):
+        return 0
+    index_max = -1
+    index_min = -1
+    for i in range(n):
+        if (arr[i] == max_el and index_max == -1):
+            index_max = i
+        if (arr[i] == min_el):
+            index_min = i
+    count += index_max
+    count += (n - 1 - index_min)
+    if (index_min < index_max):
+        count -= 1
+    return count
+
+
+if __name__ == '__main__':
+    arr = [2, 4, 1, 6, 5]
+    N = len(arr)
+    print(minimum_swaps(arr, N))
+
+def least_weighted_sum_path(n, edges, src, dst, K):
+    """
+    Minimum cost path from source node to destination node via K intermediate nodes
+    """
+    graph = [[]for i in range(3)]
+    for edge in edges:
+        graph[edge[0]].append([edge[1], edge[2]])
+    pq = []
+    costs = [[10 ** 9 for i in range(K + 2)]for i in range(n)]
+    costs[src][K + 1] = 0
+    pq.append([0, src, K + 1])
+    pq = sorted(pq)[::-1]
+    while (len(pq) > 0):
+        top = pq[-1]
+        del pq[-1]
+        if (top[1] == dst):
+            return top[0]
+        if (top[2] == 0):
+            continue
+        for neighbor in graph[top[1]]:
+            if (costs[neighbor[0]][top[2] - 1] < neighbor[1] + top[0]):
+                continue
+            costs[neighbor[0]][top[2] - 1] = neighbor[1] + top[0]
+            pq.append([neighbor[1] + top[0], neighbor[0], top[2] - 1])
+        pq = sorted(pq)[::-1]
+    return -1
+
+
+if __name__ == '__main__':
+    n, src, dst, k = 3, 0, 2, 1
+    edges = [[0, 1, 100], [1, 2, 100], [0, 2, 500]]
+    print(least_weighted_sum_path(n, edges, src, dst, k))
+
+def kth_character(S, N, K):
+    """
+    Frequency of lexicographically Kth smallest character in the a string
+    """
+    strarray = [char for char in S]
+    strarray.sort()
+    ch = strarray[K - 1]
+    count = 0
+    for c in strarray:
+        if (c == ch):
+            count += 1
+    print(count)
+
+
+if __name__ == '__main__':
+    S = "geeksforgeeks"
+    N = len(S)
+    K = 3
+    kth_character(S, N, K)
+
+def max_non_emp_sub_seq(a, n):
+    """
+    Maximum Sum Subsequence
+    """
+    sum = 0
+    maxm = max(a)
+    if (maxm <= 0):
+        return maxm
+    for i in range(n):
+        if (a[i] > 0):
+            sum += a[i]
+    return sum
+
+
+if __name__ == '__main__':
+    arr = [-2, 11, -4, 2, -3, -10]
+    N = len(arr)
+    print(max_non_emp_sub_seq(arr, N))
+
+def find_intersecting_range(tup, N, ranges):
+    """
+    Find a pair of intersecting ranges from a given array
+    """
+    curr = 0
+    currPos = 0
+    for i in range(N):
+        x = ranges[i][0]
+        y = ranges[i][1]
+        tup.append([[x, y], i + 1])
+    tup = sorted(tup)
+    curr = tup[0][0][1]
+    currPos = tup[0][1]
+    for i in range(1, N):
+        Q = tup[i - 1][0][0]
+        R = tup[i][0][0]
+        if (Q == R):
+            if (tup[i - 1][0][1] < tup[i][0][1]):
+                print(tup[i - 1][1], tup[i][1])
+            else:
+                print(tup[i][1], tup[i - 1][1])
+            return
+        T = tup[i][0][1]
+        if (T <= curr):
+            print(tup[i][1], currPos)
+            return
+        else:
+            curr = T
+            currPos = tup[i][1]
+    print("-1 -1")
+
+
+if __name__ == '__main__':
+    N = 5
+    ranges = [[1, 5], [2, 10], [3, 10], [2, 2], [2, 15]]
+    find_intersecting_range([], N, ranges)
+
+def find_index(arr, n, B):
+    """
+    Search insert position of K in a sorted array
+    """
+    start = 0
+    end = n - 1
+    while start <= end:
+        mid = (start + end) // 2
+        if arr[mid] == K:
+            return mid
+        elif arr[mid] < K:
+            start = mid + 1
+        else:
+            end = mid - 1
+    return end + 1
+
+
+arr = [1, 3, 5, 6]
+n = len(arr)
+K = 2
+print(find_index(arr, n, K))
+
+def binary_search(arr, N, X):
+    """
+    Search an element in a reverse sorted array
+    """
+    start = 0
+    end = N
+    while (start <= end):
+        mid = start + (end - start) // 2
+        if (X == arr[mid]):
+            return mid
+        elif (X < arr[mid]):
+            start = mid + 1
+        else:
+            end = mid - 1
+    return -1
+
+
+if __name__ == '__main__':
+    arr = [5, 4, 3, 2, 1]
+    N = len(arr)
+    X = 5
+    print(binary_search(arr, N, X))
+
+def check_hex(s):
+    """
+    Check if a string represents a hexadecimal number or not
+    """
+    for ch in s:
+        if ((ch < '0' or ch > '9') and (ch < 'A' or ch > 'F')):
+            print("No")
+            return
+    print("Yes")
+
+
+s = "BF57C"
+check_hex(s)
+
+def check_same_diag(x, y):
+    """
+    Check if two elements of a matrix are on the same diagonal or not
+    """
+    for i in range(m):
+        for j in range(n):
+            if li[i][j] == x:
+                I, J = i, j
+            if li[i][j] == y:
+                P, Q = i, j
+    if P - Q == I - J or P + Q == I + J:
+        print("YES")
+    else:
+        print("NO")
+
+
+if __name__ == "__main__":
+    m, n = 6, 5
+    li = [[32, 94, 99, 26, 82], [51, 69, 52, 63, 17], [90, 36, 88, 55, 33], [
+        93, 42, 73, 39, 28], [81, 31, 83, 53, 10], [12, 29, 85, 80, 87]]
+    x, y = 42, 80
+    check_same_diag(x, y)
+
+def calc_distance(A, B, n):
+    """
+    Distance Traveled by Two Trains together in the same Direction
+    """
+    distance_traveled_A = 0
+    distance_traveled_B = 0
+    answer = 0
+    for i in range(5):
+        distance_traveled_A += A[i]
+        distance_traveled_B += B[i]
+        if ((distance_traveled_A == distance_traveled_B) and (A[i] == B[i])):
+            answer += A[i]
+    return answer
+
+
+A = [1, 2, 3, 2, 4]
+B = [2, 1, 3, 1, 4]
+N = len(A)
+print(calc_distance(A, B, N))
+
+from collections import defaultdict
+
+
+def get_count(N, s):
+    """
+    Count of pairs of strings whose concatenation forms a palindromic string
+    """
+    mp = defaultdict(lambda: 0)
+    ans = 0
+    for i in range(N):
+        a = [0] * 26
+        for j in range(len(s[i])):
+            a[ord(s[i][j]) - ord('a')] += 1
+        for j in range(26):
+            a[j] = a[j] % 2
+        ans += mp[tuple(a)]
+        for j in range(26):
+            changedCount = a[:]
+            if (a[j] == 0):
+                changedCount[j] = 1
+            else:
+                changedCount[j] = 0
+            ans += mp[tuple(changedCount)]
+        mp[tuple(a)] += 1
+    return ans
+
+
+if __name__ == '__main__':
+    N = 6
+    A = ["aab", "abcac", "dffe", "ed", "aa", "aade"]
+    print(get_count(N, A))
+
+def checkrules(s):
+    """
+    Check if given Binary string follows then given condition or not
+    """
+    if len(s) == 0:
+        return True
+    if s[0] != '1':
+        return False
+    if len(s) > 2:
+        if s[1] == '0' and s[2] == '0':
+            return checkrules(s[3:])
+    return checkrules(s[1:])
+
+
+if __name__ == '__main__':
+    s = '1111'
+    if checkrules(s):
+        print('valid string')
+    else:
+        print('invalid string')
+
+def split_array(arr, N):
+    """
+    Partition a set into two subsets such that difference between max of one and min of other is minimized
+    """
+    arr = sorted(arr)
+    result = 10 ** 9
+    for i in range(1, N):
+        result = min(result, arr[i] - arr[i - 1])
+    return result
+
+
+if __name__ == '__main__':
+    arr = [3, 1, 2, 6, 4]
+    N = len(arr)
+    print(split_array(arr, N))
+
+def find_value(R, C):
+    """
+    Find the element at R ' th ▁ row ▁ and ▁ C ' th column in given a 2D pattern
+    """
+    k = (R * (R - 1)) // 2 + 1
+    diff = R + 1
+    for i in range(1, C):
+        k = (k + diff)
+        diff += 1
+    return k
+
+
+if __name__ == "__main__":
+    R = 4
+    C = 4
+    k = find_value(R, C)
+    print(k)
+
+def find_minimum_k(a, n, s):
+    """
+    Minimum K such that sum of array elements after division by K does not exceed S
+    """
+    maximum = a[0]
+    for i in range(n):
+        maximum = max(maximum, a[i])
+    low = 1
+    high = maximum + 1
+    ans = high
+    while (low <= high):
+        mid = (low + high) // 2
+        sum = 0
+        for i in range(n):
+            sum += (a[i] // mid)
+        if (sum > s):
+            low = mid + 1
+        else:
+            ans = min(ans, mid)
+            high = mid - 1
+    return ans
+
+
+a = [10, 7, 8, 10, 12, 19]
+n = len(a)
+s = 27
+print(find_minimum_k(a, n, s))
+
+def max_sum(arr, n, K):
+    """
+    Find maximum sum taking every Kth element in the array
+    """
+    maximum = -2 ** 32
+    sum = [0] * n
+    for i in range(n - 1, -1, -1):
+        if (i + K < n):
+            sum[i] = sum[i + K] + arr[i]
+        else:
+            sum[i] = arr[i]
+        maximum = max(maximum, sum[i])
+    return maximum
+
+
+arr = [3, 6, 4, 7, 2]
+n = len(arr)
+K = 2
+print(max_sum(arr, n, K))
+
+def find_min_difference(arr, n):
+    """
+    Minimize the maximum minimum difference after one removal from array
+    """
+    arr.sort()
+    diff1 = arr[n - 1] - arr[1]
+    diff2 = arr[n - 2] - arr[0]
+    return min(diff1, diff2)
+
+
+if __name__ == "__main__":
+    arr = [1, 2, 4, 3, 4]
+    n = len(arr)
+    print(find_min_difference(arr, n))
+
+def col_max_diff(mat):
+    """
+    Find pair with maximum difference in any column of a Matrix
+    """
+    max_diff = 0
+    for i in range(N):
+        max_val = mat[0][i]
+        min_val = mat[0][i]
+        for j in range(1, N):
+            max_val = max(max_val, mat[j][i])
+            min_val = min(min_val, mat[j][i])
+        max_diff = max(max_diff, max_val - min_val)
+    return max_diff
+
+
+if __name__ == "__main__":
+    mat = [[1, 2, 3, 4, 5], [5, 3, 5, 4, 0], [
+        5, 6, 7, 8, 9], [0, 6, 3, 4, 12], [9, 7, 12, 4, 3]]
+    print("Max difference :", col_max_diff(mat))
+
+def search(ar, size):
+    """
+    Find the Missing Number in a sorted array
+    """
+    a = 0
+    b = size - 1
+    mid = 0
+    while b > a + 1:
+        mid = (a + b) // 2
+        if (ar[a] - a) != (ar[mid] - mid):
+            b = mid
+        elif (ar[b] - b) != (ar[mid] - mid):
+            a = mid
+    return ar[a] + 1
+
+
+a = [1, 2, 3, 4, 5, 6, 8]
+n = len(a)
+print("Missing number:", search(a, n))
+
+def count_triplets_less_than_l(n, L, arr):
+    """
+    Ways to choose three points with distance between the most distant points <= L
+    """
+    arr.sort()
+    ways = 0
+    for i in range(n):
+        for j in range(i + 1, n):
+            for k in range(j + 1, n):
+                mostDistantDistance = arr[k] - arr[i]
+                if (mostDistantDistance <= L):
+                    ways += 1
+    return ways
+
+
+if __name__ == "__main__":
+    arr = [1, 2, 3, 4]
+    n = len(arr)
+    L = 3
+    ans = count_triplets_less_than_l(n, L, arr)
+    print("Total Number of ways =", ans)
+
+def count_max_set_bits(left, right):
+    """
+    Smallest number whose set bits are maximum in a given range
+    """
+    while (left | (left + 1)) <= right:
+        left |= left + 1
+    return left
+
+
+l = 1
+r = 5
+print(count_max_set_bits(l, r))
+l = 1
+r = 10
+print(count_max_set_bits(l, r))
+
+def maximum_mex(arr, N):
+    """
+    Rearrange array elements to maximize the sum of MEX of all prefix arrays
+    """
+    ans = []
+    arr = sorted(arr)
+    for i in range(N):
+        if (i == 0 or arr[i] != arr[i - 1]):
+            ans.append(arr[i])
+    for i in range(N):
+        if (i > 0 and arr[i] == arr[i - 1]):
+            ans.append(arr[i])
+    for i in range(N):
+        print(ans[i], end=" ")
+
+
+if __name__ == '__main__':
+    arr = [1, 0, 0]
+    N = len(arr)
+    maximum_mex(arr, N)
+
+def getcount(arr, N):
+    """
+    Count triplets from an array which can form quadratic equations with real roots
+    """
+    count = 0
+    if (N < 3):
+        return 0
+    for b in range(0, N):
+        for a in range(0, N):
+            if (a == b):
+                continue
+            for c in range(0, N):
+                if (c == a or c == b):
+                    continue
+                d = arr[b] * arr[b] // 4
+                if (arr[a] * arr) <= d:
+                    count += 1
+    return count
+
+
+arr = [1, 2, 3, 4, 5]
+N = len(arr)
+print(getcount(arr, N))
+
+def check(a, b, Na, Nb, k, m):
+    """
+    Check if X and Y elements can be selected from two arrays respectively such that the maximum in X is less than the minimum in Y
+    """
+    if (Na < k or Nb < m):
+        return "No"
+    a.sort()
+    a.sort()
+    if (a[k - 1] < b[Nb - m]):
+        return "Yes"
+    return "No"
+
+
+arr1 = [1, 2, 3]
+arr2 = [3, 4, 5]
+N = len(arr1)
+M = len(arr2)
+X = 2
+Y = 1
+print(check(arr1, arr2, N, M, X, Y))
+
+def split_array(arr, N):
+    """
+    Partition array into two subsets with minimum Bitwise XOR between their maximum and minimum
+    """
+    arr = sorted(arr)
+    result = 10 ** 9
+    for i in range(1, N):
+        result = min(result, arr[i] ^ arr[i - 1])
+    return result
+
+
+if __name__ == '__main__':
+    arr = [3, 1, 2, 6, 4]
+    N = len(arr)
+    print(split_array(arr, N))
+
+from bisect import bisect_left
+
+
+def maximum_shops(opening, closing, n, k):
+    """
+    Activity selection problem with K persons
+    """
+    a = [[0, 0]for i in range(n)]
+    for i in range(n):
+        a[i][0] = opening[i]
+        a[i][1] = closing[i]
+    a = sorted(a)
+    count = 1
+    st = {}
+    for i in range(n):
+        flag = False
+        if (len(st) == 0):
+            ar = list(st.keys())
+            it = bisect_left(ar, a[i][0])
+            if (it != 0):
+                it -= 1
+                if (ar[it] <= a[i][0]):
+                    del st[it]
+                    st[a[i][1]] = 1
+                    count += 1
+                    flag = True
+        if (len(st) < k and flag == False):
+            st[a[i][1]] = 1
+            count += 1
+    return count
+
+
+if __name__ == '__main__':
+    S = [1, 8, 3, 2, 6]
+    E = [5, 10, 6, 5, 9]
+    K, N = 2, len(S)
+    print(maximum_shops(S, E, N, K))
+
+def count_pairs(A, N):
+    """
+    Count pairs with Bitwise XOR greater than both the elements of the pair
+    """
+    count = 0
+    for i in range(0, N):
+        for j in range(i + 1, N):
+            xo = (A[i] ^ A[j])
+            mx = max(A[i], A[j])
+            if (xo > mx):
+                count += 1
+    print(count)
+
+
+if __name__ == '__main__':
+    arr = [2, 4, 3]
+    N = len(arr)
+    count_pairs(arr, N)
+
+MOD = 1000000007
+
+
+def solve(values, salary):
+    """
+    Count ways to distribute exactly one coin to each worker
+    """
+    ret = 1
+    amt = 0
+    values = sorted(values)
+    salary = sorted(salary)
+    while (len(salary) > 0):
+        while ((len(values) and values[-1] >= salary[-1])):
+            amt += 1
+            del values[-1]
+        if (amt == 0):
+            return 0
+        ret *= amt
+        amt -= 1
+        ret %= MOD
+        del salary[-1]
+    return ret
+
+
+if __name__ == '__main__':
+    values = [1, 2]
+    salary = [2]
+    print(solve(values, salary))
+
+def count_pairs(arr, n):
+    """
+    Count of index pairs with equal elements in an array
+    """
+    ans = 0
+    arr.sort()
+    left = 0
+    right = 1
+    while (right < n):
+        if (arr[left] == arr[right]):
+            ans += right - left
+        else:
+            left = right
+        right += 1
+    return ans
+
+
+if __name__ == "__main__":
+    arr = [2, 2, 3, 2, 3]
+    N = len(arr)
+    print(count_pairs(arr, N))
+
+def calculate_minimum_split(a, k):
+    """
+    Divide a sorted array in K parts with sum of difference of max and min minimized in each part
+    """
+    p = []
+    n = len(a)
+    for i in range(1, n):
+        p.append(a[i] - a[i - 1])
+    p.sort(reverse=True)
+    min_sum = sum(p[:k - 1])
+    res = a[n - 1] - a[0] - min_sum
+    return res
+
+
+/*Driver code * /
+if __name__ == "__main__":
+    arr = [4, 8, 15, 16, 23, 42]
+    K = 3
+    print(calculate_minimum_split(arr, K))
+
+import numpy as np
+N = 100
+INF = 1000000
+dp = np.zeros((N, N))
+vis = np.zeros((N, N))
+
+
+def find_sum(arr, n, k, l, r):
+    """
+    Minimize the sum of differences of consecutive elements after removing exactly K elements
+    """
+    if ((l) + (n - 1 - r) == k):
+        return arr[r] - arr[l]
+    if (vis[l][r]):
+        return dp[l][r]
+    vis[l][r] = 1
+    dp[l][r] = min(find_sum(arr, n, k, l, r - 1), find_sum(arr, n, k, l + 1, r))
+    return dp[l][r]
+
+
+if __name__ == "__main__":
+    arr = [1, 2, 100, 120, 140]
+    k = 2
+    n = len(arr)
+    print(find_sum(arr, n, k, 0, n - 1))
+
+def get_number(n, k):
+    """
+    Find Kth element in an array containing odd elements first and then even elements
+    """
+    if (n % 2 == 0):
+        pos = n // 2
+    else:
+        pos = (n // 2) + 1
+    if (k <= pos):
+        return (k * 2 - 1)
+    else:
+        return ((k - pos) * 2)
+
+
+if __name__ == "__main__":
+    n = 8
+    k = 5
+    print(get_number(n, k))
+
+def count_points(n, m, a, b, x, y):
+    """
+    Maximum number of segments that can contain the given points
+    """
+    a.sort()
+    b.sort()
+    j, count = 0, 0
+    for i in range(0, n):
+        while j < m:
+            if a[i] + y < b[j]:
+                break
+            if (b[j] >= a[i] - x and b[j] <= a[i] + y):
+                count += 1
+                j += 1
+                break
+            else:
+                j += 1
+    return count
+
+
+if __name__ == "__main__":
+    x, y = 1, 4
+    a = [1, 5]
+    n = len(a)
+    b = [1, 1, 2]
+    m = len(b)
+    print(count_points(n, m, a, b, x, y))
+
+def min_operations(n, m, k, matrix):
+    """
+    Minimum operations of given type to make all elements of a matrix equal
+    """
+    arr = []
+    if (matrix[0][0] < 0):
+        mod = k - (abs(matrix[0][0]) % k)
+    else:
+        mod = matrix[0][0] % k
+    for i in range(n):
+        for j in range(m):
+            arr.append(matrix[i][j])
+            val = matrix[i][j]
+            if (val < 0):
+                res = k - (abs(val) % k)
+                if (res != mod):
+                    return -1
+            else:
+                foo = matrix[i][j]
+                if (foo % k != mod):
+                    return -1
+    arr.sort()
+    median = arr[(n * m) // 2]
+    min_operations = 0
+    for i in range(n * m):
+        min_operations += abs(arr[i] - median) // k
+    if ((n * m) % 2 == 0):
+        median2 = arr[((n * m) // 2) - 1]
+        min_operations2 = 0
+        for i in range(n * m):
+            min_operations2 += abs(arr[i] - median2) / k
+        min_operations = min(min_operations, min_operations2)
+    return min_operations
+
+
+if __name__ == "__main__":
+    matrix = [[2, 4, 6], [8, 10, 12], [14, 16, 18], [20, 22, 24]]
+    n = len(matrix)
+    m = len(matrix[0])
+    k = 2
+    print(min_operations(n, m, k, matrix))
+
+def count_sequences(arr, n):
+    """
+    Minimum number of consecutive sequences that can be formed in an array
+    """
+    count = 1
+    arr.sort()
+    for i in range(n - 1):
+        if (arr[i] + 1 != arr[i + 1]):
+            count += 1
+    return count
+
+
+if __name__ == "__main__":
+    arr = [1, 7, 3, 5, 10]
+    n = len(arr)
+    print(count_sequences(arr, n))
+
+def minimum_moves(a, n):
+    """
+    Minimum number of increment / decrement operations such that array contains all elements from 1 to N
+    """
+    operations = 0
+    a.sort(reverse=False)
+    for i in range(0, n, 1):
+        operations = operations + abs(a[i] - (i + 1))
+    return operations
+
+
+if __name__ == '__main__':
+    arr = [5, 3, 2]
+    n = len(arr)
+    print(minimum_moves(arr, n))
+
+def max_array_cover(a, n, x):
+    """
+    Covering maximum array elements with given value
+    """
+    a.sort()
+    cc = 0
+    s = 0
+    for i in range(n):
+        s += a[i]
+        if (s > x):
+            break
+        cc += 1
+    if (sum(a) == x):
+        return n
+    else:
+        if (cc == n):
+            return n - 1
+        else:
+            return cc
+
+
+if __name__ == '__main__':
+    n, x = 3, 70
+    a = [10, 20, 30]
+    print(max_array_cover(a, n, x))
+
+def maximum_sop(a, b):
+    """
+    Maximum Sum of Products of Two Arrays
+    """
+    sop = 0
+    n = len(a)
+    a.sort()
+    b.sort()
+    for i in range(n):
+        sop += a[i] * b[i]
+    return sop
+
+
+if __name__ == "__main__":
+    A = [1, 2, 3]
+    B = [4, 5, 1]
+    print(maximum_sop(A, B))
+
+def count_triplets(arr, n, m):
+    """
+    Count number of triplets with product equal to given number
+    """
+    count = 0
+    arr.sort()
+    for end in range(n - 1, 1, -1):
+        start = 0
+        mid = end - 1
+        while (start < mid):
+            prod = (arr[end] * arr[start] * arr[mid])
+            if (prod > m):
+                mid -= 1
+            elif (prod < m):
+                start += 1
+            elif (prod == m):
+                count += 1
+                mid -= 1
+                start += 1
+    return count
+
+
+if __name__ == "__main__":
+    arr = [1, 1, 1, 1, 1, 1]
+    n = len(arr)
+    m = 1
+    print(count_triplets(arr, n, m))
+
+def distribution(arr, n):
+    """
+    Equally divide into two sets such that one set has maximum distinct elements
+    """
+    resources = set()
+    for i in range(n):
+        resources.add(arr[i])
+    return min(len(resources), n // 2)
+
+
+if __name__ == '__main__':
+    arr = [1, 1, 2, 1, 3, 4]
+    n = len(arr)
+    print(distribution(arr, n), "")
+
+def check_fitting_arrays(A, B, N):
+    """
+    Check whether an array can be fit into another array rearranging the elements in the array
+    """
+    A = sorted(A)
+    B = sorted(B)
+    for i in range(N):
+        if (A[i] > B[i]):
+            return False
+    return True
+
+
+A = [7, 5, 3, 2]
+B = [5, 4, 8, 7]
+N = len(A)
+if (check_fitting_arrays(A, B, N)):
+    print("YES")
+else:
+    print("NO")
+
+def maximum_toys(cost, N, K):
+    """
+    Maximise the number of toys that can be purchased with amount K
+    """
+    count = 0
+    sum = 0
+    cost.sort(reverse=False)
+    for i in range(0, N, 1):
+        if (sum + cost[i] <= K):
+            sum = sum + cost[i]
+            count += 1
+    return count
+
+
+if __name__ == '__main__':
+    K = 50
+    cost = [1, 12, 5, 111, 200, 1000, 10, 9, 12, 15]
+    N = len(cost)
+    print(maximum_toys(cost, N, K))
+
+def almost_sort(A, n):
+    """
+    Check if given array is almost sorted ( elements are at
+    """
+    i = 0
+    while i < n - 1:
+        if A[i] > A[i + 1]:
+            A[i], A[i + 1] = A[i + 1], A[i]
+            i += 1
+        i += 1
+    for i in range(0, n - 1):
+        if A[i] > A[i + 1]:
+            return False
+    return True
+
+
+if __name__ == "__main__":
+    A = [1, 3, 2, 4, 6, 5]
+    n = len(A)
+    if almost_sort(A, n):
+        print("Yes")
+    else:
+        print("No")
+
+def distinct_count(arr, n):
+    """
+    Absolute distinct count in a sorted array
+    """
+    s = set()
+    for i in range(n):
+        s.add(abs(arr[i]))
+    return len(s)
+
+
+arr = [-2, -1, 0, 1, 1]
+n = len(arr)
+print("Count of absolute distinct values:", distinct_count(arr, n))
+
+def gen_string(N):
+    """
+    Lexicographically smallest numeric string having odd digit counts
+    """
+    ans = ""
+    if (N % 2 == 0):
+        ans = "".join("1"for i in range(N - 1))
+        ans = ans + "2"
+    else:
+        ans = "".join("1"for i in range(N))
+    return ans
+
+
+if __name__ == "__main__":
+    N = 5
+    print(gen_string(N))
+
+def find(arr, N):
+    """
+    Minimize moves required to make array elements equal by incrementing and decrementing pairs
+    """
+    Sum = sum(arr)
+    if Sum % N:
+        return -1
+    else:
+        k = Sum // N
+        ans = 0
+        i = 0
+        while i < N:
+            ans = ans + abs(k - arr[i])
+            i += 1
+        return ans // 2
+
+
+if __name__ == '__main__':
+    arr = [5, 4, 1, 10]
+    N = len(arr)
+    print(find(arr, N))
+
+def minimum_steps(a, b):
+    """
+    Convert A into B by incrementing or decrementing 1 , 2 , or 5 any number of times
+    """
+    cnt = 0
+    a = abs(a - b)
+    cnt = (a // 5) + (a % 5) // 2 + (a % 5) % 2
+    return cnt
+
+
+A = 3
+B = 9
+print(minimum_steps(A, B))
+
+def smallest_non_subsequence(S, N):
+    """
+    Lexicographically smallest string which is not a subsequence of given string
+    """
+    freq = 0
+    for i in range(N):
+        if (S[i] == 'a'):
+            freq += 1
+    ans = ""
+    for i in range(freq):
+        ans += 'a'
+    if (freq == N):
+        ans = ans.replace(ans[freq - 1], 'b')
+    else:
+        ans += 'a'
+    return ans
+
+
+if __name__ == '__main__':
+    S = "abcdefghijklmnopqrstuvwxyz"
+    N = len(S)
+    print(smallest_non_subsequence(S, N))
+
+from collections import defaultdict
+
+
+def least_bricks(wall):
+    """
+    Minimum number of bricks that can be intersected
+    """
+    map = defaultdict(int)
+    res = 0
+    for list in wall:
+        width = 0
+        for i in range(len(list) - 1):
+            width += list[i]
+            map[width] += 1
+            res = max(res, map[width])
+    print(len(wall) - res)
+
+
+if __name__ == "__main__":
+    arr = [[1, 2, 2, 1], [3, 1, 2], [1, 3, 2], [2, 4], [3, 1, 2], [1, 3, 1, 1]]
+    least_bricks(arr)
+
+def number_of_ways(N, X, Y):
+    """
+    Maximize count of distinct profits possible by N transactions
+    """
+    S1 = (N - 1) * X + Y
+    S2 = (N - 1) * Y + X
+    return (S2 - S1 + 1)
+
+
+if __name__ == '__main__':
+    N = 3
+    X = 13
+    Y = 15
+    print(number_of_ways(N, X, Y))
+
+def minimum_operations(A, N, K):
+    """
+    Minimum number of operations required to make a permutation of first N natural numbers equal
+    """
+    Count = 0
+    i = 0
+    while (i < N - 1):
+        i = i + K - 1
+        Count += 1
+    return Count
+
+
+if __name__ == '__main__':
+    A = [5, 4, 3, 1, 2]
+    K = 3
+    N = len(A)
+    print(minimum_operations(A, N, K))
+
+from collections import Counter
+
+
+def construct_digits(s):
+    """
+    Reorder characters of a string to valid English representations of digits
+    """
+    k = ["z", "w", "u", "x", "g", "h", "o", "f", "v", "i"]
+    l = [
+        "zero",
+        "two",
+        "four",
+        "six",
+        "eight",
+        "three",
+        "one",
+        "five",
+        "seven",
+        "nine"]
+    c = [0, 2, 4, 6, 8, 3, 1, 5, 7, 9]
+    ans = []
+    d = Counter(s)
+    for i in range(len(k)):
+        x = d.get(k[i], 0)
+        for j in range(len(l[i])):
+            d[l[i][j]] -= x
+        ans.append(str(c[i]) * x)
+    ans.sort()
+    return "".join(ans)
+
+
+s = "fviefuro"
+print(construct_digits(s))
+
+def dist_integers(L, R):
+    """
+    Count distinct sum of pairs possible from a given range
+    """
+    return 2 * R - 2 * L + 1
+
+
+if __name__ == '__main__':
+    L, R = 3, 8
+    print(dist_integers(L, R))
+
+from math import sqrt
+
+
+def count_occurrences(N, X):
+    """
+    Count occurrences of an element in a matrix of size N * N generated such that each element is equal to product of its indices
+    """
+    count = 0
+    for i in range(1, int(sqrt(X)) + 1):
+        if X % i == 0:
+            a = i
+            b = X // i
+            if a <= N and b <= N:
+                if a == b:
+                    count += 1
+                else:
+                    count += 2
+    return count
+
+
+if __name__ == '__main__':
+    N = 7
+    X = 12
+    print(count_occurrences(N, X))
+
+def count_pairs(L, R):
+    """
+    Count pairs having distinct sum from a given range
+    """
+    firstNum = 2 * L
+    lastNum = 2 * R
+    Cntpairs = lastNum - firstNum + 1
+    print(Cntpairs)
+
+
+if __name__ == '__main__':
+    L, R = 2, 3
+    count_pairs(L, R)
+
+from collections import defaultdict
+
+
+def count_pairs(A, n):
+    """
+    Count pairs from an array whose Bitwise OR is greater than Bitwise AND
+    """
+    count = (n * (n - 1)) // 2
+    ump = defaultdict(int)
+    for i in range(n):
+        ump[A[i]] += 1
+    for it in ump.keys():
+        c = ump[it]
+        count = count - (c * (c - 1)) // 2
+    print(count)
+
+
+if __name__ == "__main__":
+    A = [1, 4, 7]
+    N = len(A)
+    count_pairs(A, N)
+
+def check(current_row, current_col, destination_row, destination_col):
+    """
+    Check if a Rook can reach the given destination in a single move
+    """
+    if (current_row == destination_row):
+        return ("POSSIBLE")
+    elif (current_col == destination_col):
+        return ("POSSIBLE")
+    else:
+        return ("NOT POSSIBLE")
+
+
+current_row = 8
+current_col = 8
+destination_row = 8
+destination_col = 4
+output = check(current_row, current_col, destination_row, destination_col)
+print(output)
+
+def minimum_moves(arr, N):
+    """
+    Minimum increments to modify array such that value of any array element can be splitted to make all remaining elements equal
+    """
+    sum = 0
+    maxelement = -1
+    if (N == 2):
+        print(0, end="")
+    for i in range(N):
+        sum += arr[i]
+        maxelement = max(maxelement, arr[i])
+    K = (sum + N - 2) // (N - 1)
+    K = max(maxelement, K)
+    ans = K * (N - 1) - sum
+    print(ans)
+
+
+if __name__ == '__main__':
+    arr = [2, 3, 7]
+    N = 3
+    minimum_moves(arr, N)
+
+def max_sum_of_squares(N, S):
+    """
+    Maximum possible sum of squares of stack elements satisfying the given properties
+    """
+    res = 0
+    if (S < N or S > 9 * N):
+        cout << -1
+        return
+    S = S - N
+    c = 0
+    while (S > 0):
+        c += 1
+        if (S // 8 > 0):
+            res += 9 * 9
+            S -= 8
+        else:
+            res += (S + 1) * (S + 1)
+            break
+    res = res + (N - c)
+    print(res)
+
+
+if __name__ == '__main__':
+    N = 3
+    S = 12
+    max_sum_of_squares(N, S)
+
+def clear_last_bit(N, K):
+    """
+    Unset least significant K bits of a given number
+    """
+    mask = (-1 << K + 1)
+    N = N & mask
+    return N
+
+
+N = 730
+K = 3
+print(clear_last_bit(N, K))
+
+def areaof_rectangle(L, W):
+    """
+    Maximum area of a Rectangle that can be circumscribed about a given Rectangle of size LxW
+    """
+    area = (W + L) * (W + L) / 2
+    return area
+
+
+if __name__ == "__main__":
+    L = 18
+    W = 12
+    print(areaof_rectangle(L, W))
+
+def down_to_zero(n):
+    """
+    Minimum number of operations required to reduce N to 0
+    """
+    if (n <= 3):
+        return n
+    if (n % 2 == 0):
+        return 3
+    else:
+        return 4
+
+
+if __name__ == '__main__':
+    n = 4
+    print(down_to_zero(n))
+
+def minimumrequired(A, N):
+    """
+    Minimum count of elements required to obtain the given Array by repeated mirror operations
+    """
+    K = N
+    while (K > 0):
+        if (K % 2) == 1:
+            ans = K
+            break
+        ispalindrome = 1
+        for i in range(0, K // 2):
+            if (A[i] != A[K - 1 - i]):
+                ispalindrome = 0
+        if (ispalindrome == 1):
+            ans = K // 2
+            K = K // 2
+        else:
+            ans = K
+            break
+    return ans
+
+
+A = [1, 2, 2, 1, 1, 2, 2, 1]
+N = len(A)
+print(minimumrequired(A, N))
+
+def sum_of_factors(N):
+    """
+    Sum of product of all integers upto N with their count of divisors
+    """
+    ans = 0
+    for i in range(1, N + 1):
+        first = i
+        last = (N // i) * i
+        factors = (last - first) // i + 1
+        totalContribution = (((factors * (factors + 1)) // 2) * i)
+        ans += totalContribution
+    return ans
+
+
+N = 3
+print(sum_of_factors(N))
+
+def get_max_difference(N):
+    """
+    Find a number M < N such that difference between their XOR and AND is maximum
+    """
+    M = -1
+    maxDiff = 0
+    for i in range(N):
+        diff = (N ^ i) - (N & i)
+        if (diff >= maxDiff):
+            maxDiff = diff
+            M = i
+    return M
+
+
+if __name__ == '__main__':
+    N = 6
+    print(get_max_difference(N))
+
+def count_substrings(s):
+    """
+    Count substring of Binary string such that each character belongs to a palindrome of size greater than 1
+    """
+    n = len(s)
+    answer = (n * (n - 1)) // 2
+    cnt = 1
+    v = []
+    for i in range(1, n):
+        if (s[i] == s[i - 1]):
+            cnt += 1
+        else:
+            v.append(cnt)
+            cnt = 1
+    if (cnt > 0):
+        v.append(cnt)
+    for i in range(len(v) - 1):
+        answer -= (v[i] + v[i + 1] - 1)
+    return answer
+
+
+if __name__ == '__main__':
+    s = "00111"
+    print(count_substrings(s))
+
+def max_modulosum(a, n):
+    """
+    Maximize the sum of modulus with every Array element
+    """
+    sum1 = 0
+    for i in range(0, n):
+        sum1 += a[i]
+    return sum1 - n
+
+
+a = [3, 4, 6]
+n = len(a)
+print(max_modulosum(a, n))
+
+def min_occupied_position(A, n):
+    """
+    Minimize the non
+    """
+    minPos = 0
+    i = 0
+    while i < n:
+        if (A[i] > 0):
+            minPos += 1
+            i += 2
+        i += 1
+    return minPos
+
+
+if __name__ == '__main__':
+    A = [8, 0, 7, 0, 0, 6]
+    n = len(A)
+    print(min_occupied_position(A, n))
+
+def largest_num(n):
+    """
+    Find the largest number smaller than integer N with maximum number of set bits
+    """
+    num = 0
+    for i in range(32):
+        x = (1 << i)
+        if ((x - 1) <= n):
+            num = (1 << i) - 1
+        else:
+            break
+    return num
+
+
+if __name__ == "__main__":
+    N = 345
+    print(largest_num(N))
+
+def segments(n):
+    """
+    Maximum number on 7
+    """
+    if (n == 1 or n == 0):
+        return
+    if (n % 2 == 0):
+        print("1", end="")
+        segments(n - 2)
+    elif (n % 2 == 1):
+        print("7", end="")
+        segments(n - 3)
+
+
+if __name__ == "__main__":
+    n = 11
+    segments(n)
+
+MAX_SIZE = 10
+
+
+def convolution(x, h, n, m):
+    """
+    Circular Convolution using Matrix Method
+    """
+    row_vec = [0] * MAX_SIZE
+    col_vec = [0] * MAX_SIZE
+    out = [0] * MAX_SIZE
+    circular_shift_mat = [[0 for i in range(MAX_SIZE)]for j in range(MAX_SIZE)]
+    if (n > m):
+        maxSize = n
+    else:
+        maxSize = m
+    for i in range(maxSize):
+        if (i >= n):
+            row_vec[i] = 0
+        else:
+            row_vec[i] = x[i]
+    for i in range(maxSize):
+        if (i >= m):
+            col_vec[i] = 0
+        else:
+            col_vec[i] = h[i]
+    k = 0
+    d = 0
+    for i in range(maxSize):
+        curIndex = k - d
+        for j in range(maxSize):
+            circular_shift_mat[j][i] = row_vec[curIndex % maxSize]
+            curIndex += 1
+        k = maxSize
+        d += 1
+    for i in range(maxSize):
+        for j in range(maxSize):
+            out[i] += circular_shift_mat[i][j] * col_vec[j]
+        print(out[i], end=" ")
+
+
+if __name__ == '__main__':
+    x = [5, 7, 3, 2]
+    n = len(x)
+    h = [1, 5]
+    m = len(h)
+    convolution(x, h, n, m)
+
+def get_maximum(s, a):
+    """
+    Maximize the given number by replacing a segment of digits with the alternate digits given
+    """
+    s = list(s)
+    n = len(s)
+    for i in range(n):
+        if (ord(s[i]) - ord('0') < a[ord(s[i]) - ord('0')]):
+            j = i
+            while (j < n and (ord(s[j]) - ord('0')
+                   <= a[ord(s[j]) - ord('0')])):
+                s[j] = chr(ord('0') + a[ord(s[j]) - ord('0')])
+                j += 1
+            return "".join(s)
+    return s
+
+
+if __name__ == "__main__":
+    s = "1337"
+    a = [0, 1, 2, 5, 4, 6, 6, 3, 1, 9]
+    print(get_maximum(s, a))
+
+from math import sqrt
+
+
+def count_steps(n):
+    """
+    Number of times the largest perfect square number can be subtracted from N
+    """
+    steps = 0
+    while (n):
+        largest = int(sqrt(n))
+        n -= (largest * largest)
+        steps += 1
+    return steps
+
+
+if __name__ == "__main__":
+    n = 85
+    print(count_steps(n))
+
+def maxsum(c1, c2, c3, c4):
+    """
+    Given count of digits 1 , 2 , 3 , 4 , find the maximum sum possible
+    """
+    sum = 0
+    two34 = min(c2, min(c3, c4))
+    sum = two34 * 234
+    c2 -= two34
+    sum += min(c2, c1) * 12
+    return sum
+
+
+c1 = 5
+c2 = 2
+c3 = 3
+c4 = 4
+print(maxsum(c1, c2, c3, c4))
+
+def find_count_of_pairs(a, b, n):
+    """
+    Count of pairs from 1 to a and 1 to b whose sum is divisible by N
+    """
+    ans = 0
+    ans += n * int(a / n) * int(b / n)
+    ans += int(a / n) * (b % n)
+    ans += (a % n) * int(b / n)
+    ans += int(((a % n) + (b % n)) / n)
+    return ans
+
+
+if __name__ == '__main__':
+    a = 5
+    b = 13
+    n = 3
+    print(find_count_of_pairs(a, b, n))
+
+def count_minimum_operations(n):
+    """
+    Minimum number of operations required to reduce N to 1
+    """
+    count = 0
+    while (n > 1):
+        if (n % 3 == 0):
+            n //= 3
+        elif (n % 3 == 1):
+            n -= 1
+        else:
+            if (n == 2):
+                n -= 1
+            else:
+                n += 1
+        count += 1
+    return count
+
+
+if __name__ == "__main__":
+    n = 4
+    ans = count_minimum_operations(n)
+    print(ans)
+
+def count_minimum_operations(n):
+    """
+    Minimum number of operations required to reduce N to 1
+    """
+    if (n == 2):
+        return 1
+    elif (n == 1):
+        return 0
+    if (n % 3 == 0):
+        return 1 + count_minimum_operations(n / 3)
+    elif (n % 3 == 1):
+        return 1 + count_minimum_operations(n - 1)
+    else:
+        return 1 + count_minimum_operations(n + 1)
+
+
+n = 4
+ans = count_minimum_operations(n)
+print(ans)
+
+def problems_left(K, P, N):
+    """
+    Problems not solved at the end of Nth day
+    """
+    if (K <= P):
+        return 0
+    else:
+        return ((K - P) * N)
+
+
+K, P, N = 4, 1, 10
+print(problems_left(K, P, N))
+
+def results(n, k):
+    """
+    Number of chocolates left after k iterations
+    """
+    return round(pow(n, (1.0 / pow(2, k))))
+
+
+k = 3
+n = 100000000
+print("Chocolates left after"),
+print(k),
+print("iterations are"),
+print(int(results(n, k)))
+
+def max_sum_wo3_consec(A, N):
+    """
+    Maximum subsequence sum such that no three are consecutive in O ( 1 ) space
+    """
+    if (N == 1):
+        return A[0]
+    if (N == 2):
+        return A[0] + A[1]
+    third = A[0]
+    second = third + A[1]
+    first = max(second, A[1] + A[2])
+    sum = max(max(third, second), first)
+    for i in range(3, N, 1):
+        sum = max(max(first, second + A[i]), third + A[i] + A[i - 1])
+        third = second
+        second = first
+        first = sum
+    return sum
+
+
+if __name__ == '__main__':
+    A = [3000, 2000, 1000, 3, 10]
+    N = len(A)
+    print(max_sum_wo3_consec(A, N))
+
+def find_min_operations(n):
+    """
+    Minimum number of given operations required to reduce a number to 2
+    """
+    dp = [0 for i in range(n + 1)]
+    for i in range(n + 1):
+        dp[i] = 999999
+    dp[2] = 0
+    for i in range(2, n + 1):
+        if (i * 5 <= n):
+            dp[i * 5] = min(dp[i * 5], dp[i] + 1)
+        if (i + 3 <= n):
+            dp[i + 3] = min(dp[i + 3], dp[i] + 1)
+    return dp[n]
+
+
+if __name__ == '__main__':
+    n = 28
+    m = find_min_operations(n)
+    if (m != 9999):
+        print(m)
+    else:
+        print(-1)
+
+def get_value(arr, N):
+    """
+    Split array into subarrays such that sum of difference between their maximums and minimums is maximum
+    """
+    dp = [0 for i in range(N)]
+    for i in range(1, N):
+        minn = arr[i]
+        maxx = arr[i]
+        j = i
+        while (j >= 0):
+            minn = min(arr[j], minn)
+            maxx = max(arr[j], maxx)
+            dp[i] = max(dp[i], maxx - minn + (dp[j - 1]if (j >= 1)else 0))
+            j -= 1
+    return dp[N - 1]
+
+
+if __name__ == '__main__':
+    arr = [8, 1, 7, 9, 2]
+    N = len(arr)
+    print(get_value(arr, N))
+
+dp = dict()
+
+
+def max_score(s, a):
+    """
+    Maximum score possible by removing substrings made up of single distinct character
+    """
+    if s in dp:
+        return dp[s]
+    n = len(s)
+    if n == 0:
+        return 0
+    if n == 1:
+        return a[0]
+    head = 0
+    mx = -1
+    while head < n:
+        tail = head
+        while tail < n:
+            if s[tail] != s[head]:
+                head = tail
+                break
+            sub = s[head:tail + 1]
+            mx = max(mx, a[len(sub) - 1] +
+                     max_score(s[:head] + s[tail + 1:], a))
+            tail += 1
+        if tail == n:
+            break
+    dp[s] = mx
+    return mx
+
+
+if __name__ == "__main__":
+    s = "abb"
+    a = [1, 3, 1]
+    print(max_score(s, a))
+
+def min_cost(costs, N):
+    """
+    Minimize cost of painting N houses such that adjacent houses have different colors
+    """
+    if (N == 0):
+        return 0
+    dp = [[0 for i in range(3)]for j in range(3)]
+    dp[0][0] = costs[0][0]
+    dp[0][1] = costs[0][1]
+    dp[0][2] = costs[0][2]
+    for i in range(1, N, 1):
+        dp[i][0] = min(dp[i - 1][1], dp[i - 1][2]) + costs[i][0]
+        dp[i][1] = min(dp[i - 1][0], dp[i - 1][2]) + costs[i][1]
+        dp[i][2] = min(dp[i - 1][0], dp[i - 1][1]) + costs[i][2]
+    print(min(dp[N - 1][0], min(dp[N - 1][1], dp[N - 1][2])))
+
+
+if __name__ == '__main__':
+    costs = [[14, 2, 11], [11, 14, 5], [14, 3, 10]]
+    N = len(costs)
+    min_cost(costs, N)
+
+def maximum_sum(A, B, length, X, Y):
+    """
+    Maximum sum by picking elements from two arrays in order
+    """
+    l = length
+    l1 = min(length, X)
+    l2 = min(length, Y)
+    dp = [[0 for i in range(l2 + 1)]for i in range(l1 + 1)]
+    dp[0][0] = 0
+    max_sum = -10 * 9
+    for i in range(1, l1 + 1):
+        dp[i][0] = dp[i - 1][0] + A[i - 1]
+        max_sum = max(max_sum, dp[i][0])
+    for i in range(1, l2 + 1):
+        dp[0][i] = dp[0][i - 1] + B[i - 1]
+        max_sum = max(max_sum, dp[0][i])
+    for i in range(1, l1 + 1):
+        for j in range(1, l2 + 1):
+            if (i + j <= l):
+                dp[i][j] = max(dp[i - 1][j] + A[i + j - 1],
+                               dp[i][j - 1] + B[i + j - 1])
+            max_sum = max(dp[i][j], max_sum)
+    return max_sum
+
+
+if __name__ == '__main__':
+    A = [1, 2, 3, 4, 5]
+    B = [5, 4, 3, 2, 1]
+    X = 3
+    Y = 2
+    N = len(A)
+    print(maximum_sum(A, B, N, X, Y))
+
+def reduce_zero(N):
+    """
+    Min number of operations to reduce N to 0 by subtracting any digits from N
+    """
+    dp = [1e9 for i in range(N + 1)]
+    dp[0] = 0
+    for i in range(N + 1):
+        for c in str(i):
+            dp[i] = min(dp[i], dp[i - (ord(c) - 48)] + 1)
+    return dp[N]
+
+
+N = 25
+print(reduce_zero(N))
+