Suite de nombres premiers

Fly7 · 29 Sep

Bonjour,

Je souhaiterais savoir si la suite suivante vous évoque quelque chose :

(2, 3, 2, 5, 2, 7, 2, 3, 2, 11, 2, 13, 2, 3, 2, 17, 2, 19, 2, 3, 2, 23, 2, 5, 2, 3, 2, 29, 2, 31, 2, 3, 2, 5, 2, 37, 2, 3, 2, 41, 2, 43, 2, 3, 2, 47, 2, 7, 2, 3, 2, 53, 2, 2, 2, 3, 2, 59, 2, 61, 2, 3, 2 ...).

Je l’ai trouvée en décomposant les entiers naturels en produits de nombres premiers par colonne (voir document). Je remarque qu’à chaque ligne, il est possible d’identifier cette suite, à l’exception de quelques cas spécifiques que j’ai mis en évidence avec un fond jaune.

J’imagine que cette suite est déjà connue, mais j’aimerais en avoir la confirmation.

Cordialement,
Thomas.

lourrran · 29 Sep

Cette suite apparaît sur toutes les lignes, sauf sur les lignes où elle n'apparaît pas... En fait, elle apparaît sur la 2ème ligne uniquement.
Chacune des lignes a un profil un peu différent. Chacune des lignes est 'intéressante', pourquoi pas. A priori, cette 2ème ligne ne figure pas sur OEIS. Je pense que tu peux la déposer, et tu auras laissé une trace dans l'histoire.

Si tu veux, je te suggère une autre liste. Compter le nombre de termes dans chaque colonne. Pour chacune des colonnes, on a un certain nombre de facteurs, par exemples 60 a 4 facteurs (2,2,3,5) Et donc, le 60ème terme de cette suite serait 4.
Le début serait donc 0,1,1,2,1,2,1,3,2,2,1,3,1,2,2,4,1,3,1,3,2,2,1,4,2,2,3 ....

Tu peux aussi prendre ton tableau, et le recopier 'colonne par colonne' : les facteurs de $2$, puis les facteurs de $3$, ... puis les facteurs de $n$ : 2,3,2,2,5,2,3,7,2,2,2,3,3,2,5,11,2,2,3,13,2,7,3,5,2,2,2,2,17,2,3,3,19,2,2,5,3,7,2,11,23,2,2,2,3,5,5 etc etc
Plein de suites qui gagneraient à être connues.
Ou pas.

Fly7 · 29 Sep

Je peux également remarquer que les exceptions en jaune forment elles aussi des suites que l'on peut visualiser sur chaque ligne, hormis une nouvelle exception en mauve, aux armes et cætera.

https://www.youtube.com/watch?v=cPJWZILeLzU

lourrran · 29 Sep

Sur chaque ligne ... , bof bof bof.
La première ligne commence par 2,3,2,5 , le nombre 11 apparaît pour la première fois en 10ème position, 19 apparaît pour la première fois en 18ème position.
Sur la 2ème ligne, on commence par 2,3,2,3,5. Tu as oublié de mettre en jaune le nombre 3 dans la colonne '9'. Passons.
Le nombre 11 apparaît pour la 1ère fois en 13ème position. Donc déjà un décalage, avec 3 intrus.
Tu t'es arrêté à 64, donc, sur la 6ème ligne, tu as un seul nombre.
C'est un peu court pour conclure .... 'a chaque ligne', quand dès la 6ème ligne, tu regardes un seul nombre.

Est-ce que tu as essayé d'évaluer à quel rang 11 apparaîtrait pour la 1ère fois dans cette 6ème ligne ?
Et à quel rang $R(37,8,2)$ 37 apparaîtrait pour la 8ème fois dans la 2ème ligne ?
Et à quel rang $R(37,8,9)$ 37 apparaîtrait pour la 8ème fois dans la 9ème ligne ?

Si ces 2 nombres $R(37,8,2)$ et $R(37,8,9)$ sont relativement proches, on peut valider ce que tu écris.
Mais j'ai bien peur que l'un des 2 soit BEAUCOUP plus grand que l'autre.

Fly7 · 29 Sep

Est-ce que tu as essayé d'évaluer à quel rang le 11 apparaîtrait pour la première fois dans cette 6ème ligne ?
Non, par contre, je sais qu'il se trouve dans la colonne $11\times2^{6-1}=352$

Et à quel rang R(37,8,2) 37 apparaîtrait pour la 8ème fois dans la 2ème ligne ?

pour la ligne 1 : $37+(37\times2)\times(8-1)= 555$

le nombre 37 apparaît pour la 8ème fois a la colonne 555 a la ligne 1
Pour la ligne 2 : $555\times2^{2-1}=1110$

le nombre 37 apparaît pour la 8ème fois a la colonne 1110 a la ligne 2

Et à quel rang R(37,8,9) 37 apparaîtrait pour la 8ème fois dans la 9ème ligne ?

Pour la ligne 9 : $555\times2^{9-1}=142 080$

le nombre 37 apparaît pour la 8ème fois a la colonne 142080 a la 9ème ligne

Pourrais tu définir ce que tu veux dire par rang?

Fly7 · 29 Sep

En fait, pour le moment, vu que je n’ai pas encore trouvé de méthode automatisée, j'ai trouvé trois suites.
La première, que l'on voit sur la première ligne :
(2, 3, 2, 5, 2, 7, 2, 3, 2, 11, 2, 13, 2, 3, 2, 17, 2, 19, 2, 3, 2, 23, 2, 5, 2, 3, 2, 29, ...)
La deuxième, en jaune, que l'on voit à partir de la deuxième ligne :
(3, 5, 7, 5, 3, 11, 7, 13, 3, 7, 17, 11, 19, 3, 13, 23, 5, 11, 3, 17, 29, ...)
Puis une troisième en mauve, que l'on voit à partir de la troisième ligne :
(3, 5, 7, 5, 3, 11, 7, 13, 5, ...)
Etc.
Toutes ces suites sont visibles sur toutes les lignes suivantes, avec un espacement qui double à chaque changement de ligne.

Dom · 29 Sep

Bonsoir,

je n’ai pas compris pourquoi on colorie ou pourquoi on ne colorie pas en jaune (resp. violet).

Cordialement

Dom

lourrran · 29 Sep

Les jaunes, c'est une suite qui se répète sur toutes les lignes... sauf cas parasites.
Et ces cas parasites, ils sont en violet, et eux aussi se répètent sur toutes les lignes.
D'autres parasites vont forcément apparaître sur les lignes suivantes, et ils auront une autre couleur.

Donc comme on s'autorise à 'gommer' toutes les différences, en leur donnant une nouvelle couleur, forcément, oui, toutes les lignes sont identiques.

Fly7 · 30 Sep

Dom :
Les nombres non coloriés représentent la première suite.

Je peux leur attribuer une couleur si ça te perturbe.

Je pense ne pas avoir entièrement compris la structure de ces suites.

Il me faut voir un peu plus loin pour en être sûr.

troisqua · 30 Sep

Je trouve que shtam est rafraîchissant (ou pas). On y découvre des êtres incroyables, venus d'ailleurs, vivant dans un monde parallèle... ou perpendiculaire ce n'est pas important, empli de couleurs, de rêves d'avoir découvert des trésors, d'envies de vivre à part et où les autres mathématiciens classiques (donc, au fond, méprisables) ne sont que des cailloux sur le chemin de la gloire.

Bon vol à toi @Fly7 !

LEG · 30 Sep

Fly7 a dit :
Je pense ne pas avoir entièrement compris la structure de ces suites.

Ben , peut être que tu devrais lire le TFA (théorème fondamental de l'Arithmétique) qui dit :
tout entier strictement positif peut être écrit comme un produit de nombres premiers d'une unique façon, à l'ordre près des facteurs.

Alors je pense , que tu ne vas pas avoir assez de couleur pour marquer ceux qui différencie tes lignes de facteurs premiers , je suppose que tu vas ensuite utiliser "l'arc en ciel " ça va être fun... car imagine , lorsque tu vas avoir un entier naturel qui se décompose avec 1000 facteurs premiers , si tu arrives à le décomposer...

Fly7 · 30 Sep

Désolé, LEG, rien à voir avec ce que tu penses.
Merci, troisqua, pour le compliment. Par contre, je ne mettrais pas en opposition les amateurs et le monde académique.
Tout le monde est utile dans son domaine, à condition de ne pas faire des enfantillages.
Personne n'est à l'abri de dire des conneries.

Quand j’ai dit :

Fly7 a dit :
Je pense ne pas avoir entièrement compris la structure de ces suites.

Je pensais au fait que les suites 2 et 3 étaient vraiment proches, mais après avoir vérifié plus en détail, elles sont vraiment différentes. C’est tout de même déstabilisant. Je soupçonne que je me sois trompé ou qu'il y ait quelque chose que je n’ai pas compris.

2 3 2 5 2 7 2 3 2 11 2 13 2 3 2 17 2
3 5 7 5 3 11 7 13 3 7 17 11 19 3 13 23 5
3 5 7 5 3 11 7 13 5 3 7 17 11 19 29 7 47
5

lourrran · 30 Sep

Ces suites sont différentes.
Tu dis que c'est déstabilisant, mais tu pas partir du principe suivant : avec les nombres premiers, tous les problèmes qui peuvent éventuellement arriver finissent par arriver.
Et il faut être un peu sérieux.
Tu travailles avec les nombres premiers plus petits que 100. Peut-être que tu es allé jusqu'à 1000 colonnes dans ton tableau, mais si on regarde la 2ème ou la 3ème ligne, ça reste des nombres très petits.
Tout ça, ce sont des nombres petits petits petits.
Même si tu trouves des trucs qui ont l'air de marcher sur ces petits nombres, il faut les vérifier sur des nombres, beaucoup plus grands, jusqu'à 100 Milliards ou plus.
Si ça marche jusqu'à 100 Milliards, alors ça commence à devenir sérieux.

Fly7 · 30 Sep

Un début de programme pour vérifier jusqu'à 100 milliards

def prime_factors_decomposition(n):
    # Fonction pour décomposer un nombre en produit de facteurs premiers
    def prime_factors(num):
        if num == 1:
            return [1]  # 1 n'a pas de facteurs premiers, donc on retourne [1]
        i = 2
        factors = []
        while i * i <= num:
            while (num % i) == 0:
                factors.append(i)
                num //= i
            i += 1
        if num > 1:
            factors.append(num)
        return factors

    # Liste qui va contenir les décompositions de tous les nombres
    factorizations = []

    # Parcours de chaque nombre de 1 à n
    for num in range(1, n + 1):
        factors = prime_factors(num)
        factorizations.append(factors)

    return factorizations


def generate_prime_lists(n):
    factorizations = prime_factors_decomposition(n)

    # Créer les listes pour les premiers, seconds, et troisièmes facteurs premiers
    prime_lists = []
    index = 0

    while True:
        current_list = []
        has_factors = False  # Pour arrêter si tous les éléments sont 1 (remplaçant de 0)

        for factors in factorizations:
            # Ajouter le facteur à la position index si disponible, sinon ajouter 1
            if len(factors) > index:
                current_list.append(factors[index])
                has_factors = True
            else:
                current_list.append(1)

        # Si plus aucun nombre n'a de facteur à cette position, on s'arrête
        if not has_factors:
            break

        prime_lists.append(current_list)
        index += 1

    return prime_lists


# Demande à l'utilisateur de fournir une limite n
n = int(input("Entrez un nombre limite n : "))

# Obtenir les résultats
prime_lists = generate_prime_lists(n)

# Affiche les résultats
for i, prime_list in enumerate(prime_lists):
    print(f"Liste des {i+1}ème plus petits nombres premiers pour chaque nombre de 1 à {n} : {prime_list}")

Entrez un nombre limite n : 20
Liste des 1ème plus petits nombres premiers pour chaque nombre de 1 à 20 : [1, 2, 3, 2, 5, 2, 7, 2, 3, 2, 11, 2, 13, 2, 3, 2, 17, 2, 19, 2]
Liste des 2ème plus petits nombres premiers pour chaque nombre de 1 à 20 : [1, 1, 1, 2, 1, 3, 1, 2, 3, 5, 1, 2, 1, 7, 5, 2, 1, 3, 1, 2]
Liste des 3ème plus petits nombres premiers pour chaque nombre de 1 à 20 : [1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 3, 1, 1, 1, 2, 1, 3, 1, 5]
Liste des 4ème plus petits nombres premiers pour chaque nombre de 1 à 20 : [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1]

Image: https://les-mathematiques.net/vanilla/uploads/editor/u0/1jaicddf1ayd.jpg

querty · 1 Oct

Je ne suis vraiment pas sûr d'avoir compris ce que tu veux dire, et une explication serait la bienvenue. Bon bref, pour l'instant, et pour moi, c'est juste normal ,parce que tes entiers, tu les prends par ordre croissant

Liste des 1ème plus petits nombres premiers pour chaque nombre de 1 à 20 : [1, 2, 3, 2, 5, 2, 7, 2, 3, 2, 1...19, 2]

Liste des 2ème plus petits nombres premiers pour chaque nombre de 1 à 20 : [1, 1, 1, 2, 1, 3, 1, 2, 3, 5, 1, 2, 1, 7, 5, 2, 1, 3, 1, 2]

Liste des 3ème plus petits nombres premiers pour chaque nombre de 1 à 20 : [1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 3, 1, 1, 1, 2, 1, 3, 1, 5]

Liste des 4ème plus petits nombres premiers pour chaque nombre de 1 à 20 : [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1]

Chaurien · 1 Oct

https://oeis.org/A020639 ?

Fly7 · 1 Oct

Fly77 · 1 Oct

Liste des 1ème plus petits nombres premiers pour chaque nombre de 1 à 20 : [1, 2, 3, 2, 5, 2, 7, 2, 3, 2, 1...19, 2]

Liste des 2ème plus petits nombres premiers pour chaque nombre de 1 à 20 : [1, 1, 1, 2, 1, 3, 1, 2, 3, 5, 1, 2, 1, 7, 5, 2, 1, 3, 1, 2]

Liste des 3ème plus petits nombres premiers pour chaque nombre de 1 à 20 : [1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 3, 1, 1, 1, 2, 1, 3, 1, 5]

Liste des 4ème plus petits nombres premiers pour chaque nombre de 1 à 20 : [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1]
Liste des 1ers plus petits nombres premiers se retrouve dans toutes les autres listes supérieures à 1. Je la mets en gras pour qu'elle soit visible. L'intervalle de cette liste augmente de 2^x à chaque changement de liste. Si tu cribles la Liste des 2èmes plus petits nombres premiers à la 1ère plus petits nombres premiers, tu obtiens une autre liste qui se trouve dans toutes les Listes des plus petits nombres premiers supérieurs à 2. Évidemment, ça continue à l'infini. Je suis en train de faire faire le programme à GPT. Comme je suis brouillon, ça ne va pas aussi vite que je l'espère.

lourrran · 1 Oct

@Chaurien,
Oui pour la 1ère ligne, le plus petit facteur premier de chaque entier.
Mais ensuite, pour le 2ème plus petit facteur premier, puis le 3ème etc etc
J'ai cherché sur OEIS, mais je dois avoir un problème avec ce site, je ne trouve jamais rien sur OEIS.

@Fly7, ne te prend pas trop la tête.
ça va te donner quoi ? Tu auras un outil pour agrandir ton tableau. Plein de colonnes, et beaucoup plus de suites.
C'est quoi le plan ensuite ?
- constater que les lignes se ressemblent ? Oui , les lignes vont se ressembler.
- extraire à chaque fois une nouvelle couleur , c'est à dire isoler les différences entre la couleur jaune et la couleur mauve, et ainsi de suite pour les lignes suivantes. Ok, tu vas avoir de nouvelles suites, une nouvelle suite pour chaque ligne.
- regarder si ces suites se ressemblent ? Oui, elles vont se ressembler.
- regarder si ces suites sont identiques ? Non, elles ne seront pas identiques.

querty · 1 Oct

Je ne comprends toujours pas parce que pour moi c'est juste normal. Donc, si c'est un nombre premier, c'est 1. Si ce n'est pas un nombre premier, tu prends le plus petit facteur qui décompose ce nombre.

Donc, comme tu prends les nombres dans l'ordre, c'est juste normal de voir apparaître le deux avant le trois.

Parce que si ce n'est pas le cas, cela veut dire que tu as un trou dans la progression de tes entiers.

En gros, imagine que tu vois un 3, comme le 2 existe, où est-ce que tu le mets l'entier avec le 2?

Perso moi je le met avant le 3

Fly7 · 27 Oct

Je ne suis pas totalement certain du programme.
Il faudrait que je vérifie ce 5 dans la 4e suite, que j'ai trouvé manuellement et qui contredit le résultat obtenu par le programme.
Je vérifierai plus tard, car ça me donne la mixomatose, et j’ai l’impression d’être un autiste à passer des heures à vérifier tous ces nombres.

Mon intuition sur la ressemblance des suites semble en effet se confirmer :
elles ne sont jamais identiques, mais plus on avance dans les calculs, plus elles se ressemblent, comme si elles tendaient vers une forme de convergence.

def factorisation_premiers(n):
    """Décompose un nombre en ses facteurs premiers."""
    if n == 1:
        return []
    
    facteurs = []
    diviseur = 2
    
    while n > 1:
        while n % diviseur == 0:
            facteurs.append(diviseur)
            n //= diviseur
        diviseur += 1 if diviseur == 2 else 2
        
        if diviseur * diviseur > n:
            if n > 1:
                facteurs.append(n)
            break
            
    return facteurs

def trouver_exposant(n):
    """Trouve l'exposant k tel que n = 2^k."""
    k = 1
    while (1 << k) <= n:
        k += 1
    return k

def generer_suites_completes(n, nb_termes):
    """Génère toutes les suites demandées."""
    k_max = trouver_exposant(n)
    
    # Stocker les suites i;i pour le résumé
    suites_resume = {}
    
    # Générer les suites originales
    print(f"n : {', '.join(str(i) for i in range(1, n + 1))}")
    
    # Générer et stocker les suites 1;k
    suites_1k = []
    for position in range(k_max):
        suite_courante = []
        for num in range(1, n + 1):
            facteurs = factorisation_premiers(num)
            suite_courante.append(str(facteurs[position]) if position < len(facteurs) else '-')
        suites_1k.append(suite_courante)
        print(f"Suite 1;{position + 1} : {', '.join(suite_courante)}")
        if position == 0:  # Stocker Suite 1;1 pour le résumé
            suites_resume["1;1"] = suite_courante
    
    # Générer et stocker toutes les suites pour pouvoir les référencer
    toutes_suites = {f"1;{i+1}": suites_1k[i] for i in range(len(suites_1k))}
    
    # Pour chaque niveau i de 1 à k_max-1
    for i in range(1, k_max):
        # Générer les suites A;i;k
        for k in range(i+1, k_max + 1):
            suite_decalee = ['-'] * n
            suite_source = toutes_suites[f"{i};{i}"] if i > 1 else suites_1k[0]
            
            for pos in range(n):
                if suite_source[pos] != '-':
                    nouvelle_pos = (pos + 1) * (2 ** (k-i))
                    if nouvelle_pos <= n:
                        suite_decalee[nouvelle_pos - 1] = suite_source[pos]
            
            toutes_suites[f"A;{i};{k}"] = suite_decalee
            print(f"Suite A;{i};{k} : {', '.join(suite_decalee)}")
        
        # Générer les suites du niveau suivant par comparaison
        for k in range(i+1, k_max + 1):
            suite_comparee = ['-'] * n
            suite_base = suites_1k[k-1] if i == 1 else toutes_suites[f"{i};{k}"]
            suite_a = toutes_suites[f"A;{i};{k}"]
            
            for j in range(n):
                if suite_base[j] != suite_a[j] and suite_base[j] != '-':
                    suite_comparee[j] = suite_base[j]
            
            toutes_suites[f"{i+1};{k}"] = suite_comparee
            print(f"Suite {i+1};{k} : {', '.join(suite_comparee)}")
            
            # Stocker les suites i;i pour le résumé
            if k == i+1:
                suites_resume[f"{i+1};{i+1}"] = suite_comparee
    
    # Afficher le résumé des suites i;i limité au nombre de termes demandé
    print(f"\nRésumé des suites i;i (limité à {nb_termes} termes) :")
    for i in range(1, k_max + 1):
        cle = f"{i};{i}"
        if cle in suites_resume:
            nombres = [x for x in suites_resume[cle] if x != '-'][:nb_termes]
            print(f"Suite {cle} : {', '.join(nombres)}")

def main():
    while True:
        try:
            n = int(input("Entrez la valeur de n (entier positif) : "))
            if n <= 0:
                print("Veuillez entrer un nombre entier positif.")
                continue
            break
        except ValueError:
            print("Veuillez entrer un nombre entier valide.")
    
    while True:
        try:
            nb_termes = int(input("Combien de termes voulez-vous afficher dans le résumé ? "))
            if nb_termes <= 0:
                print("Veuillez entrer un nombre positif.")
                continue
            break
        except ValueError:
            print("Veuillez entrer un nombre valide.")
    
    generer_suites_completes(n, nb_termes)

if __name__ == "__main__":
    main()

Résumé des suites i;i :
Suite 1;1 : 2, 3, 2, 5, 2, 7, 2, 3, 2, 11, 2, 13, 2, 3, 2, 17, 2, 19, 2, 3, 2, 23, 2, 5, 2, 3, 2, 29, 2, 31, 2, 3, 2, 5, 2, 37, 2, 3
Suite 2;2 : 3, 5, 7, 5, 3, 11, 7, 13, 3, 7, 17, 11, 19, 3, 13, 23, 5, 11, 3, 17, 29, 13, 31, 19, 3, 5, 37, 23, 3, 17, 11, 41, 5, 43, 19, 3, 47, 13
Suite 3;3 : 3, 5, 7, 5, 3, 11, 7, 13, 5, 3, 7, 17, 11, 19, 7, 3, 13, 23, 5, 11, 3, 7, 17, 29, 13, 11, 31, 19, 3, 5, 13, 37, 7, 23, 3, 17, 11, 41
Suite 4;4 : 3, 5, 7, 5, 3, 11, 7, 13, 5, 3, 7, 17, 11, 19, 7, 3, 13, 23, 5, 5, 11, 3, 7, 17, 29, 13, 11, 31, 19, 7, 3, 5, 13, 37, 7, 23, 3, 17
Suite 5;5 : 3, 5, 7, 5, 3, 11, 7, 13, 5, 3, 7, 17, 11, 19, 7, 3, 13, 23, 5, 5, 11, 3, 7, 17, 29, 13, 11, 31, 19, 7, 3, 5, 13, 37, 7, 23, 5, 3
Suite 6;6 : 3, 5, 7, 5, 3, 11, 7, 13, 5, 3, 7, 17, 11, 19, 7, 3, 13, 23, 5, 5, 11, 3, 7, 17, 29, 13, 11, 31, 19, 7, 3, 5, 13, 37, 7, 23, 5, 3
Suite 7;7 : 3, 5, 7, 5, 3, 11, 7, 13, 5, 3, 7, 17, 11, 19, 7, 3, 13
Suite 8;8 : 3, 5, 7

lourrran · 27 Oct

elles ne sont jamais identiques, mais plus on avance dans les calculs, plus elles se ressemblent, comme si elles tendaient vers une forme de convergence.

Non.
Plus on regarde les lignes 'vers le bas', plus c'est difficile d'avoir beaucoup de données, et donc, plus c'est difficile de voir des différences.
Quand on regarde les nombres premiers, c'est intéressant quand on commence à aborder des nombres premiers plus grands que 1 Milliard, pas les nombres premiers jusqu'à 50. Et pour voir apparaître des nombres plus grands que 1 Milliard sur la 5ème ou 10ème ligne de ton tableau, je te laisse imaginer la quantité de calculs. ... Tout ça pour tenter de voir des phénomènes qui n'existent pas.

ça me donne la mixomatose, et j’ai l’impression d’être un autiste à passer des heures à vérifier tous ces nombres.

Je t'avais prévenu... tu perds ton temps.
Oui, il y a beaucoup de ressemblances entre les lignes. Non, elles ne seront jamais identiques.

Fly7 · 27 Oct

J'ai modifié le programme pour trouver les suites qui ont le plus de termes identiques. Mon record n=2^20=1 048 576 en quelques minutes, je suis encore bien loin du milliard, mais avec un programme optimisé, un gros calculateur et moins d'un jour de calcul, cela doit être réalisable. Après, oui effectivement, quel intérêt a cette suite à part être remarquable ?

Entrez la valeur de k (n sera égal à 2^k) : 20
==================================================
PLUS LONGUE SÉQUENCE IDENTIQUE TROUVÉE :
Entre Suite 7;7 et Suite 8;8
Longueur : 279 termes
Séquence : 3, 5, 7, 5, 3, 11, 7, 13, 5, 3, 7, 17, 11, 19, 7, 3, 13, 23, 5, 5, 11, 3, 7, 17, 29, 13, 11, 31, 19, 7, 3, 5, 13, 37, 7, 23, 5, 3, 17, 11, 41, 5, 11, 43, 19, 3, 7, 47, 17, 13, 29, 7, 13, 11, 3, 31, 19, 53, 23, 7, 5, 13, 3, 5, 59, 11, 13, 61, 37, 17, 3, 7, 23, 5, 5, 17, 67, 11, 29, 41, 3, 5, 19, 13, 71, 11, 43, 31, 73, 17, 19, 3, 7, 7, 47, 17, 79, 13, 29, 3, 7, 19, 83, 13, 23, 11, 5, 31, 37, 3, 19, 53, 7, 89, 23, 7, 7, 5, 17, 3, 13, 11, 5, 41, 17, 97, 5, 59, 3, 23, 11, 13, 43, 101, 61, 37, 103, 19, 17, 3, 7, 29, 23, 107, 5, 19, 5, 109, 47, 17, 3, 13, 67, 11, 29, 113, 31, 41, 7, 5, 5, 19, 3, 13, 71, 11, 7, 43, 19, 31, 11, 73, 17, 3, 19, 53, 5, 23, 29, 7, 127, 7, 3, 23, 47, 131, 17, 13, 79, 13, 7, 29, 31, 3, 37, 7, 137, 19, 59, 83, 139, 11, 13, 23, 3, 11, 5, 61, 11, 31, 37, 5, 17, 23, 19, 3, 53, 11, 7, 89, 149, 23, 7, 41, 151, 7, 5, 3, 17, 5, 67, 13, 11, 157, 43, 29, 5, 3, 41, 37, 17, 7, 97, 5, 19, 163, 59, 29, 3, 13, 71, 23, 11, 167, 13, 43, 101, 31, 13, 61, 73, 3, 37, 103, 17, 47, 19, 173, 17, 13, 5, 31, 23, 7, 3, 29, 23, 41, 107
Première différence : 179 ≠ 5
==================================================

def factorisation_premiers(n):
    if n == 1:
        return []
    facteurs = []
    diviseur = 2
    while n > 1:
        while n % diviseur == 0:
            facteurs.append(diviseur)
            n //= diviseur
        diviseur += 1 if diviseur == 2 else 2
        if diviseur * diviseur > n:
            if n > 1:
                facteurs.append(n)
            break
    return facteurs

def trouver_sequence_identique(suite1, suite2):
    nombres1 = [x for x in suite1 if x != '-']
    nombres2 = [x for x in suite2 if x != '-']
    sequence = []
    for n1, n2 in zip(nombres1, nombres2):
        if n1 == n2:
            sequence.append(n1)
        else:
            return len(sequence), sequence, n1, n2
    return len(sequence), sequence, None, None

def generer_suites_completes(k):
    n = 2 ** k
    suites_resume = {}
    toutes_suites = {}
    
    # Générer les suites 1;k
    for position in range(k):
        suite_courante = []
        for num in range(1, n + 1):
            facteurs = factorisation_premiers(num)
            suite_courante.append(str(facteurs[position]) if position < len(facteurs) else '-')
        toutes_suites[f"1;{position+1}"] = suite_courante
        if position == 0:
            suites_resume["1;1"] = suite_courante
    
    # Générer les autres suites
    for i in range(1, k):
        # Générer d'abord toutes les suites A;i;k pour le niveau i
        for j in range(i+1, k + 1):
            suite_decalee = ['-'] * n
            suite_source = suites_resume[f"{i};{i}"] if i > 1 else toutes_suites["1;1"]
            for pos in range(n):
                if suite_source[pos] != '-':
                    nouvelle_pos = (pos + 1) * (2 ** (j-i))
                    if nouvelle_pos <= n:
                        suite_decalee[nouvelle_pos - 1] = suite_source[pos]
            toutes_suites[f"A;{i};{j}"] = suite_decalee
        
        # Puis générer les suites i+1;k par comparaison
        for j in range(i+1, k + 1):
            suite_comparee = ['-'] * n
            suite_base = toutes_suites[f"1;{j}"] if i == 1 else toutes_suites[f"{i};{j}"]
            suite_a = toutes_suites[f"A;{i};{j}"]
            for m in range(n):
                if suite_base[m] != suite_a[m] and suite_base[m] != '-':
                    suite_comparee[m] = suite_base[m]
            toutes_suites[f"{i+1};{j}"] = suite_comparee
            if j == i+1:
                suites_resume[f"{i+1};{i+1}"] = suite_comparee
    
    print(f"\nRésumé des suites i;i pour k = {k} (n = 2^{k} = {n}) :")
    for i in range(1, k + 1):
        cle = f"{i};{i}"
        if cle in suites_resume:
            nombres = [x for x in suites_resume[cle] if x != '-']
            print(f"Suite {cle} : {', '.join(nombres)}")
    
    # Analyser les similitudes
    plus_longue_sequence = 0
    suites_plus_longue = None
    sequence_plus_longue = None
    difference_plus_longue = None
    
    cles = sorted([k for k in suites_resume.keys() if k.split(';')[0] not in ('A')])
    for i in range(len(cles)-1):
        cle1 = cles[i]
        cle2 = cles[i+1]
        longueur, sequence, val1, val2 = trouver_sequence_identique(
            suites_resume[cle1],
            suites_resume[cle2]
        )
        if longueur > plus_longue_sequence:
            plus_longue_sequence = longueur
            suites_plus_longue = (cle1, cle2)
            sequence_plus_longue = sequence
            difference_plus_longue = (val1, val2)
    
    if suites_plus_longue:
        print("\n" + "="*50)
        print("PLUS LONGUE SÉQUENCE IDENTIQUE TROUVÉE :")
        print(f"Entre Suite {suites_plus_longue[0]} et Suite {suites_plus_longue[1]}")
        print(f"Longueur : {plus_longue_sequence} termes")
        print(f"Séquence : {', '.join(sequence_plus_longue)}")
        if difference_plus_longue[0] and difference_plus_longue[1]:
            print(f"Première différence : {difference_plus_longue[0]} ≠ {difference_plus_longue[1]}")
        print("="*50)

def main():
    while True:
        try:
            k = int(input("Entrez la valeur de k (n sera égal à 2^k) : "))
            if k <= 0:
                print("Veuillez entrer un nombre positif.")
                continue
            break
        except ValueError:
            print("Veuillez entrer un nombre valide.")
    
    generer_suites_completes(k)

if __name__ == "__main__":
    main()

gerard0 · 27 Oct

"Après, oui effectivement, quel intérêt a cette suite à part être remarquable ?" ???

Tout objet est remarquable à partir du moment où on s'y intéresse.

Suite de nombres premiers

Réponses

Bonjour!

Catégories

In this Discussion