NOMBRES PREMIERS

Code:: ' Liste des nombres premiers entre 2 nombres (borne inférieure et supérieure)

DIM F,J,K, SMALL, LARGE, S$

CLS
CAPTION 0, "Liste des nombres premiers entre 2 nombres"
INPUT "Veuillez saisir le nombre inférieur : ";S$
SMALL=VAL (S$)
INPUT "Veuillez saisir le nombre supérieur : ";S$
LARGE=VAL (S$)
IF LARGE < SMALL THEN TEMP = LARGE : LARGE = SMALL : SMALL = TEMP : ' Si l'utilisateur s'est trompé
SMALL=INT(SMALL/2)*2+1 : ' Prend le premier nombre impair comme borne inférieure
LARGE=INT(LARGE/2)*2-1 : ' Et le dernier nombre impiar comme borne supérieure
PRINT:PRINT "Les chiffres premiers trouvés sont : ":PRINT
FOR K=SMALL TO LARGE STEP 2
F=0 : ' Réinitialise le compteur
FOR J=3 TO SQR(K) STEP 2
IF K/J-INT(K/J)=0 THEN F=F+1 : ' Compte les facteurs, donc si F=0, ce sera un nombre premier
NEXT J
IF F=0 THEN PRINT RIGHT$(STRING$(7," ") +STR$(K),7);" "; : ' Pas de diviseur trouvé, on affiche le nombre premier
NEXT K
END

Bonjour Jicehel, Smile

Une autre façon d'avoir les nombres premiers en passant par un tableau:

Code:: dim i,j,n(10000):full_space 0:print "NOMBRES PREMIERS DE 1 A 10000"
for i=2 to 10000:n(i)=-1:next i
for i=2 to sqr(10000):for j=power(i,2) to 10000 step i:n(j)=0:next j:next i:j=0
for i=0 to 10000:if i>0 and int(i/200)=i/200 then print
if n(i)=-1 then print i;" ";
next i

A+

oui

là, tu as tout. En effet, tout dépend du besoin.

Une autre vision de la méthode de Bignono

Code:: dim i,j,n(10000),premier$
for i=2 to 10000:n(i)=-1:next i
for i=2 to sqr(10000):for j=power(i,2) to 10000 step i:n(j)=0:next j:next i:j=0
' *****************************************************************************
Is_Premier(2)
Is_Premier(10)
Is_Premier(997)
Is_Premier(999)
end
' ****************************************************************************
SUB Is_Premier(nombre)
if n(nombre) = -1
premier$ = str$(nombre) + " est prémier"
else
premier$ = str$(nombre) + " n'est pas prémier"
end_if
print premier$
END_SUB

J'aime bien la cosmétique de tes programme Papydall Wink

Papydall, c'est le prémier!
NOMBRES PREMIERS 18c_blue

Autrement dit : je n'admets aucun diviseur! NOMBRES PREMIERS U_JUMP%7E1

Heureusement car divisé, tu marcherait sans doute moins bien Wink

Nombre de messages : 7112 Localisation : 77 Date d'inscription : 29/11/2007

Bonsoir Jicehel, je ne voudrais pas jouer les puristes, mais pourquoi 'chiffres' au lieu de nombres (dans le code aussi) ?

C'est en effet une grossière erreur de langage dû à une faute d’inattention et un abus de langage. Je corrige ce que je peux, tu as parfaitement raison

Bien vu JL35 !
Moi je n’ai pas vu qu’il s’agissait des chiffres premiers !
Il n’y a que les nombres qui peuvent être premiers !
Quant au chiffres, ils ne sont ni premiers ni seconds ni derniers d'ailleurs!

Chipotons, chipotons :
1,2,3,5,7 sont bien des chiffres et ils sont premiers également... Wink

Rechipotons, rechipotons ...

1 n’est pas premier ! même s’il n’admet pour diviseur que lui-même et … 1 !
2,3,5,7 sont des chiffres (c.à.d. des symboles et ne peuvent avoir la propriété d’être ou ne pas être premiers).
2 est l'unique nombre pair et premier!
Quant aux nombres 2,3,5,7 (nuance!) oui : ils ont la propriété nombres premiers
Laughing

oui, mais bon là après, je laisse les perfectionnistes perfectionner.
Bon sinon les chiffres sont un sous ensemble des nombres.
Un chiffre est donc un nombre, mais un nombre est composé d'un ou plusieurs chiffres. Il ne peut donc pas être qualifié de "chiffre".
Si on veut améliorer la terminologie ou blinder plus le programme contre les erreurs de saisie, c'est tout à fait possible: le code est libre et ouvert à tout perfectionnement Very Happy

Donc amis puristes ou perfectionnistes, je vous en prie, perfectionnez Wink

Je savais que le nombre 1 n’est pas premier et ceci depuis mes lointains souvenirs.
Mais je ne me rappelle plus pourquoi.
J’ai consulté, donc, mon ami Google et voici l’histoire qu’il m’a racontée

UN N'EST PAS PREMIER – Pourquoi?
Un nombre premier n'est divisible que par 1 et lui-même. Or, 1 n'est pas premier !
Un est pourtant divisible que par 1 et lui-même !

Recherche
Est-ce qu'il existe un codicille à la définition des nombres premiers ?
Une petite marque cachée, excluant le 1 ou alors, c'est que 1 a des propriétés particulières?

Comme:
1 = 1 x 1 : une seule possibilité..
Alors que pour tous les nombres premiers:
5 = 1 x 5 = 5 x 1 : deux possibilités.
Ou:
1 = 1 x 1 x 1 x 1 …
Produit infini
2 <> 2 x 2 x 2 x 2 …
2 <> 1 x 2 x 2 x 2 …

On approche de la piste !
Il y a bien une exception pour 1, lequel n'est pas considéré comme un nombre premier.
C'est tout simplement que cela facilite la vie dans l'écriture de certaines lois; sans cela, il faudrait toujours énoncer la loi et ajouter "en excluant le 1".

Exemple 1:

Il existe un théorème qui dit que:
Tout nombre est le produit unique de nombres premiers (théorème fondamental de l'arithmétique).

Sans le 1, on écrit simplement:
100 = 2² x 5²

Avec le 1, on pourrait écrire une infinité de produits:
100 = 1 x 2² x 5²
= 1²⁰⁰⁰ x 2² x 5²
etc.
Bien évidemment, dans ce cas, la factorisation n'est plus unique.

Exemple 2:

Il existe un théorème qui dit que:
La somme des diviseurs d'un nombre premier p est p + 1.
Ce n'est pas le cas pour 1 lui-même, une bonne raison de l'exclure du club.

Conclusion

L'élimination du 1 n'est donc qu'une commodité de mathématicien; une convention
Rien à voir avec une propriété magique du 1, sauf qu'il se glisse partout dans les multiplications sans en changer la valeur
1 est, en effet, l'élément neutre de la multiplication.

En cherchant un peu pour trouver la méthode de calcul de PapyDall (que je n'ai encore trouvé) je suis tombé sur ceci
Je ne savais pas que cela existai... Wink

Ce n'était pas prévu mais bon vu le nombre de réactions sur ce petit programme j'ai fais une V2 un peu plus évoluée (et qui n'affiche pas le chiffre 1 dans les résultats ... Wink

Code:: ' --------------------------------------------------------------------
' Liste des nombres premiers entre 2 nombres
' --------------------------------------------------------------------

' --------------------------------------------------------------------
' Initialisation
'
LABEL chercher, recommencer, quitter, verifier
DIM F,I%,J,K,SMALL,LARGE,S$

' --------------------------------------------------------------------
' Interface utilisateur, demande du message à traduire
'
CAPTION 0, "Liste des nombres premiers entre 2 nombres"
FORM 100:LEFT 100,100:TOP 100,100:WIDTH 100,400:HEIGHT 100,200:CAPTION 100,"MESSAGE A CODER EN MORSE"
COMMAND_TARGET_IS 100
ALPHA 110:LEFT 110,10 :TOP 110,10:CAPTION 110,"Indiquez la borne inférieure de la recherche :"
EDIT 120:LEFT 120,10 :TOP 120,30:WIDTH 120,100 : ON_CHANGE 120,verifier
ALPHA 115:LEFT 115,10 :TOP 115,70:CAPTION 115,"Indiquez la borne supérieure de la recherche :"
EDIT 125:LEFT 125,10 :TOP 125,90:WIDTH 125,100 : : ON_CHANGE 125,verifier
BUTTON 130:LEFT 130,50 :TOP 130,130:CAPTION 130,"LANCER" : ON_CLICK 130, chercher
BUTTON 140:LEFT 140,155:TOP 140,130:CAPTION 140,"ANNULER": ON_CLICK 140, recommencer
BUTTON 150:LEFT 150,260:TOP 150,130:CAPTION 150,"QUITTER": ON_CLICK 150, quitter
FORM 200:HIDE 200 : LEFT 200,100:TOP 200,100:WIDTH 200,400:HEIGHT 200,160:CAPTION 200,"NOMBRES PREMIERS TROUVES"
COMMAND_TARGET_IS 200
ALPHA 210:LEFT 210,10 :TOP 210,10:CAPTION 210,"Liste des nombres premiers trouves :"
ALPHA 220:LEFT 220,10 :TOP 220,30:WIDTH 220,280
BUTTON 230:LEFT 230,50 :TOP 230,60:CAPTION 230,"NOUVEAU" :ON_CLICK 230,recommencer
BUTTON 240:LEFT 240,135:TOP 240,60:CAPTION 240,"QUITTER":ON_CLICK 240,quitter
COMMAND_TARGET_IS 100
END

chercher:
' --------------------------------------------------------------------
' Recherche les nombres entiers entre les 2 valeurs
'
HIDE 100
SMALL = VAL(TEXT$(120)) : LARGE = VAL(TEXT$(125))
IF LARGE < SMALL THEN TEMP = LARGE : LARGE = SMALL : SMALL = TEMP : ' Si l'utilisateur s'est trompé
IF LARGE < SMALL + 1
MESSAGE "La borne supérieure doit être plus grande que la borne inférieure"
GOSUB recommencer
RETURN
END_IF
SMALL=INT(SMALL/2)*2+1 : ' Prend le premier nombre impair comme borne inférieure
LARGE=INT(LARGE/2)*2-1 : ' Et le dernier nombre impair comme borne supérieure
S$=""
FOR K=SMALL TO LARGE STEP 2
F=0 : ' Réinitialise le compteur
FOR J=3 TO SQR(K) STEP 2
IF K/J-INT(K/J)=0 THEN F=F+1 : ' Compte les facteurs, donc si F=0, ce sera un nombre premier
NEXT J
IF F=0 AND K<> 1 THEN S$ = S$ + RIGHT$(STRING$(7," ") + STR$(K),7) +" " : ' Pas de diviseur trouvé, on affiche le nombre premier
NEXT K
CAPTION 220, S$ : SHOW 200
RETURN
' ------------------------------------------------------------------

verifier:
' --------------------------------------------------------------------
' Limite la taille des bornes par ce que sinon il faudrait compliquer
' le programme et que ce n'est pas le but et vérifie que l'on ne saisie
' que des chiffres pour entrer la valeur d'une des 2 bornes
'
OFF_CHANGE 120 : OFF_CHANGE 125
IF NUMBER_CHANGE = 120 OR NUMBER_CHANGE = 125
F=NUMBER_CHANGE
IF LEN(TEXT$(F)) > 7
MESSAGE "Pour des raisons pratiques, les limites doivent être inférieures à 10 000 000"
TEXT F,LEFT$(TEXT$(F),7)
END_IF
FOR I% = 1 TO LEN(TEXT$(F))
IF ASC(MID$(TEXT$(F),I%,1)) < 48 OR ASC(MID$(TEXT$(F),I%,1)) > 57
MESSAGE "Veuillez ne saisir que des chiffres"
TEXT F,""
SET_FOCUS F
END_IF
NEXT I%
END_IF
ON_CHANGE 120,verifier : ON_CHANGE 125,verifier
RETURN
' ------------------------------------------------------------------

recommencer:
' ---------------------------------------------------------------------
' Réafficher la fenêtre pour saisir les bornes de la recherche
'
HIDE 200 : OFF_CHANGE 120 : OFF_CHANGE 125 : TEXT 120, "" : TEXT 125, "": SHOW 100 : SET_FOCUS 120
ON_CHANGE 120,verifier : ON_CHANGE 125,verifier
RETURN
' --------------------------------------------------------------------

quitter:
Terminate

C’est bien !
Mais, comme j’ai toujours un mais, tu as aussi envoyé en l’air les 2 premiers nombres premiers qui sont 2 et 3 !
Ligne 47 à modifier ainsi

Code:: S$="2"+string$(7," ") + "3"

pour que ça soit dans les règles de l’art !

Le problème de ta solution c'est que ces solutions peuvent ne pas être dans la fourchette de la recherche.

Perso, je modifierais plutôt la ligne

Code:: IF F=0 AND K<> 1 THEN S$ = S$ + RIGHT$(STRING$(7," ") + STR$(K),7) +" " : ' Pas de diviseur trouvé, on affiche le nombre

en

Code:: IF (F=0 OR K=2 OR K=3) AND K<> 1 THEN S$ = S$ + RIGHT$(STRING$(7," ") + STR$(K),7) +" " : ' Pas de diviseur trouvé, on affiche le nombre

Comme ça il balaye les solutions et ajoute les bonnes réponses quand il faut si elles sont dans la fourchette de recherche.

Mais bon il y a aussi d'autres solutions qui donnent le bon résultat.

Je modifierais et je testerais ça ce soir.

Quand l’arithmétique nous fascine !

7
73
739
7393
73939
739391
7393913
73939133

Tous ces nombres sont premiers et c’est la plus grande suite possible de ce type.

Dans le même esprit que les nombres premiers, voici une procédure qui calcule le PGCD et le PPCM de 2 nombres entiers.

Rappel
En arithmétique élémentaire,
Le plus grand commun diviseur, PGCD, de deux nombres entiers naturels est le plus grand entier naturel qui divise simultanément ces deux entiers.
Le plus petit commun multiple PPCM de deux entiers non nuls est le plus petit entier strictement positif qui soit à la fois multiple de ces deux nombres.
Par exemple
Le PGCD de 42 et 56 est 14.
Le PPCM de 42 et 56 est 168.

Code:: ' Calcul du PGCD et du PPCM de deux entiers

dim PGCD%,PPCM%,n1%,n2%
n1% = 42 : n2% = 56
pgcd(n1%,n2%)
print "PGCD(" + str$(n1%) +","+str$(n2%)+") = " ; pgcd%
print "PPCM(" + str$(n1%) +","+str$(n2%)+") = " ; ppcm%
end
' ------------------------------------------------------------------------------
SUB PGCD(n1%,n2%)
dim_local n3%,n4%,n5%
n4% = n1% : n5% = n2%
while n2% > 0
n3% = n1% : n1% = n2% : n2% = n3% - n1% * int(n3%/n1%)
end_while
PGCD% = n1%
if PGCD% <> 0 then PPCM% = (n4%*n5%)/PGCD%
END_SUB
' ------------------------------------------------------------------------------

J'ai modifié mon programme pour incorporer 2 et 3 dans les chiffres / nombres premiers (ma solution ne marchait pas bien).
Du coup j'en ai profité pour rajouter dedans le PGCD et le PPCM Wink

Code:: ' --------------------------------------------------------------------
' Quelques fonctions mathématiques:
' - Liste des nombres premiers entre 2 nombres
' - Calcul du PGCD de 2 nombres entiers
' - Calcul du PPCM de 2 nombres entiers
' --------------------------------------------------------------------
' Ecrit en Basic Panoramic 0.9.24 le 18/12/2012 par Jicehel
' --------------------------------------------------------------------

' --------------------------------------------------------------------
' Initialisation
'
LABEL chercher, recommencer, quitter, verifier, calculerPGCD, calculerPPCM
LABEL M_nbpremiers, M_PGCD, M_PPCM
DIM F,I%,J,K,SMALL,LARGE,S$, PGCD%,PPCM%

' --------------------------------------------------------------------
' Interface utilisateur, demande du message à traduire
'
CAPTION 0, "FONCTIONS MATHEMATIQUES"

' Création du menu pour choisir la fonction à lancer
MAIN_MENU 10
SUB_MENU 20 : PARENT 20,10 : CAPTION 20, "Choix de la fonction à lancer"
SUB_MENU 21 : PARENT 21,20 : CAPTION 21, "Trouver les chiffres premiers entre 2 bornes" : ON_CLICK 21,M_nbpremiers
SUB_MENU 22 : PARENT 22,20 : CAPTION 22, "Trouver le PGCD de 2 nombres entiers" : ON_CLICK 22,M_PGCD
SUB_MENU 23 : PARENT 23,20 : CAPTION 23, "Trouver le PPCM de 2 nombres entiers" : ON_CLICK 23,M_PPCM

' Création des fenêtres utilisées
FORM 100:HIDE 100 : LEFT 100,100:TOP 100,100:WIDTH 100,400:HEIGHT 100,200
COMMAND_TARGET_IS 100
ALPHA 110:LEFT 110,10 :TOP 110,10
EDIT 120:LEFT 120,10 :TOP 120,30:WIDTH 120,100
ALPHA 115:LEFT 115,10 :TOP 115,70
EDIT 125:LEFT 125,10 :TOP 125,90:WIDTH 125,100
BUTTON 130:LEFT 130,50 :TOP 130,130:CAPTION 130,"LANCER"
BUTTON 140:LEFT 140,155:TOP 140,130:CAPTION 140,"ANNULER": ON_CLICK 140, recommencer
BUTTON 150:LEFT 150,260:TOP 150,130:CAPTION 150,"QUITTER": ON_CLICK 150, quitter
FORM 200:HIDE 200 : LEFT 200,100:TOP 200,100:WIDTH 200,400:HEIGHT 200,160
COMMAND_TARGET_IS 200
ALPHA 210:LEFT 210,10 :TOP 210,10
ALPHA 220:LEFT 220,10 :TOP 220,30:WIDTH 220,280
BUTTON 230:LEFT 230,50 :TOP 230,60:CAPTION 230,"NOUVEAU" :ON_CLICK 230,recommencer
BUTTON 240:LEFT 240,135:TOP 240,60:CAPTION 240,"QUITTER":ON_CLICK 240,quitter
COMMAND_TARGET_IS 100

' Fin
END

M_nbpremiers:
' --------------------------------------------------------------------
' Prépare les fenêtres pour la liste des nombres premiers
'
CAPTION 100,"Liste des nombres premiers entre 2 nombres":CAPTION 110,"Indiquez la borne inférieure de la recherche :":CAPTION 115,"Indiquez la borne supérieure de la recherche :"
ON_CHANGE 120,verifier : ON_CHANGE 125,verifier : ON_CLICK 130, chercher
CAPTION 200,"NOMBRES PREMIERS TROUVES":CAPTION 210,"Liste des nombres premiers trouves :"
GOSUB recommencer
RETURN

M_PGCD:
' --------------------------------------------------------------------
' Prépare les fenêtres pour le calcul du PGCD
'
CAPTION 100,"Calcul du PGCD (Plus Grand Commun Diviseur)"
CAPTION 110,"Indiquez le premier nombre entier:":CAPTION 115,"Indiquez le second nombre entier :"
ON_CHANGE 120,verifier : ON_CHANGE 125,verifier : ON_CLICK 130, calculerPGCD
GOSUB recommencer
RETURN

calculerPGCD:
' --------------------------------------------------------------------
' Lance le calcule du PGCD
'
HIDE 100
PGCD(VAL(TEXT$(120)),VAL(TEXT$(125)))
CAPTION 200,"RESULTAT":CAPTION 210,"Le PGCD de "+TEXT$(120)+" et de "+TEXT$(125)+" est :"
CAPTION 220, STR$(PGCD%) : SHOW 200
RETURN

' --------------------------------------------------------------------
' La fonction qui effectue le calcul
'
SUB PGCD(n1%,n2%)
dim_local n3%,n4%,n5%
n4% = n1% : n5% = n2%
while n2% > 0
n3% = n1% : n1% = n2% : n2% = n3% - n1%* int(n3%/n1%)
end_while
PGCD% = n1%
if PGCD% <> 0 then PPCM% = (n4%*n5%)/PGCD%
END_SUB
' ------------------------------------------------------------------------------

M_PPCM:
' --------------------------------------------------------------------
' Prépare les fenêtres pour le calcul du PPCM
'
CAPTION 100,"Calcul du PPCM (Plus Petit Commun Multiple)"
CAPTION 110,"Indiquez le premier nombre entier:":CAPTION 115,"Indiquez le second nombre entier :"
ON_CHANGE 120,verifier : ON_CHANGE 125,verifier : ON_CLICK 130, calculerPPCM
GOSUB recommencer
RETURN

calculerPPCM:
' --------------------------------------------------------------------
' Lance le calcul du PPCM
'
HIDE 100
PGCD(VAL(TEXT$(120)),VAL(TEXT$(125)))
CAPTION 200,"RESULTAT":CAPTION 210,"Le PPCM de "+TEXT$(120)+" et de "+TEXT$(125)+" est :"
CAPTION 220, STR$(PPCM%) : SHOW 200
RETURN

chercher:
' --------------------------------------------------------------------
' Recherche les nombres entiers entre les 2 valeurs
'
HIDE 100 : SMALL = VAL(TEXT$(120)) : LARGE = VAL(TEXT$(125))
IF LARGE < SMALL THEN TEMP = LARGE : LARGE = SMALL : SMALL = TEMP : ' Si l'utilisateur s'est trompé
IF LARGE < SMALL + 1
MESSAGE "La borne supérieure doit être plus grande que la borne inférieure"
GOSUB recommencer
RETURN
END_IF
IF LARGE > 1 AND SMALL < 3 THEN S$=" 2 " : ELSE : S$=""
IF LARGE > 2 AND SMALL < 4 THEN S$=S$+" 3 "
SMALL=INT(SMALL/2)*2+1 : ' Prend le premier nombre impair comme borne inférieure
LARGE=INT(LARGE/2)*2-1 : ' Et le dernier nombre impair comme borne supérieure
IF SMALL=LARGE THEN LARGE = LARGE + 2
FOR K=SMALL TO LARGE STEP 2
F=0 : ' Réinitialise le compteur
FOR J=3 TO SQR(K) STEP 2
IF K/J-INT(K/J)=0 THEN F=F+1 : ' Compte les facteurs, donc si F=0, ce sera un nombre premier
NEXT J
IF F=0 AND K<> 1 THEN S$ = S$ + RIGHT$(STRING$(7," ") + STR$(K),7) +" " : ' Pas de diviseur trouvé, on affiche le nombre premier
NEXT K
CAPTION 220, S$ : SHOW 200
RETURN
' ------------------------------------------------------------------

verifier:
' --------------------------------------------------------------------
' Limite la taille des bornes par ce que sinon il faudrait compliquer
' le programme et que ce n'est pas le but et vérifie que l'on ne saisie
' que des chiffres pour entrer la valeur d'une des 2 bornes
'
OFF_CHANGE 120 : OFF_CHANGE 125
IF NUMBER_CHANGE = 120 OR NUMBER_CHANGE = 125
F=NUMBER_CHANGE
IF LEN(TEXT$(F)) > 7
MESSAGE "Pour des raisons pratiques, les limites doivent être inférieures à 10 000 000"
TEXT F,LEFT$(TEXT$(F),7)
END_IF
FOR I% = 1 TO LEN(TEXT$(F))
IF ASC(MID$(TEXT$(F),I%,1)) < 48 OR ASC(MID$(TEXT$(F),I%,1)) > 57
MESSAGE "Veuillez ne saisir que des chiffres"
TEXT F,""
SET_FOCUS F
END_IF
NEXT I%
END_IF
ON_CHANGE 120,verifier : ON_CHANGE 125,verifier
RETURN
' ------------------------------------------------------------------

recommencer:
' ---------------------------------------------------------------------
' Réafficher la fenêtre pour saisir les bornes de la recherche
'
HIDE 200 : OFF_CHANGE 120 : OFF_CHANGE 125 : TEXT 120, "" : TEXT 125, "": SHOW 100 : SET_FOCUS 120
ON_CHANGE 120,verifier : ON_CHANGE 125,verifier
RETURN
' --------------------------------------------------------------------

quitter:
TERMINATE

Et voici une autre procédure pour le calcul de la factorielle d’un nombre que tu peux intégrer dans ton programme.

Rappel :
Factorielle N notée N ! = 1 * 2 * 3 * .... * N
Exemple :
5 ! = 1*2*3*4*5 = 120

Code:: ' Factoriel n
dim n%,fact
n% = 10
factoriel(n%) : print fact

end
SUB Factoriel(n%)
DIM_LOCAL i%
if n% < 0 then message "La valeur doit-être positive ou nulle !" : exit_sub
i% = n% -1
if n% = 0 then fact = 1 : exit_sub
fact = n%
while i% > 1 : fact = fact * i% : i% = i% - 1 : end_while
END_SUB
' ******************************************************************************

OK, voilà monsieur, c'est ajouté (avec la simplification de fraction aussi puisque l'on à le PGCD Wink

)

Code:: ' --------------------------------------------------------------------
' Quelques fonctions mathématiques:
' - Liste des nombres premiers entre 2 nombres
' - Calcul du PGCD de 2 nombres entiers
' - Calcul du PPCM de 2 nombres entiers
' --------------------------------------------------------------------
' Ecrit en Basic Panoramic 0.9.24 le 18/12/2012 par Jicehel
' --------------------------------------------------------------------

' --------------------------------------------------------------------
' Initialisation
'
LABEL recommencer, quitter, verifier
LABEL chercher, calculerPGCD, calculerPPCM, simplifierFraction, calculerFactoriel
LABEL M_nbpremiers, M_PGCD, M_PPCM, M_Simplifier, M_Factoriel
DIM F,I%,J,K,SMALL,LARGE,S$, PGCD%,PPCM%

' --------------------------------------------------------------------
' Interface utilisateur, demande du message à traduire
'
CAPTION 0, "FONCTIONS MATHEMATIQUES"

' Création du menu pour choisir la fonction à lancer
MAIN_MENU 10
SUB_MENU 20 : PARENT 20,10 : CAPTION 20, "Choix de la fonction à lancer"
SUB_MENU 21 : PARENT 21,20 : CAPTION 21, "Trouver les chiffres premiers entre 2 bornes" : ON_CLICK 21,M_nbpremiers
SUB_MENU 22 : PARENT 22,20 : CAPTION 22, "Trouver le PGCD de 2 nombres entiers" : ON_CLICK 22,M_PGCD
SUB_MENU 23 : PARENT 23,20 : CAPTION 23, "Trouver le PPCM de 2 nombres entiers" : ON_CLICK 23,M_PPCM
SUB_MENU 24 : PARENT 24,20 : CAPTION 24, "Simplifier une fraction de 2 entiers" : ON_CLICK 24,M_Simplifier
SUB_MENU 25 : PARENT 25,20 : CAPTION 25, "Calculer le factoriel d'un entier" : ON_CLICK 25,M_Factoriel

' Création des fenêtres utilisées
FORM 100:HIDE 100 : LEFT 100,100:TOP 100,100:WIDTH 100,400:HEIGHT 100,200
COMMAND_TARGET_IS 100
ALPHA 110:LEFT 110,10 :TOP 110,10
EDIT 120:LEFT 120,10 :TOP 120,30:WIDTH 120,100
ALPHA 115:LEFT 115,10 :TOP 115,70
EDIT 125:LEFT 125,10 :TOP 125,90:WIDTH 125,100
BUTTON 130:LEFT 130,50 :TOP 130,130:CAPTION 130,"LANCER"
BUTTON 140:LEFT 140,155:TOP 140,130:CAPTION 140,"ANNULER": ON_CLICK 140, recommencer
BUTTON 150:LEFT 150,260:TOP 150,130:CAPTION 150,"QUITTER": ON_CLICK 150, quitter
FORM 200:HIDE 200 : LEFT 200,100:TOP 200,100:WIDTH 200,400:HEIGHT 200,160
COMMAND_TARGET_IS 200
ALPHA 210:LEFT 210,10 :TOP 210,10
ALPHA 220:LEFT 220,10 :TOP 220,30:WIDTH 220,280
BUTTON 230:LEFT 230,50 :TOP 230,60:CAPTION 230,"NOUVEAU" :ON_CLICK 230,recommencer
BUTTON 240:LEFT 240,135:TOP 240,60:CAPTION 240,"QUITTER":ON_CLICK 240,quitter
COMMAND_TARGET_IS 100

' Fin
END

M_nbpremiers:
' --------------------------------------------------------------------
' Prépare les fenêtres pour la liste des nombres premiers
'
CAPTION 100,"Liste des nombres premiers entre 2 nombres":CAPTION 110,"Indiquez la borne inférieure de la recherche :":CAPTION 115,"Indiquez la borne supérieure de la recherche :"
ON_CHANGE 120,verifier : ON_CHANGE 125,verifier : ON_CLICK 130, chercher
CAPTION 200,"NOMBRES PREMIERS TROUVES":CAPTION 210,"Liste des nombres premiers trouves :"
GOSUB recommencer
RETURN

M_PGCD:
' --------------------------------------------------------------------
' Prépare les fenêtres pour le calcul du PGCD
'
CAPTION 100,"Calcul du PGCD (Plus Grand Commun Diviseur)"
CAPTION 110,"Indiquez le premier nombre entier:":CAPTION 115,"Indiquez le second nombre entier :"
ON_CHANGE 120,verifier : ON_CHANGE 125,verifier : ON_CLICK 130, calculerPGCD
GOSUB recommencer
RETURN

calculerPGCD:
' --------------------------------------------------------------------
' Lance le calcule du PGCD
'
HIDE 100
PGCD(VAL(TEXT$(120)),VAL(TEXT$(125)))
CAPTION 200,"RESULTAT":CAPTION 210,"Le PGCD de "+TEXT$(120)+" et de "+TEXT$(125)+" est :"
CAPTION 220, STR$(PGCD%) : SHOW 200
RETURN

' --------------------------------------------------------------------
' La fonction qui effectue le calcul
'
SUB PGCD(n1%,n2%)
dim_local n3%,n4%,n5%
n4% = n1% : n5% = n2%
while n2% > 0
n3% = n1% : n1% = n2% : n2% = n3% - n1%* int(n3%/n1%)
end_while
PGCD% = n1%
if PGCD% <> 0 then PPCM% = (n4%*n5%)/PGCD%
END_SUB
' ------------------------------------------------------------------------------

M_PPCM:
' --------------------------------------------------------------------
' Prépare les fenêtres pour le calcul du PPCM
'
CAPTION 100,"Calcul du PPCM (Plus Petit Commun Multiple)"
CAPTION 110,"Indiquez le premier nombre entier:":CAPTION 115,"Indiquez le second nombre entier :"
ON_CHANGE 120,verifier : ON_CHANGE 125,verifier : ON_CLICK 130, calculerPPCM
GOSUB recommencer
RETURN

calculerPPCM:
' --------------------------------------------------------------------
' Lance le calcul du PPCM
'
HIDE 100
PGCD(VAL(TEXT$(120)),VAL(TEXT$(125)))
CAPTION 200,"RESULTAT":CAPTION 210,"Le PPCM de "+TEXT$(120)+" et de "+TEXT$(125)+" est :"
CAPTION 220, STR$(PPCM%) : SHOW 200
RETURN

M_Simplifier:
' --------------------------------------------------------------------
' Prépare les fenêtres pour la simplification de la fraction
'
CAPTION 100,"Simplification d'une fraction de 2 entiers"
CAPTION 110,"Indiquez le numerateur (entier):":CAPTION 115,"Indiquez le dénominateur (entier) :"
ON_CHANGE 120,verifier : ON_CHANGE 125,verifier : ON_CLICK 130, simplifierFraction
GOSUB recommencer
RETURN

simplifierFraction:
' --------------------------------------------------------------------
' Lance la simplification de l'équation
'
HIDE 100
J = VAL(TEXT$(120)) : K = VAL(TEXT$(125)) : PGCD(J,K)
CAPTION 200,"RESULTAT":CAPTION 210,"L'équation simplifié de "+TEXT$(120)+" / "+TEXT$(125)+" est :"
CAPTION 220, STR$(J/PGCD%)+" / "+ STR$(K/PGCD%): SHOW 200
RETURN

M_Factoriel:
' --------------------------------------------------------------------
' Prépare les fenêtres pour le calcul du factoriel
'
CAPTION 100,"Calcul du factoriel d'un nombre entier"
CAPTION 110,"Indiquez l'entier dont vous vouler connaître le factoriel :":CAPTION 115,""
ON_CHANGE 120,verifier : OFF_CHANGE 125 : HIDE 125 : ON_CLICK 130, calculerFactoriel
GOSUB recommencer
RETURN

calculerFactoriel:
' --------------------------------------------------------------------
' Calculer le factoriel d'un entier
'
HIDE 100
J = VAL(TEXT$(120))
CAPTION 200,"RESULTAT":CAPTION 210,"Le résultat du factoriel de "+TEXT$(120)+" ("+TEXT$(120)+"!) est :"
IF J=0
CAPTION 220,"1"
ELSE
I% = J -1 : K = J
WHILE I% > 1 : K = K * I% : I% = I% - 1 : END_WHILE
CAPTION 220, STR$(K)
END_IF
SHOW 200
RETURN

chercher:
' --------------------------------------------------------------------
' Recherche les nombres entiers entre les 2 valeurs
'
HIDE 100 : SMALL = VAL(TEXT$(120)) : LARGE = VAL(TEXT$(125))
IF LARGE < SMALL THEN TEMP = LARGE : LARGE = SMALL : SMALL = TEMP : ' Si l'utilisateur s'est trompé
IF LARGE < SMALL + 1
MESSAGE "La borne supérieure doit être plus grande que la borne inférieure"
GOSUB recommencer
RETURN
END_IF
IF LARGE > 1 AND SMALL < 3 THEN S$=" 2 " : ELSE : S$=""
IF LARGE > 2 AND SMALL < 4 THEN S$=S$+" 3 "
SMALL=INT(SMALL/2)*2+1 : ' Prend le premier nombre impair comme borne inférieure
LARGE=INT(LARGE/2)*2-1 : ' Et le dernier nombre impair comme borne supérieure
IF SMALL=LARGE THEN LARGE = LARGE + 2
FOR K=SMALL TO LARGE STEP 2
F=0 : ' Réinitialise le compteur
FOR J=3 TO SQR(K) STEP 2
IF K/J-INT(K/J)=0 THEN F=F+1 : ' Compte les facteurs, donc si F=0, ce sera un nombre premier
NEXT J
IF F=0 AND K<> 1 THEN S$ = S$ + RIGHT$(STRING$(7," ") + STR$(K),7) +" " : ' Pas de diviseur trouvé, on affiche le nombre premier
NEXT K
CAPTION 220, S$ : SHOW 200
RETURN
' ------------------------------------------------------------------

verifier:
' --------------------------------------------------------------------
' Limite la taille des bornes par ce que sinon il faudrait compliquer
' le programme et que ce n'est pas le but et vérifie que l'on ne saisie
' que des chiffres pour entrer la valeur d'une des 2 bornes
'
OFF_CHANGE 120 : OFF_CHANGE 125
IF NUMBER_CHANGE = 120 OR NUMBER_CHANGE = 125
F=NUMBER_CHANGE
IF LEN(TEXT$(F)) > 7
MESSAGE "Pour des raisons pratiques, les limites doivent être inférieures à 10 000 000"
TEXT F,LEFT$(TEXT$(F),7)
END_IF
FOR I% = 1 TO LEN(TEXT$(F))
IF ASC(MID$(TEXT$(F),I%,1)) < 48 OR ASC(MID$(TEXT$(F),I%,1)) > 57
MESSAGE "Veuillez ne saisir que des chiffres"
TEXT F,""
SET_FOCUS F
END_IF
NEXT I%
END_IF
ON_CHANGE 120,verifier : ON_CHANGE 125,verifier
RETURN
' ------------------------------------------------------------------

recommencer:
' ---------------------------------------------------------------------
' Réafficher la fenêtre pour saisir les bornes de la recherche
'
HIDE 200 : OFF_CHANGE 120 : OFF_CHANGE 125 : TEXT 120, "" : TEXT 125, "": SHOW 100 : SET_FOCUS 120
ON_CHANGE 120,verifier : ON_CHANGE 125,verifier
RETURN
' --------------------------------------------------------------------

quitter:
TERMINATE

» Traceur de courbes représentatives des fonctions y = f(x)
» Recherche de nombres premiers
» Défi2 = les moindres carrés
» Les nombres narcissiques (ou nombres d’Armstrong)
» Premiers pas en 3D