Concours blanc Python

import numpy as np

def nbSomme3(n):
    renvoye = []
    for i in range(1, 7):
        for j in range(1, 7):
            for k in range(1, 7):
                if i + j + k == n:
                    renvoye.append([i, j, k])
    return len(renvoye)

def proba():
    dict = {}
    for i in range(1, 19):
        dict[i] = nbSomme3(i) / 216
    return dict

def esperance():
    somme = 0
    res = proba()
    for valeur in range(3, 19):
        somme += valeur * res[valeur]
    return somme

def nbSomme(d, s):
    nb = 0
    if d == 1:
        if s in [1, 2, 3, 4, 5, 6]:
            return 1
        else:
            return 0

    for i in range(1, 7):
        nb += nbSomme(d-1, s-i)
    return nb

def nbSommeImp(d, s):
    return -1

#Exercice 2

#5. On utilise A.shape()[0] pour les lignes, A.shape()[1] pour les colonnes

def colonnes(A):
    return A.shape[1]

def lignes(A):
    return A.shape[0]

def produit(A, B):
    assert colonnes(A) == lignes(B), "Matrices incompatibles"
    n, q = lignes(A), colonnes(B)
    renvoye = np.zeros((n, q))
    com = 0
    for i in range(n):
        for j in range(q):
            for k in range(colonnes(A)):
                renvoye[i][j] += A[i][k] * B[k][j]
                com+=1
    return renvoye

A = np.array(([1,3,4,1],[4,5,6,8],(8,3,0,5),(3,5,6,4)))
B = np.array(((3,4,1),(2,1,4),(8,3,0)))

# produit(A,B)

#7 Complexité : n*p*q (for avec n, for avec q, for avec p), pour une matrice carrée : n³

def strassen(A, B):
    if lignes(A) == 2:
        return produit(A, B)
    else:
        n = lignes(A)
        A1, A2, A3, A4, B1, B2, B3, B4 = np.zeros((n/2,n/2)), np.zeros((n/2,n/2)), np.zeros((n/2,n/2)), np.zeros((n/2,n/2)), np.zeros((n/2,n/2)), np.zeros((n/2,n/2)), np.zeros((n/2,n/2)), np.zeros((n/2,n/2))
        #Construction A1
        for i in range(int(n/2)):
            for j in range(int(n/2)):
                A1[i, j] = A[i, j]

        #Construction A2
        for i in range(int(n/2)):
            for j in range(int(n/2), int(n)):
                A2[i, j - int(n/2)] = A[i, j]

        #Construction A3
        for i in range(int(n/2), int(n)):
            for j in range(int(n/2)):
                A3[i - int(n/2), j] = A[i, j]

        #Construction A4
        for i in range(int(n/2), int(n)):
            for j in range(int(n/2), int(n)):
                A4[i - int(n/2), j - int(n/2)] = A[i, j]

        #Construction B1
        for i in range(int(n/2)):
            for j in range(int(n/2)):
                B1[i, j] = B[i, j]

        #Construction B2
        for i in range(int(n/2)):
            for j in range(int(n/2), int(n)):
                B2[i, j - int(n/2)] = B[i, j]

        #Construction B3
        for i in range(int(n/2), int(n)):
            for j in range(int(n/2)):
                B3[i - int(n/2), j] = B[i, j]

        #Construction B4
        for i in range(int(n/2), int(n)):
            for j in range(int(n/2), int(n)):
                B4[i - int(n/2), j - int(n/2)] = B[i, j]
        print("Appel")
        print(A)
        print(B1)
        print(B2)
        print(B3)
        print(B4)
        C1, C2, C3, C4 = np.zeros((n/2,n/2)), np.zeros((n/2,n/2)), np.zeros((n/2,n/2)), np.zeros((n/2,n/2))
        M1 = strassen((A1 + A4), (B1 + B4))
        M2 = strassen((A3 + A4), B1)
        M3 = strassen(A1, (B2 - B4))
        M4 = strassen(A4, (B3 - B1))
        M5 = strassen((A1 + A2), B4)
        M6 = strassen((A3 - A1), (B1 + B2))
        M7 = strassen((A2 - A4), (B3 + B2))

        C1 = M1 + M4 - M5 + M7
        C2 = M3 + M5
        C3 = M2 + M4
        C4 = M1 - M2 + M3 + M6

        C = np.zeros((n, n))

        for i in range(int(n/2), int(n/2)):
            for j in range(int(n/2), int(n/2)):
                C[i][j] = C1[i][j]
                C[i][j+int(n/2)] = C2[i][j]
                C[i+int(n/2)][j] = C3[i][j]
                C[i+int(n/2)][j+int(n/2)] = C4[i][j]
        return C

print(strassen(A, A))