Bonjour,
Schéma de l'algorithme

Entrée 0 < n < 99
Entrée 100*n < m  < 100*n
Entrée compteur i = 0

Condition
Si m = premier
Afficher m
i = 1
Sinon "Arrêt programme"

A bientôt.

Bonjour,
Dans mode édition passer en mode texte.

Exemple que j'ai pas fini.

VARIABLES
n EST_DU_TYPE NOMBRE
m EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
n PREND_LA_VALEUR 0
POUR n ALLANT_DE 0 A 99
DEBUT_POUR
m PREND_LA_VALEUR 100*n  
POUR m ALLANT_DE 100*n A 100*(n+1)  
SI (m=m*2 +1) ALORS
DEBUT_SI
AFFICHER* m
  FIN_SI
FIN_POUR  
FIN_ALGORITHME

A bientôt.

je ne comprends pas, SI (m=m*2 +1) ça teste si m est premier ça ?
d'abord ça devrait être SI (m==m*2 +1)
il manque aussi un FIN_POUR et puis n PREND_LA_VALEUR 0 est inutile, m PREND_LA_VALEUR 100*n aussi
non je ne comprends pas cet algorithme

Bonjour,

Voici un algorithme qui compte les nombres premiers entre 100N et 100(N+1) pour N variant de 0 à 99:

1 VARIABLES
2 N EST_DU_TYPE NOMBRE
3 I EST_DU_TYPE NOMBRE
4 premier EST_DU_TYPE NOMBRE
5 J EST_DU_TYPE NOMBRE
6 inf EST_DU_TYPE NOMBRE
7 sup EST_DU_TYPE NOMBRE
8 K EST_DU_TYPE NOMBRE
9 DEBUT_ALGORITHME
10 POUR N ALLANT_DE 0 A 99
11 DEBUT_POUR
12 inf PREND_LA_VALEUR 100*N
13 sup PREND_LA_VALEUR 100*(N+1)
14 K PREND_LA_VALEUR 0
15 POUR I ALLANT_DE inf A sup
16 DEBUT_POUR
17 premier PREND_LA_VALEUR 1
18 POUR J ALLANT_DE 2 A I-1
19 DEBUT_POUR
20 SI (I%J==0) ALORS
21 DEBUT_SI
22 premier PREND_LA_VALEUR 0
23 FIN_SI
24 FIN_POUR
25 SI (premier ==1) ALORS
26 DEBUT_SI
27 K PREND_LA_VALEUR K+1
28 FIN_SI
29 FIN_POUR
30 AFFICHER "Le nombre de nombres premiers entre "
31 AFFICHER inf
32 AFFICHER " et "
33 AFFICHER sup
34 AFFICHER " est "
35 AFFICHER K
36 FIN_POUR
37 FIN_ALGORITHME

Malheureusement, le nombre de boucles permises par algobox est volontairement limité à 5 millions ce qui fait que l' algorithme s' arrête à N=30.

Il sera donc nécessaire de modifier la ligne 10:

Bonjour,

Voici une variante d'algorithme qui passe bien sous ALGOBOX.
Il n'y a que deux boucles imbriquées.
La boucle intérieure qui teste les diviseurs s'arrête dès qu'on atteint la racine carrée de K...
... puisque un éventuel diviseur supérieur aurait déjà été trouvé avant...



CENTAINES est le nombre de centaines testées.
D'après l'énoncé :  entrer CENTAINES = 100

L'utilisation d'une liste P[N] simplifie un peu l'écriture...

Y' a pas photo LeDino, (bonjour), ton algorithme est bien meilleur!

Merci LeDino !!!
Mais dans tes variables , tu mets quoi ? :$

ben suffit de regarder les variables qui interviennent dans l' algorithme...

Bonsoir thesum,

Si tu débutes, je te conseille de commencer par faire un programme plus simple qui dit si un nombre qu'on a saisi est premier ou pas.

Pour les variables, j'ai respecté en gros celles de l'énoncé :

N :  les centaines, de 0 à 99.

K :  chaque nombre de 1 à 10000 : K est testé comme premier, s'il l'est, alors un compteur de nombre premiers est incrémenté dan la liste P[N], pour le rang N qui correspond à la centaine à laquelle appartient K.

I :  est juste un indice qui permet de chercher s'il y a un diviseur de K, afin de dire s'il est premier. On appelle ça passer K "au crible"... Si on ne trouve pas de diviseur (on commence à 2 pour ne pas s'embêter avec 1 qui divise tout) alors le nombre est premier.

DIV :  est le nombre de diviseurs de K. Si DIV = 0 en fin de boucle du crible, alors on sait que K est premier.

P[] :  est une LISTE. On stocke dans P[N] le nombre de nombres premiers trouvés pour la N-ième centaine. C'est cette liste qu'on affichera à la fin pour chaque valeur de N.
Et c'est elle qui permet aussi de calculer facilment PMOY.

PMOY :  est le nombre moyen de nombre premiers trouvés par centaine.

CENTAINES :  ça c'est juste un paramètre qui vaut 100 dans ton énoncé, mais que tu peux saisir comme tu veux quand tu fais des essais de ton programme. Il s'agit du nombre de centaines que tu veux passer au crible.

MSG :  est une variable de type CHAINE. Elle peut contenir un texte. C'est très pratique pour construire un message qui contient à la fois du texte fixe, et des données numériques (des valeurs de variabes par exemple). Une fois le message construit, il reste à afficher la variable qui le contient. C'est plus rapide et plus efficace que d'utiliser les instrucions AFFICHER MESSAGE...