Compléments olympiades 2019

Bonjour à tous
En m'inspirant des olympiades de math 2019. J'ai cherché une formule générale donnant le cardinal de E(p)=C(E(p))
E(p) est l'ensemble des triangles non aplatis de périmètre p.(on considère comme dans le sujet des triplets (x,y,z) avec x<=y<=z et x+y>z)

Je pense avoir trouvé: Il y a trois ingrédients:

1) Comme dans l'épreuve, on utilise le théorème de Pick. Pour pouvoir l'utiliser, p doit être égal à 6 mod 12.

On montre dans ce cas que C(E(p))=(p^2+12)/6

2) On trouve une formule donnant C(E(p+4)) en fonction de C(E(p))

On peut mettre en bijection E(p) et E(p+4) privé des couples (x;y,z) avec y=z
3) On trouve une formule donnant C(E(p+3)) en fonction de C(E(p))
On peut mettre en bijection E(p) et E(p+3) privé des triplets (x;y,z) avec x+y-1=z ou x=1
J'ai pas tout noté car la marge est trop petite;-)
Si ça intéresse quelqu'un je peux scanner mes papiers à mon retour de vacances.


Dans mon code
cardinal_avec_boucle(perimetre) donne ce cardinal en faisant des boucles et en testant.

La fonction cardinal_E(p): donne ce cardinal en faisant un simple calcul. J'ai vérifié que les formules étaient bonnes jusque 500.

Bien cordialement
Robert

from pylab import plot,show,close
# E(p) ensemble des triangles non aplatis de périmètre p
# C(E(p))=cardinal de E(p)
def test_triangle_non_aplati(x,y,z):
    if x+y>z:
        return True
    else:
        return False

def E(perimetre):
    X=[]
    Y=[]
    for x in range (1,perimetre//3+1):
        for y in range (max(perimetre//2-x+1,x),(perimetre-x)//2+1):
            if test_triangle_non_aplati(x,y,perimetre-x-y)==True:
                X=X+[x]
                Y=Y+[y]
    return X,Y


def cardinal_avec_boucle(perimetre):
    """ retourne C(E(p)) en faisant des boucles avec des tests"""
    return len(E(perimetre)[0])


def cardinal_E(p):
    """ retourne C(E(p)) en faisant un petit calcul"""
    beta=p%12
    alpha=p//12
    if beta==0:
        return 3*alpha**2
    if beta==1:
        return 3*alpha**2+2*alpha
    if beta==2:
        return 3*alpha**2+alpha
    if beta==3:
        return 3*alpha**2+3*alpha+1
    if beta==4:
        return 3*alpha**2+2*alpha
    if beta==5:
        return 3*alpha**2+4*alpha+1
    if beta==6:
        return 3*alpha**2+3*alpha+1
    if beta==7:
        return 3*alpha**2+5*alpha+2
    if beta==8:
        return 3*alpha**2+4*alpha+1
    if beta==9:
        return 3*alpha**2+6*alpha+3
    if beta==10:
        return 3*alpha**2+5*alpha+2
    if beta==11:
        return 3*alpha**2+7*alpha+4




def verification(p):
    n=3
    while cardinal_avec_boucle(n)==cardinal_E(n) and n<=p:
        n=n+1
    if n==p+1:
        print("programme vérifiée jusque ",p)
    else:
        print("erreur pour ",n-1)





verification(500)

##print(nombre_de_triangles(p))
##plot(E(p)[0],E(p)[1],'+')
##show()
##close()