Inscription / Connexion Nouveau Sujet

1 2 +


Posté par
dpi
re : L'arbre de Noel des premiers 24-12-20 à 15:50

Bonjour à tous,
Ce soir à minuit le concours sera terminé.
Personne n'a trouvé mieux que GBZM   pour le plus peti nombre premier dans l'étoile.

L\'arbre de Noel des premiers

Posté par
GBZM
re : L'arbre de Noel des premiers 25-12-20 à 19:00

Bonsoir,

Pour qui serait intéressé, je donne mon secret de fabrication (avec SageMath, bien sûr). J'utilise quatre procédures :

# Fabrication d'une liste de triplets de premiers consécutifs
# de sommes premières

def Triplet(p,q) :
    P=list(primes(p,q))
    T=[]
    for i in range(len(P)-2) :
        t=P[i:i+3]
        if add(t).is_prime() :
            T.append(t)
    return T


# Contrôle de fabrication d'un arbre

def controle(tt):
    F=flatten(tt); F.sort()
    if add(F).is_prime() :
        return all([F[i]!=F[i+1] for i in range(len(F)-1)])
    else : return False


# Fabrication d'une liste d'arbres d'étage un de plus 
# à partir d'une liste d'arbres

def PlusEtage(T,max=500) :
    TT=[]
    l=len(T)
    for i in range(l-2):
        for j in range(i+1,l-1):
            for k in range(j+1,l) :
                tt=[T[i],T[j],T[k]]
                if controle(tt) :
                    TT.append(tt)
                    if len(TT)==max :
                        print("Étage complété : {} arbres".format(len(TT)))
                        return TT
    print("Étage complété : {} arbres".format(len(TT)))
    return TT


# Fabrication d'une liste d'arbres d'étage un de plus 
# à partir de trois listes d'arbres

def PlusEtageter(T,U,V) :
    TT=[]
    for t in T:
        for u in U:
            for v in V :
                tt=[t,u,v]
                if controle(tt) :
                    TT.append(tt)
    print("Étage complété : {} arbres".format(len(TT)))
    return TT


Je commence par fabriquer trois listes d'arbres de trois étages au-dessus du rez de chaussée. Les intervalles où je prends mes premiers pour ces trois listes sont trouvés par un petit tâtonnement.

T1=PlusEtage(PlusEtage(Triplet(1,128)))
S=[add(flatten(t)) for t in T1]
print("Somme mini : {}; somme maxi : {}".format(min(S),max(S)))

Étage complété : 170 arbres
Étage complété : 22 arbres
Somme mini : 1613; somme maxi : 1613


T2=PlusEtage(PlusEtage(Triplet(128,390)))
S=[add(flatten(t)) for t in T2]
print("Somme mini : {}; somme maxi : {}".format(min(S),max(S)))

Étage complété : 134 arbres
Étage complété : 24 arbres
Somme mini : 7103; somme maxi : 7187


T3=PlusEtage(PlusEtage(Triplet(390,678)))
S=[add(flatten(t)) for t in T3]
print("Somme mini : {}; somme maxi : {}".format(min(S),max(S)))

Étage complété : 118 arbres
Étage complété : 168 arbres
Somme mini : 13877; somme maxi : 14639


À partir de ces trois listes, je bâtis un étage de plus. Je peux réduire la première liste à un seul élément puisque toutes les sommes sont les mêmes (1613).

T=PlusEtageter(T1[:1],T2,T3)
S=[add(flatten(t)) for t in T]
print("Somme mini : {}; somme maxi : {}".format(min(S),max(S)))
print("Indice d'un arbre de somme mini : {}".format(S.index(min(S))))

Étage complété : 192 arbres
Somme mini : 22937; somme maxi : 23209
Indice d'un arbre de somme mini : 0


On récupère en fait une flopée d'arbres de hauteur 5 et de somme 22937

Posté par
dpi
re : L'arbre de Noel des premiers 26-12-20 à 09:20

Bravo!
Je comprends que le peu d'amateurs...
J'ai environ 1000 de plus avec Excel:
*sélection des premiers
*sélection des triplets successifs.
*choix des 81 du bas donnant les 27 du premier étage.
*vérification des 9  du deuxième avec passage au triplet suivant si nécessaire .
*vérification simultanée du 3 éme et du 4 ème .
J'ai forcément laissé en route des bons triplets par rapport à toi.
  

Posté par
vham
re : L'arbre de Noel des premiers 18-01-21 à 00:12

Bonsoir, et Bonne année à tous,

Par pur plaisir, j'ai programmé sous VB.net
J'arrive quelque peu après les délais, mais je trouve d'emblée
un arbre 5 étages dont le sommet vaut 22691 < 22937
et je pense qu'on peut trouver encore moins, car
je n'ai pas cherché à optimiser l'étage "rez-de-chaussée"

Posté par
dpi
re : L'arbre de Noel des premiers 18-01-21 à 07:54

>vham
Bonne Année à toi aussi.
Tu peux donc nous donner ton arbre et tu partageras la couronne avec GBZM  

Posté par
GBZM
re : L'arbre de Noel des premiers 18-01-21 à 09:54

Bonjour,

Vham, je suis surtout curieux de voir ton programme (un peu commenté) et d'avoir une idée des temps d'exécution.

Posté par
vham
re : L'arbre de Noel des premiers 18-01-21 à 10:06

Bonjour,
J'ai pris la même démarche que GBZM en 3 arbres de 4 étages
avec les types et instructions simples du BASIC.
Nombres premiers définis par un crible et dans un tableau,
chacun accompagné d'une "signature" ( 2 à la puissance de sa position dans le tableau)

l'unicité des nombres premiers de l'étage rez-de-chaussée est définie
par construction des triplets de nombres premiers consécutifs,
Ensuite elle est maintenue par opérations logiques binaires "AND" et "OR"
sur les signatures affectées aux 3 nombres d'une somme.

L\'arbre de Noel des premiers

Posté par
vham
re : L'arbre de Noel des premiers 18-01-21 à 10:24

Bonjour,

--> GBMZ : Moins d'une seconde.
Les opérations logiques binaires "AND" et "OR" étant très rapides pour vérifier l'unicité,,
mon programme construit dans un fichier toutes les références de l'arbre 5 étages en 0.68 secondes
(Sur un PC Intel I5, 64 bits en mode debug de Visual Basic 2010 Express).

Posté par
vham
re : L'arbre de Noel des premiers 18-01-21 à 10:57

Visual Basic 2010 Express utilisé en Application Console.

Posté par
GBZM
re : L'arbre de Noel des premiers 18-01-21 à 15:50

Bravo !

Ce qui m'étonne le plus, c'est les temps que tu annonces.

Je retrouve ton record en modifiant un petit peu les paramètres de ma construction, mais avec des temps nettement plus longs :


%time T1=PlusEtage(PlusEtage(Triplet(1,128)))
CPU times: user 23.5 s, sys: 0 ns, total: 23.5 s
Wall time: 23.5 s
%time T2=PlusEtage(PlusEtage(Triplet(128,402)))
CPU times: user 20 s, sys: 0 ns, total: 20 s
Wall time: 20 s
%time T3=PlusEtage(PlusEtage(Triplet(402,674)))
CPU times: user 2.72 s, sys: 7.97 ms, total: 2.73 s
Wall time: 2.73 s
%time T=PlusEtageter(T1[-1:],T2,T3)
CPU times: user 677 ms, sys: 0 ns, total: 677 ms
Wall time: 675 ms

La différence vient peut-être du fait que ma procédure fait à chaque étape une recherche exhaustive de tous les arbres possibles. Par exemple, la dernière étape fournit 91 arbres de somme 22691. Par exemple :

[[[[7, 11, 13], [101, 103, 107], [109, 113, 127]],
  [[17, 19, 23], [67, 71, 73], [79, 83, 89]],
  [[29, 31, 37], [41, 43, 47], [53, 59, 61]]],
[[[139, 149, 151], [283, 293, 307], [347, 349, 353]],
  [[157, 163, 167], [229, 233, 239], [311, 313, 317]],
  [[211, 223, 227], [271, 277, 281], [389, 397, 401]]],
[[[409, 419, 421], [547, 557, 563], [659, 661, 673]],
  [[431, 433, 439], [491, 499, 503], [509, 521, 523]],
  [[449, 457, 461], [463, 467, 479], [617, 619, 631]]]]

Posté par
dpi
re : L'arbre de Noel des premiers 18-01-21 à 16:00

Bonjour
Sur Excel ,en m'appuyant sur un bout de wham j'arrive à 21863 dans le respect du 28-11-20 à 08:50

Posté par
GBZM
re : L'arbre de Noel des premiers 18-01-21 à 16:11

Peux-tu montrer ?

Posté par
dpi
re : L'arbre de Noel des premiers 18-01-21 à 16:50

Oui

L\'arbre de Noel des premiers

Posté par
GBZM
re : L'arbre de Noel des premiers 18-01-21 à 17:19

Tu as deux fois le triplet 1398, 149, 151 au rez-de-chaussée.
Tu as deux fois 163 et 167

Posté par
dpi
re : L'arbre de Noel des premiers 18-01-21 à 17:28

oui mais pas 1398 ?
c'était trop beau ,mais on peut essayer....

Posté par
GBZM
re : L'arbre de Noel des premiers 18-01-21 à 17:36

139,149,151 bien sûr

Posté par
vham
re : L'arbre de Noel des premiers 18-01-21 à 21:08

Bonsoir,

Le temps d'exécution que je donne est bien de l(ordre de la demi seconde, sans confusion avec quelques secondes.
le résultat  du programme s'affiche quasi instantanément, et encore plus vite si je ne demande pas d'affichage de listes à la console.
Pour chaque étage des 3 arbres,je crée une listes de noeuds (Structure en VB.net manipulée par valeurs)
un noeud n'est que "potentiellement" un noeud d'un arbre définitif que lorsque le sommet sera trouvé, aussi chaque noeud d'un étage conserve des "pointeurs" vers les nombres qui sont son origine à l'étage inférieur.Ce pourquoi l'unicité des nombres premiers du rez-de-chaussée est conservée dans chaque noeud.
Mais le mieux est peut-être de juger sur le code


   Structure Noeud
        Dim V, i0, i1, i2 As Integer ' Valeur somme des 3 nombres V en position i0,i1,i2 dans l'étage inférieur
        Dim U0, U1 As ULong 'signature pour unicité des nombres de l'étage 0
    End Structure

    Sub EtagePlus1(LE As List(Of Noeud), LS As List(Of Noeud), bvoir As Boolean) ' LE liste en entrée, LS en sortie
        Dim N As Noeud : Dim Nb As Integer = 0
        For ix = 0 To LE.Count - -3
            For iy = ix + 1 To LE.Count - 2
                For iz = iy + 1 To LE.Count - 1
                    Dim PPP As Integer = LE(ix).V + LE(iy).V + LE(iz).V
                    If Crible(PPP) = 1 Then
                        Dim a0 As ULong = LE(ix).U0 : Dim b0 As ULong = LE(iy).U0 : Dim c0 As ULong = LE(iz).U0
                        If (a0 And b0) = 0 AndAlso ((a0 Or b0) And c0) = 0 Then
                            Dim a1 As ULong = LE(ix).U1 : Dim b1 As ULong = LE(iy).U1 : Dim c1 As ULong = LE(iz).U1
                            If (a1 And b1) = 0 AndAlso ((a1 Or b1) And c1) = 0 Then
                                N.V = PPP : N.U0 = a0 Or b0 Or c0 : N.U1 = a1 Or b1 Or c1

                                Dim binsérer As Boolean = True 'test si N est déjà dans LS
                                For Each itemN In LS
                                    If itemN.V = N.V AndAlso itemN.U0 = N.U0 AndAlso itemN.U1 = N.U1 Then
                                        binsérer = False
                                        Exit For
                                    End If
                                Next
                                If binsérer Then
                                    N.i0 = ix : N.i1 = iy : N.i2 = iz
                                    LS.Add(N)
                                    If bvoir Then Voir(Nb & " " & VoirNoeud(LS(Nb)))
                                    Nb += 1
                                End If
                            End If ' N.U1
                        End If ' N.U0
                    End If ' crible
                Next
            Next
        Next
    End Sub ' EtagePlus1



Posté par
vham
re : L'arbre de Noel des premiers 19-01-21 à 15:43

Bonjour,

Mon minimum est maintenant de 22613 eu sommet de l'arbre de 5 étages
bien sûr, la rapidité d'exécution  ( < 0.5 secondes ) permet plusieurs ajustements successifs

Rez-de chaussée (étage 0) des 3 arbres de 4 étages
7 11 13 17 19 23 53 59 61 29 31 37 41 43 47 67 71 73 79 83 89 109 113 127 139 149 151
101 103 107 197 199 211 229 233 239 157 163 167 283 293 307 311 313 317 271 277 281 349 353 359 379 383 389
409 419 421 431 433 439 449 457 461 463 467 479 547 557 563 617 619 631 491 499 503 509 521 523 659 661 673
Sommet = 22613
Contrôle rez-de-chaussée OK.

Fin de programme 19/01/2021 15:40:41
0,4952439 secondes

Posté par
dpi
re : L'arbre de Noel des premiers 20-01-21 à 09:17

>vham
Je suis assez content d'avoir écrit cet exercice car lorsque on y rentre, on s'escrime...
J'avais dit que si on prenait les trios en suivant et en supposant que les étages
supérieurs seraient premiers ,on ne pouvait faire mieux que 22 495.
Je pense donc que ton 22 613 restera dans les annales.

Posté par
vham
re : L'arbre de Noel des premiers 21-01-21 à 10:55

Bonjour,

Ce que mon programme trouve en moins de 15 secondes :
Sommets possibles (arbres 5 étages) :  22613 22619 22639 22691 22907 22921 22937

Posté par
vham
re : L'arbre de Noel des premiers 23-01-21 à 15:27

Bonjour,

On peut encore faire mieux, mais je vais arrêter. Sommet = 22571

Rez-de chaussée (étage 0) des 3 arbres de 4 étages
5 7 11 17 19 23 29 31 37 41 43 47 53 59 61 139 149 151 67 71 73 101 103 107 157 163 167
83 89 97 109 113 127 229 233 239 197 199 211 271 277 281 311 313 317 283 293 307 337 347 349 379 383 389
409 419 421 457 461 463 547 557 563 431 433 439 467 479 487 491 499 503 509 521 523 617 619 631 641 643 647

étage 1 des 3 arbres de 4 étages
  23 59 97 131 173 439 211 311 487 269 349 701 607 829 941 883 1033 1151 1249 1381 1667 1303 1433 1493 1553 1867 1931
étage 2 des 3 arbres de 4 étages : 179 743 1009 1319 2377 3067 4297 4229 5351
étage 3 des 3 arbres de 4 étages : 1931 6763 13877

Sommets possibles avec mzq réglages entre 3 arbres :  22571 22613 22619 22637 22643 22679 en 12,4984639 secondes

Posté par
GBZM
re : L'arbre de Noel des premiers 26-01-21 à 11:38

Bravo vham !

Tu as beaucoup amélioré l'implémentation. Je copie ce que tu as fait en python en introduisant une classe "Noeud" et en faisant usage de "signatures" pour garder la trace des premiers du rez-de chaussée en permettant des opérations booléennes.

from sympy import ntheory as nt

class Noeud :    
    def __init__(self, parent1, parent2,parent3,valeur,signature):
        self.p1 = parent1
        self.p2 = parent2
        self.p3 = parent3
        self.v = valeur
        self.s = signature

# fabriquer l'arbre sous le noeud
def Arbre(noeud) :
        if type(noeud) == int :
            return noeud
        else :
            return (Arbre(noeud.p1),Arbre(noeud.p2),Arbre(noeud.p3))

# fabriquer une liste de noeuds constitués de triplets de premiers
# consécutifs de somme première
def Triplets(a,b) :
    Prems=[nt.prime(i+2) for i in range(a,b)]
    L=[]
    for i in range(a,b-2) :
        T=Prems[i-a:i-a+3]
        val=sum(T)
        if nt.isprime(val) :
            L.append(Noeud(T[0],T[1],T[2],val,2**i|2**(i+1)|2**(i+2)))
    return L

# à partir d'une liste de noeuds LE, fabrique une liste LS de noeuds
# de hauteur 1 de plus
def AjoutEtage(LE):
    l=len(LE)
    LS=[]
    signs=[]
    for i in range(l-2) :
        for j in range(i+1,l-1) :
            if (LE[i].s & LE[j].s == 0) :
                spart = LE[i].s | LE[j].s
                for k in range(j,l) :
                    if spart & LE[k].s == 0 :
                        val=LE[i].v+LE[j].v+LE[k].v
                        if nt.isprime(val) :
                            sign = spart | LE[k].s
                            if not(sign in signs) :
                                signs.append(sign)
                                LS.append(Noeud(LE[i],LE[j],LE[k],val,sign))
    return LS

# à partir de trois listes de noeuds, fabrique une liste de noeuds 
# de hauteur 1 de plus
def Trepied(LE1,LE2,LE3):
    LS=[]
    signs=[]
    for N1 in LE1 :
        for N2 in LE2 :
            if (N1.s & N2.s == 0) :
                spart = N1.s | N2.s
                for N3 in LE3 :
                    if spart & N3.s == 0 :
                        val=N1.v+N2.v+N3.v
                        if nt.isprime(val) :
                            sign = spart | N3.s
                            if not(sign in signs) :
                                signs.append(sign)
                                LS.append(Noeud(N1,N2,N3,val,sign))
    return LS

# fabrique un arbre minimal de hauteur 4 au-dessus du RdC 
# avec réglage des sous-arbres
def H4(a,b,c,d,e) :
    L1=AjoutEtage(AjoutEtage(Triplets(0,a)))
    L2=AjoutEtage(AjoutEtage(Triplets(b,c)))
    L3=AjoutEtage(AjoutEtage(Triplets(d,e)))
    L=Trepied(L1,L2,L3)
    Lv=[N.v for N in L]
    m=min(Lv) ; ind = Lv.index(m)
    print ("Arbre de sommet {0} :\n{1}".format(m,Arbre(L[ind])))


Avec les réglages adéquats :

%time L=H4(40,20,80,75,120)

Arbre de sommet 22571 :
((((5, 7, 11), (17, 19, 23), (29, 31, 37)), ((41, 43, 47), (53, 59, 61), (139, 149, 151)), ((67, 71, 73), (101, 103, 107), (157, 163, 167))), (((83, 89, 97), (109, 113, 127), (229, 233, 239)), ((197, 199, 211), (271, 277, 281), (311, 313, 317)), ((283, 293, 307), (337, 347, 349), (379, 383, 389))), (((409, 419, 421), (457, 461, 463), (547, 557, 563)), ((431, 433, 439), (467, 479, 487), (491, 499, 503)), ((509, 521, 523), (617, 619, 631), (641, 643, 647))))
CPU times: user 5.38 s, sys: 3.95 ms, total: 5.38 s
Wall time: 5.38 s

Posté par
dpi
re : L'arbre de Noel des premiers 26-01-21 à 19:00


Bravo à vous deux .
Je vais essayer d'en trouver une aussi sympa avec les nombres premiers.

Posté par
vham
re : L'arbre de Noel des premiers 13-02-21 à 18:37

bonjour,

Le 23-01-21 à 15:27 j'écrivais : "On peut encore faire mieux, mais je vais arrêter."
Le Sommet = 22571 est bien LE PLUS PETIT.

En effet :  sur la base de l'arbre complet, le plus petit triplet est 5+7+11=23
qui élimine 7+11+13=31  et 11+13+17=41 pour assurer l'unicité des nombres de la base,
Le triplet suivant est 17+19+23+=59 qui élimine....

On voit ainsi que les seul triplets qui pourraient faire gagner en  réduction sur 22571 sont :
79+83+89=251 qui remplacerait 83+89+97=269 pour un gain de 18
401+409+419=1229  qui remplacerait 409+419+421=1249  pour un gain de 20
449+457+ 461=1367 qui remplacerait 457+461+463=1381  pour un gain de 14
463+467+479=1409  qui remplacerait 467+479+487=1433  pour un gain de 24
mais aucune combinaison de ces quelques gains ne permet de remplacer 22571 par un nombre PREMIER plus petit.

Posté par
dpi
re : L'arbre de Noel des premiers 14-02-21 à 07:59

Bravo vham,
Tu n'as rien lâché....
J'ai  proposé un arbre composé de Premiers ,de Fibonacci premiers et de factorielles+1:
Le challenge est au moins d'en trouver un.
Si il y a plus de participants on peut tenter le plus petit sommet

Posté par
GBZM
re : L'arbre de Noel des premiers 14-02-21 à 10:10

vham @ 13-02-2021 à 18:37


En effet :  sur la base de l'arbre complet, le plus petit triplet est 5+7+11=23
qui élimine 7+11+13=31  et 11+13+17=41 pour assurer l'unicité des nombres de la base,

Cet argument ne me convainc pas.  Pourquoi la plus petite somme devrait-elle employer le plus petit triplet de premier successifs de somme première ?

Posté par
vham
re : L'arbre de Noel des premiers 14-02-21 à 16:54

Bonjour,

Le raisonnement complet est le suivant :
1) Lister par ordre de "somme croissante" tous les triplets de "nombres premiers consécutifs" dont la somme est un nombre premier
jusqu'au triplet de somme la plus grande utilisée dans la base de l'arbre de sommet 22571.
il y en a 47 jusqu'à 641+643+647=1931.
2) Cocher les 27 triplets utilisés dans l'arbre de sommet 22571
3) Colorer en rouge les triplets dont au moins un des nombres figure dans un triplet "coché"  qui lui est plus petit. Cela souligne en rouge l'unicité des nombres des triplets cochées.
il y en a alors 17 marqués en rouge .
4) Colorer en vert les triplets dont au moins un des nombres figure dans un triplet "coché" qui lui est plus grand. Cela complète l'unicité des nombres des triplets cochées.
il y en a alors 3 en vert.
Tous les triplets de la liste établie en 1) sont marqués.
Si on remplaçait un des triplets cochés par un triplet extérieur à la liste 1), on augmenterait le sommet 22571
De même si on décochait un des triplets cochés  pour le remplacer par un triplet en rouge alors libéré, on augmenterait le sommet 22571.
Reste l'action possible sur les triplets en vert tels que décrit le  13-02-21 à 18:37

Posté par
GBZM
re : L'arbre de Noel des premiers 14-02-21 à 18:35

Citation :
De même si on décochait un des triplets cochés  pour le remplacer par un triplet en rouge alors libéré, on augmenterait le sommet 22571.

Ton argument n'est toujours pas convaincant.  Tu envisages un seul remplacement à la fois. Il faudrait envisager  plusieurs remplacement simultanés.

Posté par
vham
re : L'arbre de Noel des premiers 14-02-21 à 20:02

Bonsoir,
--> GBZM : tu n'a pas bien lu ce que j'ai examiné.
J'ai pourtant écrit : " ...Aucune combinaison de ces quelques gains ..."
J'ai bien vérifié qu'aucun changement(s) d'affectations de 27 triplets dans la liste des 47 plus petits triplets qui  diminuerait la somme de 22571 n'était viable.
Et il ne peut être constitué 27 triplets de base sans utiliser au moins ces 47 premiers triplets !
As-tu seulement vérifié ma démarche en partant de la liste des 47 triplets décrite en 1) ?

Posté par
GBZM
re : L'arbre de Noel des premiers 14-02-21 à 22:56

Désolé, mais j'ai bien lu ce que tu as écrit, et ton argument ne me convainc toujours pas.
Je pense aussi qu'on ne peut pas faire mieux, mais ce que tu écris n'en constitue pas une démonstration, à mes yeux.

Posté par
vham
re : L'arbre de Noel des premiers 15-02-21 à 11:36

Bonjour,
Es-tu au moins convaincu que si plus petit sommet que 22571 il y avait, il utiliserait uniquement 27 des 47 plus petits triplets ?
C'est, à mon avis, l'argument le plus simple pour essayer d'obtenir une démonstration complète.

Posté par
GBZM
re : L'arbre de Noel des premiers 15-02-21 à 13:43

Pourquoi devrais-je être convaincu ?
Je ne vois pas d'argument convaincant dans ce que tu écris.
Pourquoi ne pourrait-on pas obtenir une somme plus petite avec 27 des 49 premiers triplets de premiers consécutifs de somme première ?

Posté par
vham
re : L'arbre de Noel des premiers 15-02-21 à 14:24

Ne pas oublier la condition d'unicité
(chaque nombre (premier) de la base ne doit être utilisé qu'une seule fois)
d'où 47 des premiers triplets pour pouvoir en utiliser 27.
Dis au moins en quoi l'argument du 15:02:2021 11:36 ne serait pas "convaincant". Car s'il fallait utiliser un triplet au delà des 47 premiers, il faudrait en abandonner un dans les 47 premiers....

Posté par
GBZM
re : L'arbre de Noel des premiers 15-02-21 à 16:18

Je n'oublie pas la condition d'unicité, et tu n'apportes aucun élément susceptible de me convaincre.

Je serais convaincu si tu démontrais qu'on ne peut pas remplacer N des 27 triplets  utilisés par K parmi les 47 premiers et N-K parmi les suivants, en respectant toujours la condition d'unicité, sans augmenter la somme.
Tu n'envisages dans l'argument que tu donnes que le remplacement d'UN des 27 utilisés par un triplet au-delà des 47 premiers. Ai-je mal compris ?

Un exemple très simplifié du genre de problème que je vois :
Quatre sommes de triplets a,b,c,d,  a+b+d pas premier, a+c+d marche. Mais on peut éventuellement faire plus petit en cherchant un nouveau triplet plus loin que d, de somme e, avec a+b+e. On n'a pas fait un seul remplacement, on a remplacé c et d par b et e.

Posté par
vham
re : L'arbre de Noel des premiers 15-02-21 à 20:08

Bonsoir,

je ne cherche plus à "convaincre".
Je ne veux simplement pas me lancer dans des investigations sur des combinaisons de quantités hors de portée (en temps) de mon ordinateur.
Je ne cherche donc qu'un raisonnement simple sur la structure de la base de l'arbre de sommet 22571 dont nous disposons.
Les 27 triplets de la base sont de somme déjà tellement optimisée pour donner 22571 qu'on doit pouvoir montrer que les possibilités d'autres configurations des 27 parmi les 47 qui n'augmenteraient pas 22571 sont limitées. Et de même que tout ajout au delà des 47 ne conviendrait pas.
Mais suis-je trop optimiste ?

Posté par
GBZM
re : L'arbre de Noel des premiers 15-02-21 à 20:40

Je pense moi aussi que l'on ne peut pas faire mieux. Mais je n'en ai pas la démonstration, et les arguments que tu avances n'en constituent pas une, à mon avis.

Posté par
dpi
re : L'arbre de Noel des premiers 16-02-21 à 07:38

Bonjour à vous deux,
Je propose d'en rester là.
De toute façon en prenant les plus petits 27 et sans tenir compte de la primarité
des couches supérieures on ne peut faire mieux que 22495.
Vous avez été excellents dommage que vham ait répondu après le 25 décembre

Posté par
vham
re : L'arbre de Noel des premiers 16-02-21 à 13:07

OK, en notant bien que le minimum accessible (le 22495 de dpi) correspond bien à 22571-18-20-14-24 (vham le 13:02 :21 18h37)

1 2 +


Répondre à ce sujet

Seuls les membres peuvent poster sur le forum !

Vous devez être connecté pour poster :

Connexion / Inscription Poster un nouveau sujet
Une question ?
Besoin d'aide ?
(Gratuit)
Un modérateur est susceptible de supprimer toute contribution qui ne serait pas en relation avec le thème de discussion abordé, la ligne éditoriale du site, ou qui serait contraire à la loi.


Vous devez être membre accéder à ce service...

Pas encore inscrit ?

1 compte par personne, multi-compte interdit !

Ou identifiez-vous :


Rester sur la page

Désolé, votre version d'Internet Explorer est plus que périmée ! Merci de le mettre à jour ou de télécharger Firefox ou Google Chrome pour utiliser le site. Votre ordinateur vous remerciera !