Voilà où j'en suis. Le test m'affiche toujours que le nombre est premier.

tu fais varier m dans ta boucle et tu testes n%p, quelle valeur a p ?

Salut,
Ta méthode est bonne et tu vas seulement jusqu'à sqrt(n) pour optimiser, c'est bien
Je n'ai pas compris à quoi servait la liste des nombres premiers par contre... ?
Pour que ton algo soit correct là, tu as juste à remplacer p par m au niveau de ta ligne grisée et c'est tout, pas besoin de se servir de la liste p !

Je voulais que p soit toutes les valeurs que je lui est attribué au départ.
C'est mon professeur qui nous a dit d'attribuer à p les 25 premiers premiers.
Effectivement si je le fais comme tu as dit ça marche. Donc pas besoin d'entrée les valeurs que peut prendre p ?

Bonjour,

non, c'est complètement faux par rapport à l'objectif annoncé.
le but n'étant pas de tester tous les nombres < sqrt(n) mais seulement les nombres premiers de la liste.

cette méthode avec utilisation d'une liste préalablement connue de nombres premiers ne peut pas se faire sainement avec une boucle "pour"
il faut utiliser une boucle tant que
(et ne pas confondre le rang d'un nombre dans la liste et sa valeur)

après, c'est sûr qu'on peut virer la liste et choisir une autre méthode (ce que tu proposes)
mais de toute façon ça ne marchera pas comme ça parce que pour un nombre n et dans la même et unique exécution, l'algorithme répéterait une palanquée de messages
les messages doivent être mis en dehors de la boucle

tout est en fait à reprendre. dans l'architecture même de l'algorithme.

D'accord merci de tes conseils.
Je peux faire ceci ?

   Tant que le reste de la division euclidienne de n par p[1] est différent de 0 faire n diviser par p[n+1] et    ainsi de suite ?  

non tu remélanges encore valeurs et indices.
n est une valeur
dans "p[n+1]", "n" est un indice, le rang du n^ème nombre premier

si tu rentres n = 3547, p[n+1] serait le 3548^ème élément de ta liste qui n'en contient que 25 ??
le rang d'un élément quelconque de ta liste doit être représenté par une autre variable
par exemple une variable "k"


de plus une boucle "tant que p[1]" ne risque pas de fonctionner puisque p[1] est toujours le même 1^er élément (le nombre premier 2) de la liste de nombres premiers

dans une telle boucle tu te poses et reposes en fait toujours la même question de savoir si n est divisble par 2
ta boucle ne s'arrête jamais sauf si n est pair !

la structure de la boucle c'est

k = 1
tant que n n'est pas divisible pas p[k] (et autres conditions en plus...)
k prend la valeur k+1 : on passe au nombre suivant de la liste p[ ]