giulio98/xlcost-single-prompt huggingface dataset:
# count even paths in binary tree | a tree node ; utility function to count the even path in a given binary tree ; base condition , when node pointer becomes null or node value is odd ; increment count when encounter leaf node with all node value even ; left recursive call , and save the value of count ; right recursive call , and return value of count ; function to count the even paths in a given binary tree ; function call with count = 0 ; 

class Node:
    def __init__(self, x):
        self .key = x
        self .left = None
        self .right = None


def evenPaths(node, count):
    if (node is None or (node .key % 2 != 0)):
        return count
    if (not node .left and not node .right):
        count += 1
    count = evenPaths(node .left, count)
    return evenPaths(node .right, count)


def countEvenPaths(node):
    return evenPaths(node, 0)


if __name__ == '__main__':
    root = Node(12)
    root .left = Node(13)
    root .right = Node(12)
    root .right .left = Node(14)
    root .right .right = Node(16)
    root .right .left .left = Node(21)
    root .right .left .right = Node(22)
    root .right .right .left = Node(22)
    root .right .right .right = Node(24)
    root .right .right .right .left = Node(8)
    print(countEvenPaths(root))

# Expected output:
3
# sum of subsets of all the subsets of an array | o ( 3 ^ n ) |  ; function to sum of all subsets of a given array ; base case ; recursively calling subsetsum ; function to generate the subsets ; base - case ; finding the sum of all the subsets of the generated subset ; recursively accepting and rejecting the current number ; 

c = []
ans = 0


def subsetSum(i, curr):
    global ans, c
    if (i == len(c)):
        ans += curr
        return
    subsetSum(i + 1, curr + c[i])
    subsetSum(i + 1, curr)


def subsetGen(arr, i, n):
    global ans, c
    if (i == n):
        subsetSum(0, 0)
        return
    subsetGen(arr, i + 1, n)
    c .append(arr[i])
    subsetGen(arr, i + 1, n)
    del c[-1]


arr = [1, 1]
n = len(arr)
subsetGen(arr, 0, n)
print(ans)

# Expected output:
6
# find maximum number possible by doing at | python3 program to find maximum integer possible by doing at - most k swap operations on its digits . ; function to find maximum integer possible by doing at - most k swap operations on its digits ; return if no swaps left ; consider every digit ; and compare it with all digits after it ; if digit at position i is less than digit at position j , swap it and check for maximum number so far and recurse for remaining swaps ; swap string [ i ] with string [ j ] ; if current num is more than maximum so far ; recurse of the other k - 1 swaps ; backtrack ; 
def swap(string, i, j):
    return (string[:i] + string[j] + string[i + 1:j] +
            string[i] + string[j + 1:])


def findMaximumNum(string, k, maxm):
    if k == 0:
        return
    n = len(string)
    for i in range(n - 1):
        for j in range(i + 1, n):
            if string[i] < string[j]:
                string = swap(string, i, j)
                if string > maxm[0]:
                    maxm[0] = string
                findMaximumNum(string, k - 1, maxm)
                string = swap(string, i, j)


if __name__ == "__main__":
    string = "129814999"
    k = 4
    maxm = [string]
    findMaximumNum(string, k, maxm)
    print(maxm[0])

# Expected output:
999984211
# print all possible paths from top left to bottom right of a mxn matrix | python3 program to print all possible paths from top left to bottom right of a mxn matrix ; if we reach the bottom of maze , we can only move right ; path . append ( maze [ i ] [ k ] ) ; if we hit this block , it means one path is completed . add it to paths list and print ; if we reach to the right most corner , we can only move down ; path . append ( maze [ j ] [ k ] ) if we hit this block , it means one path is completed . add it to paths list and print ; add current element to the path list path . append ( maze [ i ] [ j ] ) ; move down in y direction and call findpathsutil recursively ; move down in y direction and call findpathsutil recursively ; 

allPaths = []


def findPathsUtil(maze, m, n, i, j, path, indx):
    global allPaths
    if i == m - 1:
        for k in range(j, n):
            path[indx + k - j] = maze[i][k]
        print(path)
        allPaths .append(path)
        return
    if j == n - 1:
        for k in range(i, m):
            path[indx + k - i] = maze[k][j]
        print(path)
        allPaths .append(path)
        return
    path[indx] = maze[i][j]
    findPathsUtil(maze, m, n, i + 1, j, path, indx + 1)
    findPathsUtil(maze, m, n, i, j + 1, path, indx + 1)


def findPaths(maze, m, n):
    path = [0 for d in range(m + n - 1)]
    findPathsUtil(maze, m, n, 0, 0, path, 0)


if __name__ == '__main__':
    maze = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    findPaths(maze, 3, 3)

# Expected output:
[1, 4, 7, 8, 9]
[1, 4, 5, 8, 9]
[1, 4, 5, 6, 9]
[1, 2, 5, 8, 9]
[1, 2, 5, 6, 9]
[1, 2, 3, 6, 9]
# given an array a [ ] and a number x , check for pair in a [ ] with sum as x | function to find and print pair ; 
def chkPair(A, size, x):
    for i in range(0, size - 1):
        for j in range(i + 1, size):
            if (A[i] + A[j] == x):
                print("Pair with a given sum ", x,
                      " is (", A[i], ", ", A[j], ")")
                return True
    return False


A = [0, -1, 2, -3, 1]
x = -2
size = len(A)
if (chkPair(A, size, x)):
    print("Valid pair exists")
else:
    print("No valid pair exists for ", x)

# Expected output:
Pair with a given sum  -2  is ( -3 ,  1 )
Valid pair exists
# significant inversions in an array | function that sorts the input array and returns the number of inversions in the array ; recursive function that sorts the input array and returns the number of inversions in the array ; divide the array into two parts and call _mergesortandcountinv ( ) for each of the parts ; inversion count will be sum of the inversions in the left - part , the right - part and the number of inversions in merging ; merge the two parts ; function that merges the two sorted arrays and returns the inversion count in the arrays ; i is the index for the left subarray ; j is the index for the right subarray ; k is the index for the resultant merged subarray ; first pass to count number of significant inversions ; i is the index for the left subarray ; j is the index for the right subarray ; k is the index for the resultant merged subarray ; second pass to merge the two sorted arrays ; copy the remaining elements of the left subarray ( if there are any ) to temp ; copy the remaining elements of the right subarray ( if there are any ) to temp ; copy back the merged elements to the original array ; 
def _mergeSort(arr, temp, left, right):
    mid, inv_count = 0, 0
    if (right > left):
        mid = (right + left) // 2
        inv_count = _mergeSort(arr, temp, left, mid)
        inv_count += _mergeSort(arr, temp, mid + 1, right)
        inv_count += merge(arr, temp, left, mid + 1, right)
    return inv_count


def merge(arr, temp, left, mid, right):
    inv_count = 0
    i = left
    j = mid
    k = left
    while ((i <= mid - 1) and (j <= right)):
        if (arr[i] > 2 * arr[j]):
            inv_count += (mid - i)
            j += 1
        else:
            i += 1
    i = left
    j = mid
    k = left
    while ((i <= mid - 1) and (j <= right)):
        if (arr[i] <= arr[j]):
            temp[k] = arr[i]
            i, k = i + 1, k + 1
        else:
            temp[k] = arr[j]
            k, j = k + 1, j + 1
    while (i <= mid - 1):
        temp[k] = arr[i]
        i, k = i + 1, k + 1
    while (j <= right):
        temp[k] = arr[j]
        j, k = j + 1, k + 1
    for i in range(left, right + 1):
        arr[i] = temp[i]
    return inv_count

def mergeSort(arr, array_size):
    temp = [0 for i in range(array_size)]
    return _mergeSort(arr, temp, 0, array_size - 1)


arr = [1, 20, 6, 4, 5]
n = len(arr)
print(mergeSort(arr, n))

# Expected output:
3
# find nth term ( a matrix exponentiation example ) | python3 program to find n - th term of a recursive function using matrix exponentiation . ; this power function returns first row of { transformation matrix } ^ n - 1 * initial vector ; this is an identity matrix . ; this is transformation matrix . ; matrix exponentiation to calculate power of { tmat } ^ n - 1 store res in " res " matrix . ; res store { transformation matrix } ^ n - 1 hence will be first row of res * initial vector . ; 

MOD = 1000000009


def power(n):
    if (n <= 1):
        return 1
    n -= 1
    res = [[1, 0], [0, 1]]
    tMat = [[2, 3], [1, 0]]
    while (n):
        if (n & 1):
            tmp = [[0 for x in range(2)]for y in range(2)]
            tmp[0][0] = (res[0][0] * tMat[0][0] + res[0][1] * tMat[1][0]) % MOD
            tmp[0][1] = (res[0][0] * tMat[0][1] + res[0][1] * tMat[1][1]) % MOD
            tmp[1][0] = (res[1][0] * tMat[0][0] + res[1][1] * tMat[1][0]) % MOD
            tmp[1][1] = (res[1][0] * tMat[0][1] + res[1][1] * tMat[1][1]) % MOD
            res[0][0] = tmp[0][0]
            res[0][1] = tmp[0][1]
            res[1][0] = tmp[1][0]
            res[1][1] = tmp[1][1]
        n = n // 2
        tmp = [[0 for x in range(2)]for y in range(2)]
        tmp[0][0] = (tMat[0][0] * tMat[0][0] + tMat[0][1] * tMat[1][0]) % MOD
        tmp[0][1] = (tMat[0][0] * tMat[0][1] + tMat[0][1] * tMat[1][1]) % MOD
        tmp[1][0] = (tMat[1][0] * tMat[0][0] + tMat[1][1] * tMat[1][0]) % MOD
        tmp[1][1] = (tMat[1][0] * tMat[0][1] + tMat[1][1] * tMat[1][1]) % MOD
        tMat[0][0] = tmp[0][0]
        tMat[0][1] = tmp[0][1]
        tMat[1][0] = tmp[1][0]
        tMat[1][1] = tmp[1][1]
    return (res[0][0] * 1 + res[0][1] * 1) % MOD


n = 3
print(power(n))

# Expected output:
13
# shuffle 2 n integers in format { a1 , b1 , a2 , b2 , a3 , b3 , ... ... , an , bn } without using extra space | function to shuffle an array of size 2 n ; rotate the element to the left ; swap a [ j - 1 ] , a [ j ] ; 
def shuffleArray(a, n):
    i, q, k = 0, 1, n
    while (i < n):
        j = k
        while (j > i + q):
            a[j - 1], a[j] = a[j], a[j - 1]
            j -= 1
        i += 1
        k += 1
        q += 1


a = [1, 3, 5, 7, 2, 4, 6, 8]
n = len(a)
shuffleArray(a, int(n / 2))
for i in range(0, n):
    print(a[i], end=" ")

# Expected output:
1 2 3 4 5 6 7 8
# place k elements such that minimum distance is maximized | returns true if it is possible to arrange k elements of arr [ 0. . n - 1 ] with minimum distance given as mid . ; place first element at arr [ 0 ] position ; initialize count of elements placed . ; try placing k elements with minimum distance mid . ; place next element if its distance from the previously placed element is greater than current mid ; return if all elements are placed successfully ; returns largest minimum distance for k elements in arr [ 0. . n - 1 ] . if elements can 't be placed, returns -1. ; sort the positions ; initialize result . ; consider the maximum possible distance ; do binary search for largest minimum distance ; if it is possible to place k elements with minimum distance mid , search for higher distance . ; change value of variable max to mid iff all elements can be successfully placed ; if not possible to place k elements , search for lower distance ; 
def isFeasible(mid, arr, n, k):
    pos = arr[0]
    elements = 1
    for i in range(1, n, 1):
        if (arr[i] - pos >= mid):
            pos = arr[i]
            elements += 1
            if (elements == k):
                return True
    return 0


def largestMinDist(arr, n, k):
    arr .sort(reverse=False)
    res = -1
    left = 1
    right = arr[n - 1]
    while (left < right):
        mid = (left + right) / 2
        if (isFeasible(mid, arr, n, k)):
            res = max(res, mid)
            left = mid + 1
        else:
            right = mid
    return res


if __name__ == '__main__':
    arr = [1, 2, 8, 4, 9]
    n = len(arr)
    k = 3
    print(largestMinDist(arr, n, k))

# Expected output:
3.0
# find frequency of each element in a limited range array in less than o ( n ) time | it prints number of occurrences of each element in the array . ; hashmap to store frequencies ; traverse the array ; update the frequency ; traverse the hashmap ; 
def findFrequency(arr, n):
    mp = {}
    for i in range(n):
        if arr[i]not in mp:
            mp[arr[i]] = 0
        mp[arr[i]] += 1
    for i in mp:
        print("Element", i, "occurs", mp[i], "times")


arr = [1, 1, 1, 2, 3, 3, 5, 5, 8, 8, 8, 9, 9, 10]
n = len(arr)
findFrequency(arr, n)

# Expected output:
Element 1 occurs 3 times
Element 2 occurs 1 times
Element 3 occurs 2 times
Element 5 occurs 2 times
Element 8 occurs 3 times
Element 9 occurs 2 times
Element 10 occurs 1 times
# square root of an integer | returns floor of square root of x ; base cases ; do binary search for floor ( sqrt ( x ) ) ; if x is a perfect square ; since we need floor , we update answer when mid * mid is smaller than x , and move closer to sqrt ( x ) ; if mid * mid is greater than x ; 
def floorSqrt(x):
    if (x == 0 or x == 1):
        return x
    start = 1
    end = x
    while (start <= end):
        mid = (start + end) // 2
        if (mid * mid == x):
            return mid
        if (mid * mid < x):
            start = mid + 1
            ans = mid
        else:
            end = mid - 1
    return ans


x = 11
print(floorSqrt(x))

# Expected output:
3
# sine rule with derivation , example and implementation | python3 program for the above approach ; function to calculate remaining two sides ; calculate angle b ; convert angles to their respective radians for using trigonometric functions ; sine rule ; print the answer ; 

import math


def findSides(A, C, c):
    B = 180 - (A + C)
    A = A * (3.14159 / 180)
    C = C * (3.14159 / 180)
    B = B * (3.14159 / 180)
    a = (c / math .sin(C)) * math .sin(A)
    b = (c / math .sin(C)) * math .sin(B)
    print("{0:.2f}".format(a))
    print("{0:.2f}".format(b))


A = 45.0
C = 35.0
c = 23
findSides(A, C, c)

# Expected output:
28.35
39.49
# equation of a straight line passing through a point and making a given angle with a given line | python3 program for the above approach ; function to find slope of given line ; special case when slope of line is infinity or is perpendicular to x - axis ; function to find equations of lines passing through the given point and making an angle with given line ; store slope of given line ; convert degrees to radians ; special case when slope of given line is infinity : in this case slope of one line will be equal to alfa and the other line will be equal to ( 180 - alfa ) ; in this case slope of required lines can 't be  infinity ; g and f are the variables of required equations ; print first line equation ; print second line equation ; special case when slope of required line becomes infinity ; general case ; g and f are the variables of required equations ; print first line equation ; print second line equation ; 

import math


def line_slope(a, b):
    if (a != 0):
        return -b / a
    else:
        return (-2)


def line_equation(a, b, c, x1, y1, alfa):
    given_slope = line_slope(a, b)
    x = alfa * 3.14159 / 180
    if (given_slope == -2):
        slope_1 = math .tan(x)
        slope_2 = math .tan(3.14159 - x)
        g = x1, f = x1
        g *= (-slope_1)
        g += y1
        if (g > 0):
            print("y = ", round(slope_1, 2), "x +", round(g))
        if (g <= 0):
            print("y = ", round(slope_1, 2), "x ", round(g))
        f *= (-slope_2)
        f += y1
        if (f > 0):
            print("y = ", round(slope_2, 2), "x +", round(f))
        if (f <= 0):
            print("y = ", round(slope_2, 2), "x ", round(f))
        return
    if (1 - math .tan(x) * given_slope == 0):
        print("x =", x1)
    if (1 + math .tan(x) * given_slope == 0):
        print("x =", x1)
    slope_1 = ((given_slope + math .tan(x)) / (1 - math .tan(x) * given_slope))
    slope_2 = ((given_slope - math .tan(x)) / (1 + math .tan(x) * given_slope))
    g = x1
    f = x1
    g *= (-slope_1)
    g += y1
    if (g > 0 and 1 - math .tan(x) * given_slope != 0):
        print("y = ", round(slope_1, 2), "x +", round(g))
    if (g <= 0 and 1 - math .tan(x) * given_slope != 0):
        print("y = ", round(slope_1, 2), "x ", round(g))
    f *= (-slope_2)
    f += y1
    if (f > 0 and 1 + math .tan(x) * given_slope != 0):
        print("y = ", round(slope_2, 2), "x +", round(f))
    if (f <= 0 and 1 + math .tan(x) * given_slope != 0):
        print("y = ", round(slope_2, 2), "x ", round(f))


if __name__ == "__main__":
    a = 2
    b = 3
    c = -7
    x1 = 4
    y1 = 9
    alfa = 30
    line_equation(a, b, c, x1, y1, alfa)

# Expected output:
y =  -0.49 x + 11
y =  -15.51 x + 71
# equation of a normal to a circle from a given point | function to calculate the slope ; store the coordinates the center of the circle ; if slope becomes infinity ; stores the slope ; if slope is zero ; return the result ; function to find the equation of the normal to a circle from a given point ; stores the slope of the normal ; if slope becomes infinity ; if slope is zero ; otherwise , print the equation of the normal ; 
def normal_slope(a, b, x1, y1):
    g = a / 2
    f = b / 2
    if (g - x1 == 0):
        return (-1)
    slope = (f - y1) / (g - x1)
    if (slope == 0):
        return (-2)
    return slope


def normal_equation(a, b, x1, y1):
    slope = normal_slope(a, b, x1, y1)
    if (slope == -1):
        print("x = ", x1)
    if (slope == -2):
        print("y = ", y1)
    if (slope != -1 and slope != -2):
        x1 *= -slope
        x1 += y1
        if (x1 > 0):
            print("y = ", slope, "x + ", x1)
        else:
            print("y = ", slope, "x ", x1)


a = 4
b = 6
c = 5
x1 = 12
y1 = 14
normal_equation(a, b, x1, y1)

# Expected output:
y =  1.1 x +  0.7999999999999989
# sum of squares of distances between all pairs from given points | function to find the sum of squares of distance between all distinct pairs ; stores final answer ; traverse the array ; adding the effect of this point for all the previous x - points ; temporarily add the square of x - coordinate ; add the effect of this point for all the previous y - points ; print the desired answer ; 
def findSquareSum(Coordinates, N):
    xq, yq = 0, 0
    xs, ys = 0, 0
    res = 0
    for i in range(N):
        a = Coordinates[i][0]
        b = Coordinates[i][1]
        res += xq
        res -= 2 * xs * a
        res += i * (a * a)
        xq += a * a
        xs += a
        res += yq
        res -= 2 * ys * b
        res += i * b * b
        yq += b * b
        ys += b
    print(res)


if __name__ == '__main__':
    arr = [[1, 1], [-1, -1], [1, -1], [-1, 1]]
    N = len(arr)
    findSquareSum(arr, N)

# Expected output:
32
# count points from an array that lies inside a semi | python implementation of above approach ; traverse the array ; stores if a point lies above the diameter or not ; stores if the r is less than or equal to the distance between center and point ; 
def getPointsIns(x1, y1, radius, x2, y2, points):
    ans = 0
    for point in points:
        condOne = (point[1] - y2) * (x2 - x1) - \
            (y2 - y1) * (point[0] - x2) >= 0
        condTwo = radius >= ((y1 - point[1])**2 + (x1 - point[0])**2)**(0.5)
        if condOne and condTwo:
            ans += 1
    return ans


X = 0
Y = 0
R = 5
P = 5
Q = 0
arr = [[2, 3], [5, 6], [-1, 4], [5, 5]]
print(getPointsIns(X, Y, R, P, Q, arr))

# Expected output:
2
# count pairs of points having distance between them equal to integral values in a k | function to find pairs whose distance between the points of is an integer value . ; stores count of pairs whose distance between points is an integer ; traverse the array , points [ ] ; stores distance between points ( i , j ) ; traverse all the points of current pair ; update temp ; update dist ; if dist is a perfect square ; update ans ; given value of k ; given points ; 
def cntPairs(points, n, K):
    ans = 0
    for i in range(0, n):
        for j in range(i + 1, n):
            dist = 0
            for k in range(K):
                temp = (points[i][k] - points[j][k])
                dist += temp * temp
            if (((dist)**(1 / 2)) * ((dist)**(1 / 2)) == dist):
                ans += 1
    print(ans)


K = 2
points = [[1, 2], [5, 5], [-2, 8]]
n = len(points)
cntPairs(points, n, K)

# Expected output:
1
# circumradius of a cyclic quadrilateral using the length of sides | program to find circumradius of a cyclic quadrilateral using sides ; function to return the circumradius of a cyclic quadrilateral using sides ; find semiperimeter ; calculate the radius ; 

import math


def Circumradius(a, b, c, d):
    s = (a + b + c + d) / 2
    radius = (1 / 4) * math .sqrt(((a * b) + (c * d)) * ((a * c) + (b * d))
                                  * ((a * d) + (b * c)) / ((s - a) * (s - b) * (s - c) * (s - d)))
    return radius


A = 3
B = 4
C = 5
D = 6
ans = Circumradius(A, B, C, D)
print(round(ans, 2))

# Expected output:
3.29
# area of triangle using side | python3 program to calculate the area of a triangle when the length of two adjacent sides and the angle between them is provided ; function to return the area of triangle using side - angle - side formula ; 

import math


def Area_of_Triangle(a, b, k):
    area = (1 / 2) * a * b * math .sin(k)
    return area


a = 9
b = 12
k = 2
ans = Area_of_Triangle(a, b, k)
print(round(ans, 2))

# Expected output:
49.1
# find if a point lies inside , outside or on the circumcircle of three points a , b , c | function to find the line given two points ; function which converts the input line to its perpendicular bisector . it also inputs the points whose mid - lies o on the bisector ; find the mid point ; x coordinates ; y coordinates ; c = - bx + ay ; assign the coefficient of a and b ; returns the intersection of two lines ; find determinant ; returns the intersection of two lines ; find determinant ; function to find the point lies inside , outside or on the circle ; store the coordinates radius of circumcircle ; line pq is represented as ax + by = c ; line qr is represented as ex + fy = g ; converting lines pq and qr to perpendicular bisectors . after this , l = ax + by = c m = ex + fy = g ; the of intersection of l and m gives r as the circumcenter ; length of radius ; distance between radius and the given d ; condition for lies inside circumcircle ; condition for lies on circumcircle ; condition for lies outside circumcircle ; 
def lineFromPoints(P, Q, a, b, c):
    a = Q[1] - P[1]
    b = P[0] - Q[0]
    c = a * (P[0]) + b * (P[1])
    return a, b, c


def perpenBisectorFromLine(P, Q, a, b, c):
    mid_point = [0, 0]
    mid_point[0] = (P[0] + Q[0]) / 2
    mid_point[1] = (P[1] + Q[1]) / 2
    c = (-b * (mid_point[0]) + a * (mid_point[1]))
    temp = a
    a = -b
    b = temp
    return a, b, c


def LineInterX(a1, b1, c1, a2, b2, c2):
    determ = a1 * b2 - a2 * b1
    x = (b2 * c1 - b1 * c2)
    x /= determ
    return x


def LineInterY(a1, b1, c1, a2, b2, c2):
    determ = a1 * b2 - a2 * b1
    y = (a1 * c2 - a2 * c1)
    print(y)
    y /= determ
    return y


def findPosition(P, Q, R, D):
    r = [0, 0]
    a, b, c = lineFromPoints(P, Q, 0, 0, 0)
    e, f, g = lineFromPoints(Q, R, 0, 0, 0)
    a, b, c = perpenBisectorFromLine(P, Q, a, b, c)
    e, f, g = perpenBisectorFromLine(Q, R, e, f, g)
    r[0] = LineInterX(a, b, c, e, f, g)
    r[1] = LineInterY(a, b, c, e, f, g)
    q = ((r[0] - P[0]) * (r[0] - P[0]) + (r[1] - P[1]) * (r[1] - P[1]))
    dis = ((r[0] - D[0]) * (r[0] - D[0]) + (r[1] - D[1]) * (r[1] - D[1]))
    if (dis < q):
        print("Point (", D[0], ",", D[1], ") is inside the circumcircle")
    elif (dis == q):
        print("Point (", D[0], ",", D[1], ") lies on the circumcircle")
    else:
        print("Point (", D[0], ",", D[1], ") lies outside the circumcircle")


if __name__ == '__main__':
    A = [2, 8]
    B = [2, 1]
    C = [4, 5]
    D = [3, 0]
    findPosition(A, B, C, D)

# Expected output:
63.0
Point ( 3 , 0 ) lies outside the circumcircle