def affiche(X):
    for x in X:
        print(x)

def somme(X):
    S = 0
    for x in X:
        S += x
    return S

def moyenne(X):
    return somme(X) / len(X)

def compte(X):
    m = moyenne(X)
    c = 0
    for x in X:
        if x > m:
            c += 1
    return c

def sigma(X):
    m = moyenne(X)
    S = 0
    for x in X:
        S += (x-m)**2
    return S

def ecart_type(X):
    return (sigma(X)/len(X))**(1/2)

UPDATE Tournoi
SET catégorie = 'WTA 1000'
WHERE catégorie = 'WTA Premiere Mandatory' 
OR catégorie = 'WTA Premier 5'

def matrice_zeros(n):
    return [[0]*n for _ in range(n)]

def matrice_id(n):
    M = matrice_zeros(n)
    for i in range(n):
        M[i][i] = 1
    return M

def sigma(L, U, i, j):
    S = 0
    for k in range(i):
        S += L[i][k] * U[k][j]
    return S

def doolittle(M):
    n = len(M)
    L = matrice_id(n)
    U = matrice_zeros(n)
    for i in range(n):
        for j in range(i, n):
            U[i][j] = M[i][j] - sigma(L, U, i, j)
        for j in range(i+1, n):
            L[j][i] = (M[j][i] - sigma(L, U, j, i)) / U[i][i]
    return L, U

def descente(L, Y):
    n = len(L)
    Z = [0] * n
    for i in range(n):
        S = 0
        for j in range(i):
            S += L[i][j]*Z[j]
        Z[i] = Y[i] - S
    return Z

def remonte(U, Z):
    n = len(U)
    X = [0] * n
    for i in range(n):
        S = 0
        for j in range(n-1, i, -1):
            S += U[i][j] * X[j]
        X[i] = (Z[i] - S) / U[i][i]

def tri_sequence(S):
    n = len(S)
    for p in range(n):
        for i in range(n-1):
            if S[i] > S[i+1]:
                S[i], S[i+1] = S[i+1], S[i]
    return S

def sous_sequence(X, Y):
    j = 0
    for i in range(len(X)):
        while j < len(Y) and Y[j] != X[i]:
            j+=1
        if j == len(Y):
            return False
    return True

def taille_PLSSC(X, Y):
    if len(X) == 0 or len(Y) == 0:
        return 0
    if X[-1] == Y[-1]:
        return 1 + taille_PLSSC(X[:-1], Y[:-1])
    return max(taille_PLSSC(X[:-1], Y), taille_PLSSC(X, Y[:-1]))

def matrice_nulle(n, p):
    return [[0] * (p+1) for _ in range(n+1)]

def matrice_tailles(X, Y):
    n, p = len(X), len(Y)
    M = matrice_nulle(n, p)
    for i in range(n+1):
        for j in range(p+1):
            if i == 0 or j == 0:
                M[i][j] = 0
            elif X[i-1] == Y[i-1]:
                M[i][j] = 1 + M[i-1][j-1]
            else :
                M[i][j] = max(M[i][j-1], M[i-1][j])
    return M

def taille_plssc(X, Y):
    return matrice_tailles(X, Y)[-1][-1]