Bonjour,
Vous me voyez très content que vous soyez content que nous soyons contents... ^_^
Très bien..., j'avais plutôt l'impression d'apprendre de votre programmation, ; donc alors chacun de nous apprend de l'autre.
Voilà (légèrement retouché pour gagner des instructions) ce que j'ai envoyé à
O^O :*
#!/usr/bin/python
# -*- coding: UTF-8 -*-
from math import sqrt
from operator import itemgetter
def triangles(Max,nombre,Trg):
for AC,BC,AB in Trg:
AC2,BC2,AB2 = AC**2,BC**2,AB**2
b=AB-1
for AM in range(1, b):
AM2 = AM**2
for BM in range(AB - AM + 1,Max):
BM2 = BM**2
xc = (AC2 + AB2 - BC2)/(2 * AB)
yc = sqrt(AC2 - xc**2)
xm = (AM2 + AB2 - BM2)/(2 * AB)
ym = sqrt(AM2 - xm**2)
if ym * xc - (xm * yc) + 0.001 < 0 and ym * (xc - AB) - (yc * (xm - AB)) - 0.001 > 0:
#M est intérieur
CMd = sqrt((xm - xc)**2 + (ym - yc)**2)
CM=int(CMd + 0.0000001)
if abs(CM - CMd) < 0.000001:
#recalcul sur entiers
xcL = AC2 + AB2 - BC2
xmL = AM2 + AB2 - BM2
Yc2 = 4 * AB2 * AC2 - (xcL**2) #4*AB*AB*yc*yc
Ym2 = 4 * AB2 * AM2 - (xmL**2) #4*AB*AB*ym*ym
g = 2 * AB2 * (AC2 + AM2 - CM**2) - ((AB2 + AM2 - BM2) * (AC2 + AB2 - BC2))
if g**2 == Yc2 * Ym2:
nombre += 1
print("N°","%4i" % nombre," : ","%3i" % AC,"%3i" % BC,"%3i" % AB," --- ","%3i" % AM,"%3i" % BM, "%3i" % CM)
if nombre == 1300:
return
else:
break
# Triangles à cotés entiers classés par pérmètres croissants
maxp=336 # Choisir la valeur limite pour le périmètre
nombre=0
Trg,Peri,nb=[(0,0,0,0),(1,0,0,0),(2,0,0,0),(3,1,1,1),(4,0,0,0)],[],5
Dico={0:[0,1],1:[0,1],2:[0,1],3:[1,2],4:[0,1]}
for p in range(5,maxp): # p est le périmètre
nb1=nb
for AC in range(1,maxp): # AC sera limité bien avant maxp
BC=(p-AC)//2 # division euclidienne
if BC<AC:
break # AC est trop grand, passer à la valeur suivante de AC
AB=p-AC-BC
while 1: # boucle pour tous les triangles tels que AC<=BC<=AB
if AB>=AC+BC: # le triangle n'existe pas
break # donc sortie de la boucle while...
#print("périmètre =",p,AC,BC,AB)
nb+=1
Trg.append((p,AC,BC,AB)) # Stockage du quadruplet trouvé
BC-=1 #triangle suivant de même périmètre
AB+=1
if BC<AC:
break
Dico.update({p:[nb1,nb]}) # je complète mon dictionnaire
for p in range(5,maxp):
dp=p/2
a,b=Dico[p]
Ordre=[]
if b-a>1: # s'il y a plus d'un triangle de périmètre p
Peri=Trg[a:b]
for i,(x,y,z,t)in enumerate(Peri):
s=dp*sqrt(dp*(dp-y)*(dp-z)*(dp-t)) # Formule de Heron
Ordre.append((i,s))
Ordre=sorted(Ordre,key=itemgetter(1)) # tri sur 2e élément d'un tuple
for i,(x,s) in enumerate(Ordre): # évite gestion compteur
Trg[a+i]=Peri[x] #remplacement par les tuples triés
#je ne garde que les n-5 derniers enregistrements
Trg=Trg[5:]
Tr=[]
for (p,x,y,z) in Trg:
Tr.append((x,y,z)) # nouvelle liste sans périmètres
del(Trg) # Suppression 1ere liste : gain espace mémoire
triangles(maxp,nombre,Tr) # Appel du prog totomm
Je râle assez quand je n'ai pas connaissance de la "philosophie" qui sous-tend un programme pour ne pas prêter le flanc à mon tour...
Voici donc le pourquoi de ce qui figure ci-dessus.
Il me fallait conserver les périmètres et les longueurs des côtés :
Créer une liste de listes ? plusieurs listes ? En point de mire : les tris futurs. Je n'ai pas fait d'essais, mais ça ne me tentait pas...
J'ai finalement opté pour des tuples : je garde tout ensemble et les tris de tuples sur un élément quelconque est très facile pour qui a déjà rencontré itemgetter et employé.
C'est peut-être un peu plus lourd, je ne sais pas : question programmation je me fie à mon instinct, même s'il lui est arrivé d'être défaillant...
Après, j'étais face à l'alternative suivante :
* Relever tous les triangles de même périmètre et leurs côtés
après constitution de la liste.
Ce 1er point était faisable mais il y avait beaucoup de code pour mon goût
* Les relever pendant leur création ou pouvoir les retrouver facilement après.
J'avais envisagé une liste de listes, mais j'ai trouvé ça trop pénible à gérer (encore l'instinct ? Oui et non. J'ai fait quelques essais quand même...)
J'ai fini par opter pour un dictionnaire où les clés étaient les périmètres avec [indice 1er triangle:indice 2e triangle+1] comme valeurs
D'où la suppression ultérieure de 3 boucles dans votre script initial puisque les les triangles (tous) sont déjà existants.
Il n'y a plus qu'à charger les 3 côtés : encore un tuple. J'aurais pu utiliser une liste, mais il m'aurait fallu charger les éléments par 3...
Et les affecter ensuite. Avec un tuple, c'est plus immédiat
Mais il fallait encore les trier sur les aires, si plus d'un triangle.
Là encore, j'ai préféré traiter au fur et à mesure les triangles de même aire dans une liste à part : Peri.
A partir de Peri, où je n'ai pas vu comment trier sur place, j'ai créé une autre liste de couples (indice dans Peri, aire) que j'ai triée.
L'ordre devant être retrouvé j'ai trié sur le 2e élément, l'aire.
Pour trier des tuples sur n'importe quel élément emploi de
itemgetter(indice) obligatoire.
Et comme je l'ai déjà indiqué, pour un tri /aires décroissantes dans sorted, on rajoute reverse=True à la fin.
Noter que sur les listes simples, reverse() donne la liste inversée :
>>> Y=[1,7,4,8,2,9,10]
>>> Y.reverse()
>>> Y
[10, 9, 2, 8, 4, 7, 1]
>>>
J'espère que si vous aviez eu besoin d'éclaircissements, ceux-ci ont été suffisants.
@+