giulio98/xlcost-single-prompt huggingface dataset:
# count number of integers less than or equal to n which has exactly 9 divisors | function to count factors in o ( n ) ; iterate and check if factor or not ; function to count numbers having exactly 9 divisors ; check for all numbers <= n ; check if exactly 9 factors or not ; 
def numberOfDivisors(num):
    c = 0
    for i in range(1, num + 1):
        if (num % i == 0):
            c += 1
    return c


def countNumbers(n):
    c = 0
    for i in range(1, n + 1):
        if (numberOfDivisors(i) == 9):
            c += 1
    return c


if __name__ == "__main__":
    n = 1000
    print(countNumbers(n))

# Expected output:
8
# number of distinct integers obtained by lcm ( x , n ) / x | python 3 program to find distinct integers ontained by lcm ( x , num ) / x ; function to count the number of distinct integers ontained by lcm ( x , num ) / x ; iterate to count the number of factors ; 

import math


def numberOfDistinct(n):
    ans = 0
    for i in range(1, int(math .sqrt(n)) + 1):
        if (n % i == 0):
            ans += 1
            if ((n // i) != i):
                ans += 1
    return ans


if __name__ == "__main__":
    n = 3
    print(numberOfDistinct(n))

# Expected output:
2
# ulam number sequence | python3 code to print nth ulam number ; array to store ulam number ; function to compute ulam number ; push first 2 two term of the sequence in the array for further calculation ; loop to generate ulam number ; traverse the array and check if i can be represented as sum of two distinct element of the array ; if count is 1 that means i can be represented as sum of two distinct terms of the sequence ; i is ulam number ; 

MAX = 1000
arr = []


def ulam():
    arr .append(1)
    arr .append(2)
    for i in range(3, MAX):
        count = 0
        for j in range(len(arr) - 1):
            for k in range(j + 1, len(arr)):
                if (arr[j] + arr[k] == i):
                    count += 1
                if (count > 1):
                    break
            if (count > 1):
                break
        if (count == 1):
            arr .append(i)


if __name__ == '__main__':
    ulam()
    n = 9
    print(arr[n - 1])

# Expected output:
16
# find the number of rectangles of size 2 * 1 which can be placed inside a rectangle of size n * m | function to find the number of rectangles of size 2 * 1 can be placed inside a rectangle of size n * m ; if n is even ; if m is even ; if both are odd ; 
def NumberOfRectangles(n, m):
    if (n % 2 == 0):
        return (n / 2) * m
    elif (m % 2 == 0):
        return (m // 2) * n
    return (n * m - 1) // 2


if __name__ == "__main__":
    n = 3
    m = 3
    print(NumberOfRectangles(n, m))

# Expected output:
4
# next greater number than n with the same quantity of digits a and b | recursive function to find the required number ; if the resulting number is >= n and count of a = count of b , return the number ; select minimum of two and call the function again ; function to find the number next greater number than n with the same quantity of digits a and b ; 
def findNumUtil(res, a, aCount, b, bCount, n):
    if (res > 1e11):
        return 1e11
    if (aCount == bCount and res >= n):
        return res
    return min(
        findNumUtil(
            res * 10 + a,
            a,
            aCount + 1,
            b,
            bCount,
            n),
        findNumUtil(
            res * 10 + b,
            a,
            aCount,
            b,
            bCount + 1,
            n))


def findNum(n, a, b):
    result = 0
    aCount = 0
    bCount = 0
    return findNumUtil(result, a, aCount, b, bCount, n)


if __name__ == '__main__':
    N = 4500
    A = 4
    B = 7
    print(findNum(N, A, B))

# Expected output:
4747
# absolute difference between sum and product of roots of a quartic equation | function taking coefficient of each term of equation as input ; finding sum of roots ; finding product of roots ; absolute difference ; 
def sumProductDifference(a, b, c, d, e):
    rootSum = (-1 * b) / a
    rootProduct = e / a
    return abs(rootSum - rootProduct)


print(sumProductDifference(8, 4, 6, 4, 1))

# Expected output:
0.625
# number of solutions of n = x + n âš • x | function to find the number of solutions of n = n xor x ; counter to store the number of solutions found ; 
def numberOfSolutions(n):
    c = 0
    for x in range(n + 1):
        if (n == (x + (n ^ x))):
            c += 1
    return c


if __name__ == "__main__":
    n = 3
    print(numberOfSolutions(n))

# Expected output:
4
# program to find minimum number of lectures to attend to maintain 75 % | python program to find minimum number of lectures to attend to maintain 75 % attendance ; function to compute minimum lecture ; formula to compute ; 

import math


def minimumLecture(m, n):
    ans = 0
    if (n < math .ceil(0.75 * m)):
        ans = math .ceil(((0.75 * m) - n) / 0.25)
    else:
        ans = 0
    return ans


M = 9
N = 1
print(minimumLecture(M, N))

# Expected output:
23
# count numbers with n digits which consists of odd number of 0 's | function to count numbers with n digits which consists of odd number of 0 's ; 
def countNumbers(N):
    return (pow(10, N) - pow(8, N)) // 2


if __name__ == "__main__":
    n = 5
    print(countNumbers(n))

# Expected output:
33616
# sum of all primes in a given range using sieve of eratosthenes | python 3 program to find sum of primes in range l to r ; prefix [ i ] is going to store sum of primes till i ( including i ) . ; function to build the prefix sum array ; create a boolean array " prime [ 0 . . n ] " . a value in prime [ i ] will finally be false if i is not a prime , else true . ; if prime [ p ] is not changed , then it is a prime ; update all multiples of p ; build prefix array ; function to return sum of prime in range ; 

from math import sqrt
MAX = 10000
prefix = [0 for i in range(MAX + 1)]


def buildPrefix():
    prime = [True for i in range(MAX + 1)]
    for p in range(2, int(sqrt(MAX)) + 1, 1):
        if (prime[p]):
            for i in range(p * 2, MAX + 1, p):
                prime[i] = False
    prefix[0] = 0
    prefix[1] = 0
    for p in range(2, MAX + 1, 1):
        prefix[p] = prefix[p - 1]
        if (prime[p]):
            prefix[p] += p


def sumPrimeRange(L, R):
    buildPrefix()
    return prefix[R] - prefix[L - 1]


if __name__ == '__main__':
    L = 10
    R = 20
    print(sumPrimeRange(L, R))

# Expected output:
60
# sum of the first n terms of the series 5 , 12 , 23 , 38. ... | function to calculate the sum ; 
def calculateSum(n):
    return (2 * (n * (n + 1) * (2 * n + 1) // 6) + n * (n + 1) // 2 + 2 * (n))


if __name__ == "__main__":
    n = 3
    print("Sum =", calculateSum(n))

# Expected output:
Sum = 40
# program to find number of solutions in quadratic equation | function to check for solutions of equations ; if the expression is greater than 0 , then 2 solutions ; if the expression is equal 0 , then 1 solutions ; else no solutions ; 
def checkSolution(a, b, c):
    if ((b * b) - (4 * a * c)) > 0:
        print("2 solutions")
    elif ((b * b) - (4 * a * c)) == 0:
        print("1 solution")
    else:
        print("No solutions")


if __name__ == "__main__":
    a, b, c = 2, 5, 2
    checkSolution(a, b, c)

# Expected output:
2 solutions
# Find sum of the series ? 3 + ? 12 + ... ... ... upto N terms | Function to find the sum ; Apply AP formula ; number of terms

import math


def findSum(n):
    return math .sqrt(3) * (n * (n + 1) / 2)


if __name__ == '__main__':
    n = 10
    print(findSum(n))

# Expected output:
95.26279441628824
# find the sum of the series x ( x + y ) + x ^ 2 ( x ^ 2 + y ^ 2 ) + x ^ 3 ( x ^ 3 + y ^ 3 ) + ... + x ^ n ( x ^ n + y ^ n ) | function to return required sum ; sum of first series ; sum of second series ; 
def sum(x, y, n):
    sum1 = ((x ** 2) * (x ** (2 * n) - 1)) // (x ** 2 - 1)
    sum2 = (x * y * (x ** n * y ** n - 1)) // (x * y - 1)
    return (sum1 + sum2)


if __name__ == '__main__':
    x = 2
    y = 2
    n = 2
    print(sum(x, y, n))

# Expected output:
40
# find any pair with given gcd and lcm | function to print the pairs ; 
def printPair(g, l):
    print(g, l)


g = 3
l = 12
printPair(g, l)

# Expected output:
3 12
# sum of first n terms of a 
def calculateSum(n):
    a1 = 1
    a2 = 2
    r = 2
    d = 1
    return ((n) * (2 * a1 + (n - 1) * d) / 2 + a2 * (pow(r, n) - 1) / (r - 1))


n = 5
print("Sum =", int(calculateSum(n)))

# Expected output:
Sum = 77
# maximum of sum and product of digits until number is reduced to a single digit | function to sum the digits until it becomes a single digit ; function to product the digits until it becomes a single digit ; loop to do sum while sum is not less than or equal to 9 ; function to find the maximum among repeated sum and repeated product ; 
def repeatedSum(n):
    if (n == 0):
        return 0
    return 9 if (n % 9 == 0)else (n % 9)


def repeatedProduct(n):
    prod = 1
    while (n > 0 or prod > 9):
        if (n == 0):
            n = prod
            prod = 1
        prod *= n % 10
        n //= 10
    return prod


def maxSumProduct(N):
    if (N < 10):
        return N
    return max(repeatedSum(N), repeatedProduct(N))


if __name__ == "__main__":
    n = 631
    print(maxSumProduct(n))

# Expected output:
8
# count of subsets of integers from 1 to n having no adjacent elements | function to count subsets ; 
def countSubsets(N):
    if (N <= 2):
        return N
    if (N == 3):
        return 2
    DP = [0] * (N + 1)
    DP[0] = 0
    DP[1] = 1
    DP[2] = 2
    DP[3] = 2
    for i in range(4, N + 1):
        DP[i] = DP[i - 2] + DP[i - 3]
    return DP[N]


if __name__ == '__main__':
    N = 20
    print(countSubsets(N))

# Expected output:
265
# count the number of ordered sets not containing consecutive numbers | dp table ; function to calculate the count of ordered set for a given size ; base cases ; if subproblem has been soved before ; store and return answer to this subproblem ; function returns the count of all ordered sets ; prestore the factorial value ; iterate all ordered set sizes and find the count for each one maximum ordered set size will be smaller than n as all elements are distinct and non consecutive . ; multiply ny size ! for all the arrangements because sets are ordered . ; add to total answer ; 

dp = [[-1 for j in range(500)]for i in range(500)]


def CountSets(x, pos):
    if (x <= 0):
        if (pos == 0):
            return 1
        else:
            return 0
    if (pos == 0):
        return 1
    if (dp[x][pos] != -1):
        return dp[x][pos]
    answer = (CountSets(x - 1, pos) + CountSets(x - 2, pos - 1))
    dp[x][pos] = answer
    return answer


def CountOrderedSets(n):
    factorial = [0 for i in range(10000)]
    factorial[0] = 1
    for i in range(1, 10000):
        factorial[i] = factorial[i - 1] * i
    answer = 0
    for i in range(1, n + 1):
        sets = CountSets(n, i) * factorial[i]
        answer = answer + sets
    return answer


if __name__ == "__main__":
    N = 3
    print(CountOrderedSets(N))

# Expected output:
5
# count the arithmetic sequences in the array of size at least 3 | function to find all arithmetic sequences of size atleast 3 ; if array size is less than 3 ; finding arithmetic subarray length ; to store all arithmetic subarray of length at least 3 ; check if current element makes arithmetic sequence with previous two elements ; begin with a new element for new arithmetic sequences ; accumulate result in till i . ; return final count ; 
def numberOfArithmeticSequences(L, N):
    if (N <= 2):
        return 0
    count = 0
    res = 0
    for i in range(2, N):
        if ((L[i] - L[i - 1]) == (L[i - 1] - L[i - 2])):
            count += 1
        else:
            count = 0
        res += count
    return res


L = [1, 3, 5, 6, 7, 8]
N = len(L)
print(numberOfArithmeticSequences(L, N))

# Expected output:
4
# count triplet of indices ( i , j , k ) such that xor of elements between [ i , j ) equals [ j , k ] | function return the count of triplets having subarray xor equal ; xor value till i ; count and ways array as defined above ; using the formula stated ; increase the frequency of x ; add i + 1 to ways [ x ] for upcoming indices ; 
def CountOfTriplets(a, n):
    answer = 0
    x = 0
    count = [0 for i in range(100005)]
    ways = [0 for i in range(100005)]
    for i in range(n):
        x ^= a[i]
        answer += count[x] * i - ways[x]
        count[x] += 1
        ways[x] += (i + 1)
    return answer


if __name__ == '__main__':
    Arr = [3, 6, 12, 8, 6, 2, 1, 5]
    N = len(Arr)
    print(CountOfTriplets(Arr, N))

# Expected output:
6
# count of subarrays of an array having all unique digits | function to obtain the mask for any integer ; function to count the number of ways ; subarray must not be empty ; if subproblem has been solved ; excluding this element in the subarray ; if there are no common digits then only this element can be included ; calculate the new mask if this element is included ; store and return the answer ; function to find the count of subarray with all digits unique ; initializing dp ; 
def getmask(val):
    mask = 0
    if val == 0:
        return 1
    while (val):
        d = val % 10
        mask |= (1 << d)
        val = val // 10
    return mask


def countWays(pos, mask, a, n):
    if pos == n:
        if mask > 0:
            return 1
        else:
            return 0
    if dp[pos][mask] != -1:
        return dp[pos][mask]
    count = 0
    count = (count + countWays(pos + 1, mask, a, n))
    if (getmask(a[pos]) & mask) == 0:
        new_mask = (mask | (getmask(a[pos])))
        count = (count + countWays(pos + 1, new_mask, a, n))
    dp[pos][mask] = count
    return count


def numberOfSubarrays(a, n):
    return countWays(0, 0, a, n)


N = 4
A = [1, 12, 23, 34]
rows = 5000
cols = 1100
dp = [[-1 for i in range(cols)]for j in range(rows)]
print(numberOfSubarrays(A, N))

# Expected output:
7
# count the numbers with n digits and whose suffix is divisible by k | python3 implementation to count the numbers with n digits and whose suffix is divisible by k ; suffix of length pos with remainder rem and z representing whether the suffix has a non zero digit until now ; base case ; if count of digits is less than n ; placing all possible digits in remaining positions ; if remainder non zero and suffix has n digits ; if the subproblem is already solved ; placing all digits at msb of suffix and increasing it 's length by 1 ; non zero digit is placed ; store and return the solution to this subproblem ; function to count the numbers with n digits and whose suffix is divisible by k ; since we need powers of 10 for counting , it 's better to  pre store them along with their  modulo with 1e9 + 7 for counting ; since at each recursive step we increase the suffix length by 1 by placing digits at its leftmost position , we need powers of 10 modded with k , in order to fpos the new remainder efficiently ; initialising dp table values - 1 represents subproblem hasn 't  been solved yet  memset(dp, -1, sizeof(dp)) ; 

mod = 1000000007
dp = [[[-1 for i in range(2)]for i in range(105)]for i in range(1005)]
powers = [0] * 1005
powersModk = [0] * 1005


def calculate(pos, rem, z, k, n):
    if (rem == 0 and z):
        if (pos != n):
            return (powers[n - pos - 1] * 9) % mod
        else:
            return 1
    if (pos == n):
        return 0
    if (dp[pos][rem][z] != -1):
        return dp[pos][rem][z]
    count = 0
    for i in range(10):
        if (i == 0):
            count = (count + (calculate(pos + 1,
                     (rem + (i * powersModk[pos]) % k) % k, z, k, n))) % mod
        else:
            count = (count + (calculate(pos + 1,
                     (rem + (i * powersModk[pos]) % k) % k, 1, k, n))) % mod
    dp[pos][rem][z] = count
    return count


def countNumbers(n, k):
    st = 1
    for i in range(n + 1):
        powers[i] = st
        st *= 10
        st %= mod
    st = 1
    for i in range(n + 1):
        powersModk[i] = st
        st *= 10
        st %= mod
    return calculate(0, 0, 0, k, n)


if __name__ == '__main__':
    N = 2
    K = 2
    print(countNumbers(N, K))

# Expected output:
45
# shortest path with exactly k edges in a directed and weighted graph | set 2 | python3 implementation of the above approach ; function to find the smallest path with exactly k edges ; array to store dp ; loop to solve dp ; initialising next state ; recurrence relation ; returning final answer ; 

inf = 100000000


def smPath(s, d, ed, n, k):
    dis = [inf] * (n + 1)
    dis[s] = 0
    for i in range(k):
        dis1 = [inf] * (n + 1)
        for it in ed:
            dis1[it[1]] = min(dis1[it[1]], dis[it[0]] + it[2])
        for i in range(n + 1):
            dis[i] = dis1[i]
    if (dis[d] == inf):
        return -1
    else:
        return dis[d]


if __name__ == '__main__':
    n = 4
    ed = [[0, 1, 10], [0, 2, 3], [0, 3, 2], [1, 3, 7], [2, 3, 7]]
    s = 0
    d = 3
    k = 2
    print(smPath(s, d, ed, n, k))

# Expected output:
10
# path with smallest product of edges with weight > 0 | python3 implementation of the approach . ; function to return the smallest product of edges ; if the source is equal to the destination ; array to store distances ; initialising the array ; bellman ford algorithm ; loop to detect cycle ; returning final answer ; 

import sys
inf = sys .maxsize


def bellman(s, d, ed, n):
    if (s == d):
        return 0
    dis = [0] * (n + 1)
    for i in range(1, n + 1):
        dis[i] = inf
    dis[s] = 1
    for i in range(n - 1):
        for it in ed:
            dis[it[1]] = min(dis[it[1]], dis[it[0]] * ed[it])
    for it in ed:
        if (dis[it[1]] > dis[it[0]] * ed[it]):
            return -2
    if (dis[d] == inf):
        return -1
    else:
        return dis[d]


if __name__ == "__main__":
    n = 3
    ed = {(1, 2): 0.5, (1, 3): 1.9, (2, 3): 3}
    s = 1
    d = 3
    get = bellman(s, d, ed, n)
    if (get == -2):
        print("Cycle Detected")
    else:
        print(get)

# Expected output:
1.5
# find maximum length of a square submatrix having sum of elements at | python3 implementation of the above approach ; function to return maximum length of square submatrix having sum of elements at - most k ; matrix to store prefix sum ; current maximum length ; variable for storing maximum length of square ; calculating prefix sum ; checking whether there exits square with length cur_max + 1 or not ; returning the maximum length ; 

import numpy as np


def maxLengthSquare(row, column, arr, k):
    sum = np .zeros((row + 1, column + 1))
    cur_max = 1
    max = 0
    for i in range(1, row + 1):
        for j in range(1, column + 1):
            sum[i][j] = sum[i - 1][j] + sum[i][j - 1] + \
                arr[i - 1][j - 1] - sum[i - 1][j - 1]
            if (i >= cur_max and j >= cur_max and sum[i][j] - sum[i - cur_max]
                    [j] - sum[i][j - cur_max] + sum[i - cur_max][j - cur_max] <= k):
                max = cur_max
                cur_max += 1
    return max


if __name__ == "__main__":
    row = 4
    column = 4
    matrix = [[1, 1, 1, 1], [1, 0, 0, 0], [1, 0, 0, 0], [1, 0, 0, 0]]
    k = 6
    ans = maxLengthSquare(row, column, matrix, k)
    print(ans)

# Expected output:
3
# sum of all numbers formed having 4 atmost x times , 5 atmost y times and 6 atmost z times | python3 program to find sum of all numbers formed having 4 atmost x times , 5 atmost y times and 6 atmost z times ; exactsum [ i ] [ j ] [ k ] stores the sum of all the numbers having exact i 4 ' s , ▁ j ▁ 5' s and k 6 's ; exactnum [ i ] [ j ] [ k ] stores numbers of numbers having exact i 4 ' s , ▁ j ▁ 5' s and k 6 's ; utility function to calculate the sum for x 4 ' s , ▁ y ▁ 5' s and z 6 's ; computing exactsum [ i ] [ j ] [ k ] as explained above ; 

import numpy as np
N = 101
mod = int(1e9) + 7
exactsum = np .zeros((N, N, N))
exactnum = np .zeros((N, N, N))


def getSum(x, y, z):
    ans = 0
    exactnum[0][0][0] = 1
    for i in range(x + 1):
        for j in range(y + 1):
            for k in range(z + 1):
                if (i > 0):
                    exactsum[i][j][k] += (exactsum[i - 1][j][k]
                                          * 10 + 4 * exactnum[i - 1][j][k]) % mod
                    exactnum[i][j][k] += exactnum[i - 1][j][k] % mod
                if (j > 0):
                    exactsum[i][j][k] += (exactsum[i][j - 1][k]
                                          * 10 + 5 * exactnum[i][j - 1][k]) % mod
                    exactnum[i][j][k] += exactnum[i][j - 1][k] % mod
                if (k > 0):
                    exactsum[i][j][k] += (exactsum[i][j][k - 1]
                                          * 10 + 6 * exactnum[i][j][k - 1]) % mod
                    exactnum[i][j][k] += exactnum[i][j][k - 1] % mod
                ans += exactsum[i][j][k] % mod
                ans %= mod
    return ans


if __name__ == "__main__":
    x = 1
    y = 1
    z = 1
    print((getSum(x, y, z) % mod))

# Expected output:
3675.0
# maximum value obtained by performing given operations in an array | python3 implementation of the above approach ; a function to calculate the maximum value ; basecases ; loop to iterate and add the max value in the dp array ; 

import numpy as np


def findMax(a, n):
    dp = np .zeros((n, 2))
    dp[0][0] = a[0] + a[1]
    dp[0][1] = a[0] * a[1]
    for i in range(1, n - 1):
        dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]) + a[i + 1]
        dp[i][1] = dp[i - 1][0] - a[i] + a[i] * a[i + 1]
    print(max(dp[n - 2][0], dp[n - 2][1]), end="")


if __name__ == "__main__":
    arr = [5, -1, -5, -3, 2, 9, -4]
    findMax(arr, 7)

# Expected output:
33.0
# optimal strategy for a game with modifications | python3 implementation of the above approach ; function to return sum of subarray from l to r ; calculate sum by a loop from l to r ; dp to store the values of sub problems ; if length of the array is less than k return the sum ; if the value is previously calculated ; else calculate the value ; select all the sub array of length len_r ; get the sum of that sub array ; check if it is the maximum or not ; store it in the table ; 

import numpy as np


def Sum(arr, l, r):
    s = 0
    for i in range(l, r + 1):
        s += arr[i]
    return s


dp = np .zeros((101, 101, 101))


def solve(arr, l, r, k):
    if (r - l + 1 <= k):
        return Sum(arr, l, r)
    if (dp[l][r][k]):
        return dp[l][r][k]
    sum_ = Sum(arr, l, r)
    len_r = (r - l + 1) - k
    length = (r - l + 1)
    ans = 0
    for i in range(length - len_r + 1):
        sum_sub = Sum(arr, i + l, i + l + len_r - 1)
        ans = max(ans, (sum_ - sum_sub) + (sum_sub -
                  solve(arr, i + l, i + l + len_r - 1, k)))
    dp[l][r][k] = ans
    return ans


if __name__ == "__main__":
    arr = [10, 15, 20, 9, 2, 5]
    k = 2
    n = len(arr)
    print(solve(arr, 0, n - 1, k))

# Expected output:
32
# find the minimum difference path from ( 0 , 0 ) to ( n | python3 implementation of the approach ; function to return the minimum difference path from ( 0 , 0 ) to ( n - 1 , m - 1 ) ; terminating case ; base case ; if it is already visited ; recursive calls ; return the value ; 

import numpy as np
import sys
MAXI = 50
INT_MAX = sys .maxsize
dp = np .ones((MAXI, MAXI, MAXI * MAXI))
dp *= -1


def minDifference(x, y, k, b, c):
    if (x >= n or y >= m):
        return INT_MAX
    if (x == n - 1 and y == m - 1):
        diff = b[x][y] - c[x][y]
        return min(abs(k - diff), abs(k + diff))
    ans = dp[x][y][k]
    if (ans != -1):
        return ans
    ans = INT_MAX
    diff = b[x][y] - c[x][y]
    ans = min(ans, minDifference(x + 1, y, abs(k + diff), b, c))
    ans = min(ans, minDifference(x, y + 1, abs(k + diff), b, c))
    ans = min(ans, minDifference(x + 1, y, abs(k - diff), b, c))
    ans = min(ans, minDifference(x, y + 1, abs(k - diff), b, c))
    return ans


if __name__ == "__main__":
    n = 2
    m = 2
    b = [[1, 4], [2, 4]]
    c = [[3, 2], [3, 1]]
    print(minDifference(0, 0, 0, b, c))

# Expected output:
0