Nombres premiers en open source

Version imprimable

Bonjour à tous
Je ne comprends pas encore le tout python, et çà s'en ressent lors de l'exécution de la programmation.

Un peu d'aide m'aiderait à comprendre mes erreurs

Voici la copie du programme source : Confiez vos commentaires de nph1.py

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# Ce programme calcule les Nombres Premiers #
# Révolution : Vicenté Llavata au 25 avril 2014 #
 
# Initialisation de listeNPH.txt #
fo = open("C:\python\pynph\listeNPH.txt","r")
ft = fo.readline()
fo.close()
if (ft == ""):
    fo = open("C:\python\pynph\listeNPH.txt","a")
    fo.write("1\n","1\n")
    fo.close()
 
# Fonction de recherche #
def calnph(a):
    if (a > 1):
        lfor = open("C:\python\pynph\listeNPH.txt","r")
        lb = a          #
        lbb = (lb + 1)       # Initie segment for(lbb)
        lc = lb * 2     #
        nreelexist = 0
        #
        for lbb in lc :             # Segment for(lbb)
            lba = lbb / lb           # Réel lb
            lbb = lbb + 1
            while l :
                nentier = float(lfor.readline())
                nreel = float(lfor.readline())
                if (lba == nreel) :
                    nreelexist = 1
                    break
            if (nreelexist == 1) :
                lbb == (lc + 1)     # Terme for (lbb)
        #
        lfor.close()
        if (nreelexist == 0) :
            nentier1 = lb
            nreel2 = lba
            e = str(nentier1)
            f = str(nreel2)
            prenph(e,f)
 
# Fonction du premier réel #
def prenph(e,f):
    lfoa = open("C:\python\pynph\listeNPH.txt","a")
    lfoa.write(e,"\n")
    lfoa.write(f,"\n")
    lfoa.close()
 
# Introduction nombre utilisateur #
nombre = input("Entrez un nombre entier : ")
ne = int(nombre)
a = 0
 
# Début de la boucle globale (a) #
while (a <= ne) :
    a = a + 1
    nem = a%6
    if (nem == (1 or 5)):
        calnph(a)

Merci d'avance pour vos commentaires...

Salut,

Pourquoi ne pas prendre le temps de parcourir un tuto. pour apprendre les constructions de base?
Dans le Python tutorial, vous avez déjà:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 >>> for n in range(2, 10): ... for x in range(2, n): ... if n % x == 0: ... print n, 'equals', x, '*', n/x ... break ... else: ... # loop fell through without finding a factor ... print n, 'is a prime number' ... 2 is a prime number 3 is a prime number 4 equals 2 * 2 5 is a prime number 6 equals 2 * 3 7 is a prime number 8 equals 2 * 4 9 equals 3 * 3
Ca génère les nombres premiers et çà vous montre aussi l'intérêt de for a in range(1, n) plutôt que while a < n: a += 1 et la construction "for...else..."

La plus grosse partie de votre code consiste a gérer des fichiers.
On peut imaginer que çà stocke les N nombres premiers calculés lors des run précédents.
Mais c'est pas très clair (et c'est plein de bugs).

Plutôt que de vous embêter avec des fichiers, des conversions de str en float et de int en str, pourquoi ne pas commencer par tout stocker dans une liste en mémoire? C'est un type de base Python fort utile.
Lorsque çà fonctionnera, vous pourrez optimiser en chargeant/sauvegardant cette liste dans un fichier.

- W

28/04/2014, 19h26
Invité

Excellent exercice de code

Vous m'avez rassuré avec cet exemple ciblé tutoriel, qui va peut être faire avancer mes boucles "for".
Puis, je vais me pencher sur cette nouvelle opportunité de calcul des nombres premiers...
D'ailleurs, je suis contant d'utiliser ce langage de programmation, car il laisse des idées claires codées.
à bientôt, après analyse du code tutoriel

Un avis en plus

Je suis encore dessus, et j'avance doucement...

Et, autrement pour aider le suivi du programme.
J'ai ajouté des mots "print", afin d'y lire des valeurs.
Les "print" sont situés en fin de bloc de traitement.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
# Ce programme calcule les Nombres Premiers #
# Révolution : Vicenté Llavata au 1 mai 2014 #
 
#4 Initialisation de listeNPH.txt #
#5 ListeNPH.txt enregistre les nombres premiers entiers
#6 Le fichier "listeNPH" des nombres entiers diviseurs
fo = open("C:\python\pynph\listeNPH.txt","r")
ft = fo.readline()
fo.close()
if (ft == ""):
    fo = open("C:\python\pynph\listeNPH.txt","a")
    fo.write("1\n")
    fo.close()
 
#15 Fonction de recherche #
def calnph(a):
    if (a > 1):
        lb = a              #19 a = Cumul des tours !
        lbb = lb            #20 Initie segment for(lbb) (=(a+1))
        lc = lb * 2         #21 Le double de "a"
        nreelexist = 0      #22 Réinitialisation de nreelexist
        print("if (a > 1):) ",a," ",lbb," ",lc,)
        #23
        # "while (a <= ne)" ionique Utile
        # "def calnph(a)" tonique Globale
        # "for lbb in range(lb,lc)" diatonique Locale
        #27
        for lbb in range(lb,lc) :   # Segmentation diatonique
            lfor = open("C:\python\pynph\listeNPH.txt","r")
            lbb1 = lbb
            lbb2 = lbb1 + 1
            lba = lbb2 / lb          # Réel lba de la division
            print("for lbb in range(lb,lc) ",lba," ",lbb2," ",lb)
 
            while (nreelexist != 1) :   # Lecture listeNPH.txt par tour
                nen = lfor.readline()   # Lecture ligne
                if (nen == "1") :
                    nen1 = 1
                elif (nen == "") :
                    nen1 = 2
                    nreelexist = 0
                else :
                    nen4 = int(nen)
                    nentier = nen4           # nentier, c'est la donnée lue
                    nen2 = nentier
                    nen3 = nen2 + 1
                    nenreel = nen3 / nentier  # Réel listeNPH.txt
                    print("while (nreelexist != 1) ",nenreel," ",nen3," ",nentier)
                    print("while (nreelexist != 1) ",lba," "," ")
                    if (lba == nenreel) :   # Les deux réels sont identiques
                        nreelexist = 1      # nreelexist vaut 1
                        print("if (lba == nenreel) ",lba," ",nreel," ",nreelexist)
            #40
            if (nreelexist == 0) :
                nentier1 = lb
                e = str(nentier1)
                print("if (nreelexist == 0)",nentier1)
                prenph(e)
 
#49 Fonction du premier réel #
def prenph(e):
    lfoa = open("C:\python\pynph\listeNPH.txt","a")
    lfoa.write(nentier,"\n")
    lfoa.close()
 
#55 Introduction nombre utilisateur #
nombre = input("Entrez un nombre entier : ")
if (nombre == "") :
    ne = 1
else :
    ne = int(nombre)
a = 0
 
#60 Début de la boucle globale (a) #
while (a <= ne) :               # Segmentation ionique
    a = a + 1
    nem = a%6
    if ((nem == 1) or (nem == 5)):
        calnph(a)

Pour le moment, j'essaie de savoir là où çà casse :^)

Salut,

Côté code, je ne peux pas faire grand chose pour vous.
Par contre, vous semblez avoir la même maladie qu'un de vos copains du forum.
Rassurez vous, ce n'est pas contagieux. Votre vie n'est pas en danger. Juste qu'écrit comme çà, un code est épuisant. Il devient indomptable.

79 lignes de code. La structure se résume a deux fonctions.
Pas facile de s'y retrouver.
Imaginez que vos lignes soient autant de vaches. Manque de bol, pas de chien de troupeau pour les rabattre. En Australie, ils rabattent les troupeaux avec des avions ou des hélicos.
Heu... snif avec du code on ne peut même pas espérer l'aide d'un toutou ;-(
Damned!

Pourquoi s'embêter a ouvrir et lire dans le fichier lors de la génération des nombres premiers?
Qu'est devenu l'exemple de la doc. Python?
Code:

1 2 3 4 5 6 7 8 >>> for n in range(2, 10): ... for x in range(2, n): ... if n % x == 0: ... print n, 'equals', x, '*', n/x ... break ... else: ... # loop fell through without finding a factor ... print n, 'is a prime number'
Pas facile de le retrouver dans cette forêt vierge!

Cette chose là forge le squelette de votre programme.
Une fois que cela marche, le jeu sera d'ajouter les histoires de fichiers sans rien casser.
Le plus simple sera de décorer ce squelette.
Cette jonglerie avec le fichier permet de ne pas calculer les N premiers nombres que l'on a déjà calculé.
C'est une liste d'entiers. Elle est rangée en ordre croissant. Et le prochain nombre premier ira s'ajouter à la fin.

Pourquoi ne pas lire le fichier au début et transformer son contenu en liste d'entiers?
Puis vous appelez calnpth avec un paramètre supplémentaire "known_primes".
Plus besoin de se trimbaler la gestion du fichier dans la fonction.

"known_primes" est une liste d'entiers.
vide ou pleine, calnpth devra récupérer ou accumuler des nombres premiers en fonction de "n".
Pour mettre au point ce truc là, pas besoin du fichier.
Vous pouvez tester avec la liste que vous voulez, vous assurer qu'elle est bien utilisée, mise à jour.

Cela fait, comment sauvegarder et relire une liste d'entier est quelque chose d'assez générique, çà se fout pas mal de ce qu'on pourra bien faire de la liste après.

Ah c'est pour monsieur nombre premier?
C'est comme dans la vraie vie. Maintenant que sont séparés génération des nombre premier et gestion du fichier, il va falloir "orchestrer" ces bouts pour que ce qui sort de l'un entre dans ce qu'attend l'autre.

Mais c'est le plus fastoche:
Code:

1 2 3 4 1 - lire "known_primes" 2 - entrée de "nombre" 3 - calcul "nombre", "known_primes" 4 - écrire "known_primes"
Ouais... c'est pas du Python. Mais c'est facile à traduire en Python.
En plus ce sont des fonctions. Une première mouture de lire "known_primes" pourrait se réduire à:
Code:

1 2 def read_known_primes(): return [ 1 ]
Ca retourne ce que devrait être un nouveau fichier....

L'idée est que si vous partez faire de l'escalade, il faut anticiper le chemin par lequel vous allez passer pour y arriver.
Bon courage.

- W

PS: il faudra que je revoie la metaphore du squelette. Mais je n'ai pas réussi à traduire "it is the business of the program".

Je vous ai compris !

Il est vrai que mon voyage parmi les nombres entiers m'a fait voir plein de choses... .
Citation:
Salut,

Pourquoi ne pas prendre le temps de parcourir un tuto. pour apprendre les constructions de base?
Dans le Python tutorial, vous avez déjà:
Code:

1 2 3 4 5 6 7 8 >>> for n in range(2, 10): ... for x in range(2, n): ... if n % x == 0: ... print n, 'equals', x, '*', n/x ... break ... else: ... # loop fell through without finding a factor ... print n, 'is a prime number'
Il me semble qu'à première vue, le tuto ne démontre pas la capacité hexa des entiers.
Le tuto répète les nombres, ce qui n'est pas utile. Puis, 9 n'est pas un nombre premier.
C'est à cause de çà, que je prend tout mon temps, et qu'autrement je peaufine mon code perso)

Citation:

Salut,

Côté code, je ne peux pas faire grand chose pour vous.
Par contre, vous semblez avoir la même maladie qu'un de vos copains du forum.
Rassurez vous, ce n'est pas contagieux. Votre vie n'est pas en danger. Juste qu'écrit comme çà, un code est épuisant. Il devient indomptable.

Pour ne venir au squelette, qu'est-il sans l'imagerie, sans la médecine. Pour dompter, il faut comprendre !
Car, le programme calcule les nombres avec une logique du nombre premier multiple. Pour comprendre, il faut dompter !

Citation:

Pourquoi s'embêter a ouvrir et lire dans le fichier lors de la génération des nombres premiers?
Qu'est devenu l'exemple de la doc. Python?

Il est, que si le mot réservé "python" est réduit à un unique mot.
Il est alors, plus que difficile de lire en ce mot codé le traitement qu'il effectue.
C'est pour une raison de transparence, que je préfère écrire mon programme en version alpha.

Citation:

Pourquoi ne pas lire le fichier au début et transformer son contenu en liste d'entiers?
Puis vous appelez calnpth avec un paramètre supplémentaire "known_primes".

Aussi, les nombres entiers premiers multiples aucun humain n'en connait la limite.
Et, mon petit ordinateur non plus, alors je laisse une plage dans un fichier.
Qui en un premier temps est sur mon ordi, et sûrement plus tard en mémoire externe.

Merci pour votre message, qui ne manque pas de piquant.

Un avis en plus

Au sujet du tutoriel :

Citation:

Code:

1
2
3
4
5
6
7
8
>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print n, 'equals', x, '*', n/x
...             break
...     else:
...         # loop fell through without finding a factor
...         print n, 'is a prime number'

Et maintenant, sa révolution :

Code:

1
2
3
4
5
6
7
8
9
10
11
# Définition exacte des nombres entiers
# Dans le système hexanumérique
 
for n in range(1, 10):
    x = n%6     # Module d'analyse
    if (x == 1) or (x == 5) :
        print (n, 'possible premier')
    if (x == 2)or (x == 4) :
        print (n, 'multiple de 2')
    if (x == 3)or(x == 0) :
        print (n, 'multiple de 3')

Et voilà

Je n'ai pas lu les autres posts mais voilà un petit programme que j'avais écris pour m'entraîner quand j'apprenais encore le langage (je me rends compte en le relisant qu'il y a plein de trucs qui pourraient être améliorés), ce n'est pas forcément très optimisé mais ça marche (à noter que pour écrire un programme qui a besoin de rapidité pour calculer beaucoup de nombres premiers, un langage comme le C++ sera plus adaptée) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 liste=[] nb=input('entrez un nombre : ') nb=int(nb) i=0 while i<nb: i+=1 liste.append(i)#liste=nombres de 0 à nb suite=[] for a in liste :#nombre à tester casser=False for avant in liste[0:a-1]: if avant>a/2+a/4: break elif a%avant==0 and avant!=1: casser=True break if casser==False: suite.append(a) print("Voici la suite des nombres premiers jusqu'à",nb,":") présentation="" for convert in suite: if convert!=1: présentation+=" - " présentation+=str(convert) print(présentation) qutter=input()

08/05/2014, 14h55
Sve@r
Citation:
Envoyé par toumus

Code:

1 2 3 4 5 # Ce programme calcule les Nombres Premiers # if (ft == ""): fo = open("C:\python\pynph\listeNPH.txt","a") fo.write("1\n","1\n") fo.close()
Bonjour
Sans vouloir casser l'ambiance, 1 n'est pas un nombre premier.
Ce n'est pas à cause d'une histoire de sémantique (est-ce que le "et" dans "nombre divisible par un et par lui-même" doit signifier que le nombre doit absolument être différent de un) mais simplement parce que certaines propriétés mathématiques qui fonctionnent avec les nombres premiers ne fonctionnent pas avec 1.
Par exemple une propriété qui dit qu'un nombre non premier est toujours le produit d'un nombre fini de nombres premiers (12=2*2*3) ne fonctionne plus si on y inclus 1 => 12=1*1*1*1*......... (à l'infini)*2*2*3.

Et donc, pour éviter de devoir rajouter à chaque fois "sauf 1", la communauté mathématique a décidé que 1 serait exclu de la liste des premiers. Ainsi, le tout premier nombre premier sera le seul et unique nombre premier pair ce qui correspond en plus à une certaine élégance mystique (le premier nombre premier ayant alors une particularité qu'on ne retrouve dans aucun autre).

Accessoirement, si ton fichier est vide, alors autant l'ouvrir en mode "w" ;)

3 pièce(s) jointe(s)

Point de vue artistique

Pièce jointe 145340

La plénitude de la décomposition moléculaire du code, et la séparation des complexes organisés en vue de dénouer un enchevêtrement déjà bien fait. Je pense à çà.
Citation:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 liste=[] nb=input('entrez un nombre : ') nb=int(nb) i=0 while i<nb: i+=1 liste.append(i)#liste=nombres de 0 à nb suite=[] for a in liste :#nombre à tester casser=False for avant in liste[0:a-1]: if avant>a/2+a/4: break elif a%avant==0 and avant!=1: casser=True break if casser==False: suite.append(a) print("Voici la suite des nombres premiers jusqu'à",nb,":") présentation="" for convert in suite: if convert!=1: présentation+=" - " présentation+=str(convert) print(présentation) qutter=input()
Juste encore un pasPièce jointe 145344

J'apprécie

Citation:
Envoyé par stalacta
Je n'ai pas lu les autres posts mais voilà un petit programme que j'avais écris pour m'entraîner quand j'apprenais encore le langage (je me rends compte en le relisant qu'il y a plein de trucs qui pourraient être améliorés), ce n'est pas forcément très optimisé mais ça marche (à noter que pour écrire un programme qui a besoin de rapidité pour calculer beaucoup de nombres premiers, un langage comme le C++ sera plus adaptée) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 liste=[] nb=input('entrez un nombre : ') nb=int(nb) i=0 while i<nb: i+=1 liste.append(i)#liste=nombres de 0 à nb suite=[] for a in liste :#nombre à tester casser=False for avant in liste[0:a-1]: if avant>a/2+a/4: break elif a%avant==0 and avant!=1: casser=True break if casser==False: suite.append(a) print("Voici la suite des nombres premiers jusqu'à",nb,":") présentation="" for convert in suite: if convert!=1: présentation+=" - " présentation+=str(convert) print(présentation) qutter=input()
Citation:

J'apprécie ce petit programme, car il est simple. Il va sûrement m'aider à simplifier le mien...

10/05/2014, 11h18
Invité

1 pièce(s) jointe(s)

bonjour ovale

Citation:

Sve@r a dit : Bonjour
Sans vouloir casser l'ambiance, 1 n'est pas un nombre premier.

Belle répercussion et quel point d'orgue mathématique majeur.
Sauf, que je ne suis pas si discipliné que çà, voire même pas diplômé. Mais je ne suis pas là pour décrire ma vie, mais mon expérience en cette matière.
Les nombres entiers forment une suite de chiffres, allant d'une première unité jusqu'à l'infini. Les nombres et leur chronologie fondamentale.
Il faut comprendre que les chiffres font partie d'une même famille, qu'ils ont chacun leur propre comportement. Aussi, lorsqu'un chiffre est le multiple d'un autre. Il agit en se comportant comme un multiple, ce dernier comportement du nombre peut également être rapporté à d'autres nombres multiples. Il est normal alors, de croire que certains chiffres aient un même comportement. Dan tous ces aléas des nombres entiers, il y a la connaissance généralement fondamentale de l'histoire des nombres entiers "occurrence". Lorsqu'ils ont étés créés, les chiffres n'avaient pas à l'origine découverts toutes les nuances de leurs comportements. Et avec ma mentalité "de l'âge de la pierre et du galet", je m'oblige un rapport fondamental. En me conditionnant à un unique savoir numérique, celui des premiers cours de mathématiques :

Les chiffres commencent à 0, cet élément vide ne se comporte pas comme tous les autres chiffres élémentaires. La séquence numérique suit la chronologie naturelle des nombres entiers, elle réunit ainsi différents comportement des numéros. Il est utile de croire en ces termes qui vont suivre. En l'effet de se souvenir des ces quelques mots simples et constants parmi la totalité des chiffres : PAIR - IMPAIR - PREMIER...

La fonction du chiffre 1. Cette unité est le premier multiple PAIR - IMPAIR - PREMIER
La fonction du chiffre 2. Cette unité est le premier multiple PAIR
La fonction du chiffre 3. Cette unité est le premier multiple PAIR - IMPAIR
La fonction du chiffre 5. Cette unité est le premier IMPAIR - PREMIER

@suivre

Citation:
Envoyé par stalacta
je me rends compte en le relisant qu'il y a plein de trucs qui pourraient être améliorés, ce n'est pas forcément très optimisé mais ça marche (à noter que pour écrire un programme qui a besoin de rapidité pour calculer beaucoup de nombres premiers, un langage comme le C++ sera plus adaptée) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 liste=[] nb=input('entrez un nombre : ') nb=int(nb) i=0 while i<nb: i+=1 liste.append(i)#liste=nombres de 0 à nb suite=[] for a in liste :#nombre à tester casser=False for avant in liste[0:a-1]: if avant>a/2+a/4: break elif a%avant==0 and avant!=1: casser=True break if casser==False: suite.append(a) print("Voici la suite des nombres premiers jusqu'à",nb,":") présentation="" for convert in suite: if convert!=1: présentation+=" - " présentation+=str(convert) print(présentation) qutter=input()
Déjà, une amélioration immédiate serait, dans la boucle inférieure, de ne pas traiter liste[0:a-1] mais suite[1:]
En effet, le tableau "liste" contient tous les entiers naturels de 1 à nb alors que "suite" ne contient que les nombres premiers de 1 (en faisant abstraction de ma remarque précédente) à nb
Or, si un nombre n est divisible par un entier x non premier, il est forcément divisible par un des premiers qui factorisent ce x !!!
Ca accèlèrera grandement le traitement quoi...

Et pourquoi commencer à [1] ? Simplement pour ne pas tester liste[0] qui vaut 1 ce qui évite en plus ce "and avant != 1".

De plus, quitter quand "avant" a dépassé 3/4 de a est bien trop tard. C'est quand avant dépasse racine2(a) qu'il faut quitter (ou plus simplement quand "a/avant < avant") !!!

Citation:

Envoyé par toumus

Mais je ne suis pas là pour décrire ma vie, mais mon expérience en cette matière...En me conditionnant à un unique savoir numérique, celui des premiers cours de mathématiques

Sauf que tu as oublié une chose fondamentale dans tout apprentissage: c'est que l'apprentissage de l'esprit humain se fait par couches successives, chaque couche détruisant les fondamentaux de la couche précédente.

Prend le petit enfant qui regarde le soleil. On lui apprendra alors que le soleil tourne autour de la Terre.
Plus tard, quand il aura un esprit plus formé, on lui dira que cette "vérité" est fausse mais que c'est en fait la Terre qui tourne sur elle-même. Il aura alors la maturité suffisante pour se "représenter" cette réalité et comprendre que visuellement cela a le même effet.
Dans le même temps, on lui enseigne que la Terre est ronde. Plus tard, s'il devient géographe ou cartographe, on lui enseignera que cette "vérité" est fausse car la Terre à la forme d'une "patate" (hyper important dans le calcul des latitudes et des longitudes).

Et c'est pareil en mathématiques. On apprend d'abord les "entiers naturels" qui (comme tu le dis) commencent à 0. Puis on apprend plus tard les "entiers relatifs" pour qui 0 n'est plus un début mais simplement une "limite" séparant ceux qui sont "avant" de ceux qui sont "après". Et dans cet ensemble, les nombres n'ont pas de commencement. Puis on apprend les décimaux, puis les rationnels, puis les irrationnels avec leurs racines carrées qui ne s'appliquent qu'aux positifs. Puis, plus tard, on apprend les nombre complexes qui peuvent exprimer (entre autre) la racine carrée d'un nombre négatif. Tous ces ensembles n'ont plus aucun rapport avec la "réalité naturelle" (qui s'amuse à acheter 2+3i pommes pour la somme de 7-5i € ???) ; réalité naturelle qui n'est concernée que par les "entiers naturels" (d'où son nom) mais ils n'en existent pas moins et ont leur utilité (les nombres complexes sont utilisés dans les équations d'Einstein concernant le temps et donnent des résultats concrets et vérifiables).

T'es-tu demandé une seule fois pourquoi (-200) * (-3) donne +600 ? Comment, avec la multiplication qui n'est qu'une suite d'addition, pouvait-on "additionner" un nombre négatif "moins trois fois" et avoir au final un résultat positif donc faisant partie des entiers naturels (qu'on peut toucher du doigt) ??? Pourtant un gain (+200€) gagné trois fois de suite donnera un gain de +600€. De même qu'une dette (-200€) due à trois personne différente donnera une dette de -600€. Mais peut-on concevoir une dette (-200€) due à "moins trois" personnes différentes et donner au final un gain de +600€ ??? ;)

"Les chiffres commencent à 0" as-tu dis. Mais te représentes-tu le temps qu'il a fallu pour arriver à concevoir un chiffre exprimant non pas ce qu'on "pouvait compter" mais "ce qui est absent" ??? Combien de milliers de personnes se sont senties dépassées par cette idée ??? Et Pythagore, ayant trouvé que la diagonale d'un carré de coté "1" donnait racine(2) mais ne pouvant pas calculer cette valeur par division de nombre entiers avait déclaré ce nombre "interdit"...

Ainsi, si on t'a un jour appris que 1 était le premier des "premiers", j'espère qu'aujourd'hui tu pourras concevoir que ce n'est pas tout à fait exact. 1 n'est pas premier. Mais comme je l'ai dit, non pas pour faire chier tous ceux qui aimaient cette idée mais simplement parce que les nombres premiers sont un outil et que, dans l'utilisation de cet outil, 1 est plus une gêne qu'autre chose (regarde d'ailleurs l'algo se stalacta => ce 1 l'a gêné au point qu'il a dû rajouter un test spécial pour lui et moi je suis obligé de faire commencer ma boucle au second élément pour ne pas avoir à le traiter)...

Citation:

Envoyé par toumus

Sauf, que je ne suis pas si discipliné que çà

C'est ton droit. Tu as en effet le droit de considérer les nombres (qui ne sont qu'une vue de l'esprit) de la façon qui te plait le mieux. Tu peux même vivre toute ta vie avec cette conception sans problème. Mais il se peut aussi qu'un jour ta conception (qui n'est pas celle adoptée par la communauté) se heurte justement à celle de la communauté ou que ton travail ou tes résultats soient en désaccord avec les résultats demandés/attendus...

10/05/2014, 19h01
stalacta

Oui, je sais que mon code est loin d'être optimisé, j'étais au début de mon apprentissage (je suis encore loin d'avoir tout appris) et déjà la première chose à modifier serait d'utiliser la fonction magique range que je ne connaissais pas à l'époque. Après, peut-être existe-t-il des algorithmes plus élaborés que de tester une division par tous les nombres précédents (quoique j'ai fait légèrement mieux).
11/05/2014, 08h23
tyrtamos

Bonjour,

Citation:

Envoyé par stalacta

Après, peut-être existe-t-il des algorithmes plus élaborés que de tester une division par tous les nombres précédents (quoique j'ai fait légèrement mieux).

Une des méthodes plus rapides que j'ai essayée est le crible d'Eratosthène (http://fr.wikipedia.org/wiki/Crible_...atosth%C3%A8ne). Il existe des implémentations de ce crible qui donnent des résultats impressionnants. Je me suis un peu amusé à ça (http://python.jpvweb.com/mesrecettes...mbres_premiers). Avec un PC récent, j'ai obtenu les 455052511 nombres premiers inférieurs à 10 milliard en une heure environ. Pour lutter contre les limites de la mémoire disponible, il faut enregistrer les nombres premiers trouvés sur disque au fur et à mesure, et cela représente tout de même un fichier de 5,03 Go! Il existe encore des marges d'amélioration et on doit pouvoir faire mieux.

Sinon, je suis d'accord avec Sve@r: tu peux toujours adopter tes propres définitions (ex: 1 est un nb premier), mais tu te prépares un futur difficile:
- soit tu es un mathématicien génial et la communauté finira par adopter tes vues (c'est toujours possible, mais il te faudra méchamment batailler pour y arriver...)
- soit ce n'est pas le cas et tout ce que tu feras sera considéré comme faux par la communauté.

A noter qu'il a fallu attendre la fin du 19ème siècle pour accepter que "0 est un nombre" (Axiomes de Peano).

Les maths ont toujours été un plaisir pour moi, même si je ne suis pas mathématicien. Mais je me suis toujours placé comme dans un jeu: on peut jouer au bridge avec plus ou moins de talent, mais on ne peut plus jouer avec personne si on remet en cause les règles du jeu.
11/05/2014, 11h03
Invité

J'ai opté pour bon, pour mon plaisir

Bienheureux le rêveur des logiques... .

Citation:

Pour lutter contre les limites de la mémoire disponible, il faut enregistrer les nombres premiers trouvés sur disque au fur et à mesure, et cela représente tout de même un fichier de 5,03 Go!

Une élaboration dès son départ connait les obscurités à la forme d'une montagne insurmontable. Et, parmi les mystères de montagnard. Il y a ce qui lui manquait le plus, et qui répondait à cette question : Où vais-je placer les premiers multiples ?

Citation:

Sinon, je suis d'accord avec Sve@r: tu peux toujours adopter tes propres définitions (ex: 1 est un nb premier), mais tu te prépares un futur difficile:
- soit tu es un mathématicien génial et la communauté finira par adopter tes vues (c'est toujours possible, mais il te faudra méchamment batailler pour y arriver...)
- soit ce n'est pas le cas et tout ce que tu feras sera considéré comme faux par la communauté.

Au final, la nature se joue des mathématiques populaires humaines. Elle détient son propre code harmonique. Le paradoxe d'une élaboration qui tient en équilibre un ensemble fonctionnel comportant des grossièretés, du jargon de certains codes. Certaines représentations d'une fonction peuvent prendre différentes allures, et les astucieuses méthodes venant simplifier le code.
Le principal est d'avoir un sujet de développement, avec une démarche élaborant un plan de redressement...

Le nombres entiers premiers multiples, sont toujours impairs. Mon sujet est simple :
Un centre hexa réunit les nombres, il ne reste plus qu'à trouver une méthode astucieusement populaire.
Ceci dit, vos interventions m'on données la chance de voir du code (hors manuel). Grâce à ceci, je me suis décidé à revoir mon projet. En mangeant une olive et en m'occupant sérieusement du noyau.

Un pas de plus

J'ai amélioré les instructions, et contrairement au précédent qui reflète les nombres décimaux prévus pour un autre usage.
Ce programme réalise une reconnaissance numérique, en donnant le type, le multiple et les premiers, au cas par cas.

Rentrez un nombre entier et puis c'est tout

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#17/05/2014 à 13 heures.
#Les premiers multiples prolonge le syshexa en zygzag.
#Les chiffres premiers et le point de commun au syshexa.
 
#Ceyi
##saisie1 = input('Saisissez 1 pour voir les multiples communs : ')
##if saisie1 != "1" :
##    saisie1 = 0
##listecommun = int(saisie1)
saisie2 = input('Entrez un nombre : ')
if saisie2 == "" :
    saisie2 = "1"
nombre = int(saisie2)   #Nombre de référence
 
#Const
etat = nombre % 6       #etat = rang hexanumérique
multiple = 0
if nombre > 6 :         #Couches hexa supérieures
    if etat == 2 :
        print('Le nombre saisi (',nombre,') est un multiple PAIR')
        multiple = 1
        multinf = 2
    if etat == 3 :
        print('Le nombre saisi (',nombre,') est un multiple IMPAIR')
        multiple = 1
        multinf = 3
if etat == 4 :          #Couche fondamentale hexa
    print('Le nombre saisi (',nombre,') est un multiple PAIR')
    multiple = 1
    multinf = 2
if etat == 0 :          #Couche fondamentale hexa
    print('Le nombre saisi (',nombre,') est un multiple PAIR')
    multiple = 1
    multinf = 3
 
if (etat == 1)or(etat == 5) :   #etat = rang des premiers multiples
    n = 1
    for element in range(n,nombre) :        
        if element > 1 :
            examen = element % 6    #examen = rang hexa de l'indice
            if (examen == 1)or(examen == 5) :
                hexarang = nombre % element
                if hexarang == 0 :  #hexarang = multiple commun
                    #Le nombre est un multiple de l'élément
                    multinf = element
                    multiple = 1
##                    if (listecommun == 1) :
                    print('Multiple commun : ',element)                    
 
if multiple == 1 :
    print("Le nombre saisi est multiple de :",multinf)
else :
    print("Le nombre saisi (",nombre,") est premier")
multiple = 0

18/05/2014, 14h31
Sve@r

Citation:

Envoyé par toumus

Rentrez un nombre entier et puis c'est tout

Ben je rentre 420 et il me dit que c'est un multiple pair et un multiple de 3. Ce n'est pas tout à fait faux mais je sens qu'il manque quand-même des trucs non ???

Bonjour,

Ci-dessous, à titre d'exemple, un petit code pour trouver la liste des nombres premiers par la méthode des divisions. Ce n'est pas la plus rapide, mais ça marche déjà pas mal.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# -*- coding: utf-8 -*-
 
def facteurspremiers(n):
    """décomposition d'un nombre entier n en facteurs premiers par la méthode des divisions
       retourne la liste des facteurs premiers
       si la liste ne retourne qu'un seul élément égal à n: n est premier
    """
    if n<2:
        return [] # pas de nombre premier avant 2
    F = [] # pour stocker les nombres premiers trouvés
    # recherche de tous les facteurs 2 s'il y en a
    while n>=2:
        q, r = divmod(n, 2)
        if r==0:
            F.append(2)
            n = q
        else:
            break
    # recherche des facteurs 1er > 2
    i = 3
    while i<=n:
        if i*i>n:
            F.append(n)
            break # on a fini
        q, r = divmod(n, i)
        if r==0:
            F.append(i)
            n = q
        else:
            i += 2 # on ne teste que les nombres impairs
    return F

Exemples d'utilisation:

Code:

1
2
3
4
5
6
7
8
print(facteurspremiers(100))
[2,2,5,5]
 
print(facteurspremiers(123456789))
[3,3,3607,3803]
 
print(facteurspremiers(12345678901234567890))
[2,3,3,5,101,3541,3607,3803,27961]

,,, puis c'est tout...

Citation:

Rentrez un nombre entier et puis c'est tout
Ben je rentre 420 et il me dit que c'est un multiple pair et un multiple de 3. Ce n'est pas tout à fait faux mais je sens qu'il manque quand-même des trucs non ???

type de nombre.py : Donne la nature du nombre entier saisi, sans démultiplier les multiples des rangs ne contenant aucun premier multiple. C'est à cause du modèle (n%6), il est sûr qu'on pourrait tous les écrire. Mais l'intérêt pressant tourne autour des rangées sur lesquelles se trouvent les nombres premiers multiples communs, l'évolution part en boucles.

Première saisie du nombre, qui pose sa première question : Qui suis-je ?
*nombre = int(saisie2) #Nombre de référence*. La réponse frôle une technique d'approche hexanumérique, car tout bon érudit que je sois. Alors, on a besoin de savoir de quelle nature est ce nombre. Voici ce qu'elle dit : *etat = nombre % 6 #etat = rang hexanumérique*.
Vous pouvez tester çà avec les nombres à volonté.

Le problème posé par ce système hexa, est en relation avec la notion du premier multiple commun. Car, selon la définition générale les nombres premiers sont situés dans les rangs (1,5). Sauf pour la première couche (1,2,3,4,5,6), qui contient des nombres premiers aux rangs (2,3).

*if (etat == 1)or(etat == 5) : #etat = rang des premiers multiples*... #Rappel : etat = n%6
*hexarang = nombre % element*. #Un "%" classique
*if hexarang == 0 : #hexarang = multiple commun*. # Puis, un "==0" standard

Il est certain que cet exercice demande beaucoup de précision,
et d'amélioration. Mais, dans l'exercice de mon expérience. C'est que je cherche aussi à améliorer,
de manière à bien cerner les codages instructifs.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#17/05/2014 à 13 heures.
#Les premiers multiples prolonge le syshexa en zygzag.
#Les chiffres premiers et le point de commun au syshexa.
 
#Ceyi
saisie1 = input('Saisissez 1 pour voir les multiples communs : ')
if saisie1 != "1" :
    saisie1 = 0
listecommun = int(saisie1)
saisie2 = input('Entrez un nombre : ')
if saisie2 == "" :
    saisie2 = "1"
nombre = int(saisie2)   #Nombre de référence
 
#Const
etat = nombre % 6       #etat = rang hexanumérique
multiple = 0
if nombre > 6 :         #Couches hexa supérieures
    if etat == 2 :
        print('Le nombre saisi (',nombre,') est un multiple PAIR')
        multiple = 1
        multinf = 2
    if etat == 3 :
        print('Le nombre saisi (',nombre,') est un multiple IMPAIR')
        multiple = 1
        multinf = 3
if etat == 4 :          #Couche fondamentale hexa
    print('Le nombre saisi (',nombre,') est un multiple PAIR')
    multiple = 1
    multinf = 2
if etat == 0 :          #Couche fondamentale hexa
    print('Le nombre saisi (',nombre,') est un multiple PAIR')
    multiple = 1
    multinf = 3
 
if (etat == 1)or(etat == 5) :   #etat = rang des premiers multiples
    n = 1
    for element in range(n,nombre) :        
        if element > 1 :
            examen = element % 6    #examen = rang hexa de l'indice
            if (examen == 1)or(examen == 5) :
                hexarang = nombre % element
                if hexarang == 0 :  #hexarang = multiple commun
                    #Le nombre est un multiple de l'élément
                    multinf = element
                    multiple = 1
                    if (listecommun == 1) :
                        print('Multiple commun : ',element)                    
 
if multiple == 1 :
    print("Le nombre saisi est multiple de :",multinf)
else :
    print("Le nombre saisi (",nombre,") est premier")
multiple = 0

Ce n'est pas fini, je vous copie ce nouveau programme.py

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#*Reche*ri*che Des premiers multiples*
#Version1.5 : print(n), 18 mai 2014 | 14:12mn 
 
#"dianombre = nombre numérique-diatonique"
#"dianumérique = diatonisation numérique"
#Fonction dianumétrique
def dianombre(n) :
    y = 1
    for i in range(y,dian) :   #i = unième dianumérique
        if i > 1 :
            #Filtrage hexa (%6) de la valeur de i
            ihexa = i % 6
            if (ihexa == 1) or (ihexa ==5) :
                #print("ihexa = ",ihexa)
                #Comparaison de multiple (n%i)
                imult = n % i
                #Condition de non multiplicité
                if imult == 0 :
                    #imult = Multiple commun de n
                    #print("Résultat1 : ",imult)
                    break
                else :
                    #imult = Premier multiple commun
                    print("Premier multiple entier impair ",n)
                    break
 
###Saisie utilisateur
saisie1 = input("Les premiers multiples jusqu'à : ")
if saisie1 == "" :
    nombre = 1
else :
    nombre = int(saisie1)
 
#La première couche hexanumérique est composée des six premiers chiffres.
#C'est ici, qu'apparaissent les premiers premiers multiples
#Les couches supérieures réagissent au filtrage systématique.
#IMAGE : 2éme couche = (7,8,9,10,11,12). 3éme = (13,14,15,16,17,18).
 
###Bouclage tonique
x = 1
for n in range(x, nombre+1) : #n = unième numérique-tonique
    #Filtrage hexa (%6) de la valeur de n
    nhexa = n % 6
    #Condition de la première couche hexa (1,2,3,4,5,6)
    if (n <= 6)or(n == 1) :
        if nhexa == 1 :
            #Nombre premier multiple
            nhexa1 = " Multiple universel 1 "
            print("nhexa1 = ",nhexa1)
        if nhexa == 2 :
            #Nombre premier multiple
            nhexa2 = " Premier multiple pair de 2 "
            print("nhexa2 = ",nhexa2)
        if nhexa == 3 :
            #Nombre premier multiple
            nhexa3 = " Premier multiple impair de 3 "
            print("nhexa3 = ",nhexa3)
        if nhexa == 4 :
            #Nombre sous-premier multiple
            nhexa4 = " Sous-Premier multiple pair de 2 "
            print("nhexa4 = ",nhexa4)
        if nhexa == 5 :
            #Nombre premier multiple
            nhexa5 = " Premier multiple impair de 5 "
            print("nhexa5 = ",nhexa5)
        if nhexa == 0 :
            #Nombre sous-premier multiple
            nhexa6 = " Sous-Premier multiple pair de 3 "
            print("nhexa6 = ",nhexa6)
    else :   
        #Appel à la fonction dianumétrique
        if (nhexa == 1) or (nhexa ==5) :
            if n > 1000 :
                divn = n / 1000
                dian = int(n / divn)
            else :
                dian = n
            dianombre(n)
 
#Fin du programme