Affichage de nombres premiers

Naindev · 23/11/2012, 01h06

Bonsoir développeurs.

Je profite de mon premier post sur ce forum pour présenter mon profil de développeur.

Naindev, 19 ans, étudiant en L1 de Mathématiques-Informatique, Paris.

Concernant ma question, voici l'énoncé de mon exercice :

Citation:

Lire un nombre entier L puis afficher tous les nombres premiers compris entre 0 et L

Et voici le code Pascal que j'ai concocté :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
program prim_num;
uses crt;

var n,j:integer;

begin 
clrscr;
writeln(' Les nombres premiers compris entre 1 et 100 sont :');
writeln('1');
writeln('2');

n:=3;
while (n<100) do
    begin

    j:=2;

      repeat
      begin

        if (n mod j <> 0) then
          j:=j+1
        else

          begin
           n:=n+1;
           j:=2;
          end;

      end;

     until (n=j);
7
    writeln(n);
    n:=n+1;

    end;

readln;

end.

( Note : Dans un premier temps, j'ai fixé L à 100 pour mes tests. ).

En exécutant ce code, je me retrouve avec tous les nombres premiers compris entre 0 et 100 + 101. 97 est le dernier nombre premier compris entre 1 et 100, ensuite viennent 98, 99, 100 qui engendreront l'exécution de la partie en gras. Puis 101 qui est premier, qui fera donc afficher 101 et sortir de la boucle "while" ( 101 étant supérieur à 100 ).

Cependant, l'énoncé de l'exercice ne réclame que les nombres premiers compris entre 0 et 100, donc pas le 101. J'ai donc modifié mon code de la sorte :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
uses crt;

var n,j:integer;

begin
clrscr;
writeln(' Les nombres premiers compris entre 1 et 100 sont :');
writeln('1');
writeln('2');

n:=3;
while (n<100) do {a}
    begin

    j:=2;

      repeat {b}
      begin
        {Part1} 
        if (n mod j <> 0) then
          j:=j+1
        else

          begin
           {Part2}
          if n<100 then
            begin
            n:=n+1;
            j:=2;
            end;
          end;
      end;

     until (n=j);

    writeln(n);
    n:=n+1;

    end;

readln;

end.

Arrivé à 99 qui n'est pas premier et 99 étant inférieur à 100, c'est la partie qui suit la ligne en gras qui sera exécutée, donc la valeur sera 100. Mais 100 n'est pas premier ( 100 mod 2 = 0, Part 1 } ), il engendre donc l'exécution de la Part2. 100 n'étant pas supérieur à 100, cette partie ne sera pas exécutée et 100 =/= 2 donc on reste toujours dans la boucle {b} et ça demeurera ainsi infiniment.

J'aimerais donc, si possible, avoir une solution à ce petit souci, et, par la même occasion, avoir votre avis sur cette solution ( je vous prie d'en proposer une meilleure si vous en avez ).

Merci, et bon développement.

M.Dlb · 23/11/2012, 10h02

Ton code est un peu "alambiqué", on comprend pas tout du premier coup d'oeil. Pourtant si tu exprimes la liste des actions à effectuer en français, le problème parait plus simple...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
Parcourir tous les nombres entre 0 et L
  Pour un nombre n
    Tester si il existe un diviseur j de n qui donne 0 comme reste (division euclidienne)
    si j existe
      sortir -> n n'est pas premier
    si j n'existe pas
      afficher n car premier
  Passer au n suivant
fin

Petit conseil, indente ton code de manière régulière, c'est beaucoup plus facile à lire ensuite.

Naindev · 23/11/2012, 17h09

Quel que soit L, 1 et 2 sont des nombres premiers. je commence donc par les afficher. Ensuite, j'affecte à n ( qui est un des nombres entiers compris entre 0 et L ) la valeur 3. Tant que n est inférieur à L ( 100 dans mon test ), je réinitialise la variable j ( potentiel diviseur de n ) à 2.

Après, je répète n mod j. Si n mod j est différent de 0, j n'est donc pas un diviseur de n, on passe au j suivant ( j:= j+1 ). Quand n=j, n est donc premier ( aucun des nombres compris en 1 et n ne divise n ), on sort de la boucle répéter mais on reste dans tant que ( car n inférieur à 100 ) et on affiche n.

Si n mod j est 0, on passe directement au n suivant et on réinitialise j à 2. n sera sûrement supérieur à j car sa valeur initiale est 3, donc on reste dans la boucle répéter.

Voici l'explication littéraire de mon programme.

Concernant mon souci, j'ai trouvé la solution ( très évidente, au fait ). Voici le nouveau code ( la ligne rajoutée est la 34 ) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
uses crt;
 
var n,j:integer;
 
begin
  clrscr;
  writeln(' Les nombres premiers compris entre 1 et 100 sont :');
  writeln('1');
  writeln('2');
 
  n:=3;
while (n<100) do 
        begin
 
            j:=2;
 
            repeat 
               begin
                   if (n mod j <> 0) then
                      j:=j+1
                   else
 
                       begin
                           if n<100 then
                               begin
                                   n:=n+1;
                                   j:=2;
                               end;
                        end;
               end;
 
            until (n=j);
 
           if (n<=100) then
              writeln(n);
 
            n:=n+1;
 
        end;
 
readln;
 
end.

Vu que j'ai résolu mon souci, et que je pense avoir amélioré l'indentation de mon code, j'aimerais que vous me donneriez et vos avis et vos potentielles meilleures solutions.

Merci.

droggo · 23/11/2012, 17h38

Hia,

Citation:

Envoyé par Naindev

Quel que soit L, 1 et 2 sont des nombres premiers.

Erreur, 1 n'est pas un nombre premier.

Car, contrairement à la définition populaire "un nombre premier n'est divisible que par 1 et lui-même", qui est fausse, la définition réelle est

un nombre premier a 2 diviseurs, et 2 seulement. (Pour les matheux : on ne parle ici que des premiers dans les entiers naturels, ne venez pas perturber avec des définitions que le commun des mortels ne comprendra pas.

).

Ainsi :

1 a un seul diviseur (1) ==> pas premier
2 a 2 diviseurs (1, 2) ==> premier
3 a 2 diviseurs (1, 3) ==> premier
4 a 3 diviseurs (1, 2, 4) ==> pas premier
...

Naindev · 23/11/2012, 17h50

En effet, il n'est question que des nombres premiers dans les entiers naturels. De quelle(s) autre(s) définition(s) veux-tu parler ?

Sinon, il est vrai que 1 n'est pas premier. Je l'enlève.

En attente d'autres avis...

Roland Chastain · 23/11/2012, 23h07

Moi aussi je trouve ton code un peu difficile à comprendre (étant donnée la simplicité de l'algorithme).

Pour parcourir la série des nombres à étudier, il serait plus naturel d'utiliser for que while.

Une autre suggestion que je ferais, c'est de séparer les deux parties du programmes : la fonction qui établit si un nombre est premier ou pas, et la procédure qui fait appel à cette fonction pour telle série de nombres.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
program NombresPremiers;
 
function Premier(const n: integer): boolean;
var
  d: integer;
begin
  Premier := true;
  for d := 2 to n - 1 do
    if n mod d = 0 then
    begin
      Premier := false;
      Exit;
    end;
end;
 
var
  i: integer;
 
begin
  for i := 2 to 100 do
    if Premier(i) then
      WriteLn(i);
 
  ReadLn;
end.

Naindev · 24/11/2012, 16h57

J'ai utilisé dans mon premier test la boucle for. Cependant, en exécutant, c'est une boucle infinie qui affiche tous les nombres premiers entre 0 et 32 767 ( ce nombre étant la limite maximale des nombres Integer ). J'ai relié cet effet à l'incrémentation qui doit être faite au sein de la boucle, n:=n+1 à la ligne 37 ( J'en profite pour poser ma question : est-ce que l'incrémentation de la variable de la boucle for a quelconque effet sur le fonctionnement de cette boucle ? ).

Concernant l'utilisation des fonctions, que ce soit en cours ou seul, je n'ai encore rien appris sur leur utilisation.

Enfin, j'aimerais que vous m'expliquiez où/comment trouvez-vous mon code difficile à comprendre.

Roland Chastain · 25/11/2012, 10h39

Pour tout nombre entier compris entre 0 et 100, on fera telle chose.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
for n := 0 to 100 do
begin
end;

Maintenant, si tu changes la valeur de n au beau milieu de la boucle, c'est sûr que ça ne va plus marcher, mais ça ne prouve pas qu'il faille remplacer for par while.

Si j'ai bien compris, pour obtenir que ton code fonctionne, tu as dû ajouter cette ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (n<=100) then

C'est bien qu'il y a un problème de conception, non ?

Dr.Who · 26/11/2012, 22h39

Si ça t’intéresse, j'avais fait ce programme lors d'un petit concours pour trouver tout les diviseurs d'un nombre entre 1 et 2^32-1 (MAXINT)

Le tout le plus rapidement possible (condition du concours le plus rapide pour trouver les diviseurs de 864864000 (1152))

ici cette routine le fait en 1650 cycles/t>0ms (on avait pas réussi à faire mieux sauf en pur assembleur) et indique, en prime, si le nombre testé était un nombre premier.

donc voici le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
{ GetDivisors requirement ----- START }
procedure IDivMod(const Dividend, Divisor: Longint; var Result, Remainder: Longint); register;
asm
  push ebx;
  mov ebx, edx;
  cdq;
  idiv ebx;
  mov ebx, Remainder;
  mov [ecx],eax;
  mov [ebx],edx;
  pop ebx;
end; 
 
type
  pLongintArray = ^TLongintArray;
  TLongintArray = array[0..3999] of Longint;
  { il n'existe logiquement pas de nombre entier signé 32bits capable de remplir ce tableau
    theoriquement un nombre qui en serait capable devrait être superieur à 2 milliard.
  }
 
{ GetDivisors requirement ----- END }
{ GetDivisors
  Renvois les diviseurs existant pour un nombre donné et precise si ce nombre
  est un nombre premier ou pas.
  parametres :
    Number        [I] longint, le nombre duquel on veut les diviseurs
    pDivisors     [I] pLongintArray, pointeur sur un tableau de type TLongintArray
    DivisorsCount [O] longint, nombre de diviseurs trouvé et stocké dans pDivisors
    AsPrime       [O] boolean, true si Number est un nombre premier sinon false
}
procedure GetDivisors(const Number: Longint; const pDivisors: pLongintArray; out DivisorsCount: Longint; out AsPrime: boolean);
var DivisorA, DivisorB, Modulo : Longint;
begin
  // init
  AsPrime := false;   // puisque les nombres premiers sont plus rare que les autres
  DivisorA := 1;      // le premier "plus petit diviseur" connus de Number
  DivisorB := Number; // le premier "plus grand diviseur" connus de Number
  Modulo := 0;        // tout nombres % 1 = 0
  DivisorsCount := 0; // aucuns pour l'instant
 
  while DivisorA <= DivisorB do
  { tant que DivisorA inferieur ou egal à DivisorB, cette condition nous permet
    de sortir trés rapidement de la boucle en ne testant que ce qu'il faut pour
    trouver tout les diviseurs de Number.
    * exemple d'iteration avec Number = 10 :
    iterations | diviseurs trouvés | DivisorA | DivisorB | valides | sortie
    1 | 1, 10       | 1 | 10 | oui | non
    2 | 1, 10, 2, 5 | 2 | 5  | oui | non
    3 | 1, 10, 2, 5 | 3 | 3  | non | oui (while a <= B)
    * exemple d'iteration avec Number = 11 (nombre premier) :
    iterations | diviseurs trouvés | DivisorA | DivisorB | valides | sortie
    1 | 1, 11 | 1 | 11 | oui | non
    2 | 1, 11 | 2 | 5  | non | non
    3 | 1, 11 | 3 | 3  | non | oui (while a <= b )
    * exemple d'iteration avec Number = 25 :
    iterations | diviseurs trouvés | DivisorA | DivisorB | valides | sortie
    1 | 1, 25    | 1 | 25 | oui | non
    2 | 1, 25    | 2 | 12 | non | non
    3 | 1, 25    | 3 | 8  | non | non
    4 | 1, 25    | 4 | 6  | non | non
    5 | 1, 25, 5 | 5 | 5  | oui | oui (if a >= b)
  }
  begin
    { modulo = 0 : si on a un diviseur valide sous la mains ...
    }
    if Modulo = 0 then
    begin
      { on stocke DivisorA
      }
      pDivisors^[DivisorsCount] := DivisorA;
      { on incremente le compteur d'entrées, pas de inc pour eviter un call lent et inutile
        le compilo vas directement nous generer une belle incrementation rapide en assembleur :)
        * Comme BruNews a pus me le demontrer, en C ces deux lignes pourrait etre beaucoup plus simple
        si Delphi possedait l'operateur ++ et -- ce qui serait le minimum quand même! (>_<) *
      }
      DivisorsCount := DivisorsCount + 1;
      { test si DivisorA est superieur ou egal à DivisorB, permet la sortie prematurée
        de la boucle pour :
        1) ne pas stocker DivisorB car deja present dans pDivisors (grace aux valeurs
          precedentes de DivisorA)
        2) eviter des appels, calculs et jump conditionnel inutiles puisqu'on sait que si
          on arrive ici il ne nous reste plus qu'à determiner si Number est un nombre premier.
          donc pas besoin d'aller au test DivisorA <= DivisorB, l'un ne peu fonctionner sans
          l'autre pour garder des performances irreprochable dans tout les cas de figure.
      }
      if DivisorA >= DivisorB then
        Break;
      { Stocke DivisorB puisque apparement il est toujours superieur à DivisorB
      }
      pDivisors^[DivisorsCount] := DivisorB;
      DivisorsCount := DivisorsCount + 1;
    end;
    DivisorA := DivisorA + 1;
 
    { HAHA! une astuce de phoque, on calcul directement la division et le modulo
      grace aux fonctions de l'unité ExtMath!
      ça nous permet de diviser le temps et les cycles pris par la fonction par 2,
      à l'instar de la fonction SinCos dans les calculs de courbes par exemple...
    }
    IDivMod(Number, DivisorA, DivisorB, Modulo);
  end;
 
  { il nous reste plus grand chose à faire pour determiner que Number est un nombre premier
    rappel :
    un nombre premier est un nombre qui ne peut etre divisé que par 1 et par lui même.
    nombre premier de 1 a 100 :
    2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97.
  }
  AsPrime := (DivisorsCount = 2) and ((pDivisors^[0] = 1) and (pDivisors^[1] = Number));
end;

Naindev · 26/11/2012, 22h57

Citation:

Envoyé par Roland Chastain

Si j'ai bien compris, pour obtenir que ton code fonctionne, tu as dû ajouter cette ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (n<=100) then

C'est bien qu'il y a un problème de conception, non ?

Euh... Nan. J'ai pourtant expliqué l'origine de ce souci. Je me cite :

Citation:

En exécutant ce code, je me retrouve avec tous les nombres premiers compris entre 0 et 100 + 101. 97 est le dernier nombre premier compris entre 1 et 100, ensuite viennent 98, 99, 100 qui engendreront l'exécution de la partie en gras. Puis 101 qui est premier, qui fera donc afficher 101 et sortir de la boucle "while" ( 101 étant supérieur à 100 ).

Si tu as une meilleure solution que l'ajout de la condition, je t'écoute.

Concernant for ou while, tu le dis toi-même, l'incrémentation ( obligée ) de la variable qu'utilise le for engendre un dysfonctionnement de la boucle. Comment veux »tu que je l'utilise ?

Dr.Who · 28/11/2012, 19h13

Tiens une version amélioré du code que je t'ai mis plus haut :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
procedure IDivMod(const Dividend, Divisor: Longint; var Result, Remainder: Longint); register;
asm
  push ebx;
  mov ebx, edx;
  cdq;
  idiv ebx;
  mov ebx, Remainder;
  mov [ecx],eax;
  mov [ebx],edx;
  pop ebx;
end; 
 
type
  pLongintArray = ^TLongintArray;
  TLongintArray = array[0..3999] of Longint;
 
function GetDivisors(const Number: Longint; const pDivisors: pLongintArray; out DivisorsCount: Longint; const OnlyPrime: boolean = false): boolean;
var DivisorA, DivisorB, Modulo : Longint;
    p : pLongintArray;
begin
  Result := false;  
  DivisorA := 1;     
  DivisorB := Number;
  Modulo := 0;       
  DivisorsCount := 0;
  while DivisorA <= DivisorB do
  begin
    if Modulo = 0 then
    begin
      pDivisors^[DivisorsCount] := DivisorA;
      DivisorsCount := DivisorsCount + 1;
      if DivisorA >= DivisorB then
        Break;
      pDivisors^[DivisorsCount] := DivisorB;
      DivisorsCount := DivisorsCount + 1;
      if OnlyPrime and (DivisorsCount >= 3) then
        Break;
    end;
    DivisorA := DivisorA + 1;
    IDivMod(Number, DivisorA, DivisorB, Modulo);
  end;
  Result := (DivisorsCount = 2) and ((pDivisors^[0] = 1) and (pDivisors^[1] = Number));
end;
 
function isPrime(aNumber: integer): boolean;
var LA : TLongintArray;
    DC : integer;
begin
  result := getDivisors(aNumber, @LA, DC, True);
end;

A utiliser comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
for X := 1 to 100 do
  if isPrime(X) then
    writeln(X,' est un nombre premier')
  else
    writeln(X,' est un nombre pas premier du tout, vilain qu''il est !');

J'ai tester avec ce programme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
program Project2;
 
(* ... le code ici ... *)
 
var X: integer;
begin
  writeln('Les nombres premier de 1 à 100 :');
  for X := 1 to 100 do
  begin
    if isPrime(X) then
      write(X,', ');
  end;
 
  writeln('Distribution de 1 a 10000 ( . = nombre premier) :');
  for X := 1 to 10000 do
  begin
    if isPrime(X) then
      write('.')
    else
      write(' ');
  end;
  ReadLn;
end.

qui affiche :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
Les nombres premier de 1 Ó 100 :
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73,
79, 83, 89, 97, Distribution de 1 a 10000 ( . = nombre premier) :
 .. . .   . .   . .   .     . .     .   . .   .     .     . .     .   . .     .
  .     .       .   . .   . .   .             .   .     . .         . .     .
  .   .     .     . .         . .   . .           .           .   . .   .     .
.         .     .     .     . .     .   . .         .             .   . .   .
          .     .         . .   .     .       .     .     .   .     .       .
.       .         . .         . .     .   .     .       .   . .   .           .
      .   .       .   .     .           . .                 .     .         .
  .     . .     .         .     .     . .     .     .   . .           .
. .   .     .     . .           .   .     .       .         .       .         .
      .     .     .   .       .     .   .       .   .             .         .
        . .         . .   . .         .             .   . .   .             .
. .   .                   .   .       .         .       .   .     .     .
      .   .     .     .       .     .           .   .     . .         . .     .
        . .         . .     .                 .   . .   .     .     .       .
  .     .                     . .         .       .         .     .     .
.           .   .     .     . .     .           .         .                 . .
  .     . .     .   . .   .           . .     .
.     .     .       .                 .         .             .   . .   .     .
      .   . .     .           .         . .   . .   .     .           .
  .       .           .     .   .     .       .   .       .   .             .
.     . .   .     . .     .         .                   .     .   . .
            .   . .         .           . .         .       .     .     .     .
                .     .   . .           .         .           .       .
      .             .     .   . .   . .         .           .     .     .
          . .               . .                     .     .       .     .   . .
  .       .     .         . .         .             .         .     .
. .   . .         .           . .               . .     .   . .         .
.                 .                       .   .     .       .               . .
  .       .               . .   .       .     .     .   .           . .
            .     . .     .   .     .             .     .   . .     .   .     .
          .     .     .             .   .     .           .       .     .   .
                      .                 .         .       .   .     . .     .
                  .           . .               .       .   .           .
      .         . .   .       .     .     .   . .   .     .       .   . .     .
        . .         .       .   .             .         .           . .     .
. .               .             .   .     .       .     .   .                 .
      .         .     .     .       .         .           .             .   .
  .     . .                           . .         .       .   .             .
.       .           .     .           .   .     .                   .         .
.               .                         .   . .           .     .   .
  .     .       .   .       .                     . .   . .           .
                  . .     .     .     .   .     . .           .   .           .
.         . .               . .               .     .                   .
        .       .   . .   . .                     .       .           .     .
      . .   .     . .     .         . .           .         . .         .
      .     .   .     .       .     .     .               .           . .   .
          .     .   .       .         .       .     .     .
.     . .         .             .   .     .                 . .         .
      .   . .         .             .   .       .                 .   .     . .
  .     . .           .   .                   .                     .
. .   .     .     . .     .                     . .     .               .     .
          . .     .           .               . .   .     .             .   . .
                .                       .         .     . .         . .
. .         .     . .         . .         .     .       .
      .         . .         .       .     .         .                 .     .
        .           . .                 .     .   .     .     .
. .         .             .     .   . .   .                       . .
.     .               .       .     .     .                 .               . .
  .     . .     .     .         .     .           .           .
. .     .   .                 .       .                       .   . .   .     .
.           .   .             .                             .         .     .
        .             .     .         .           . .   .     .       .     .
      . .   .             .     .     .   .     . .         . .               .
          .       .                 .   .     .           . .     .     .     .
                          .     .             .   .       .         .       .
        .                 .   . .   .                       .           .     .
.               .     .     .             .         .             .   .
                    .     .     .     .       .     .   . .           .     .
. .     .                     .     . .   .                 . .   .           .
.     .   .                         .     .     .   .       .         .
                      .               . .     .   . .   . .         .
  .     .   .       .         .     .                   .   . .     .
                  .   .       .         .     .     .       .     .           .
  .     . .     .   .     . .         . .               .     .
  .   .           .             .                           .     .
      .   .                 .       .     .   .     .             .     .     .
        . .         .           .       .         . .         .       .
  .         .                       . .   .       .     .   .       .
      .         .     .     . .     .         .           . .         .     .
  .     .       .     .         .     . .     .     .     .         .       .
                    .     .                     . .                 .   .
.         .                             .       .                 .   . .
  .     . .     .   .                 .       .           .                 .
            .     . .           .     .         . .         . .     .         .
            .   .                       . .               . .         . .
  .                   .   . .   .       .               .     .     . .
  .               .       .   .     .                             . .         .
.     .   .     .     .       .     .   .           .     .       .           .
  .             .           .         .                       .     .
.     . .                     .       .                 .         .     .
      .   . .     .         .       .     .   .     .
  .             .         . .           .         . .               . .
        .                       .                 .     .               .
          .     . .                 .   .     . .         .       .         .
  .     .       .   .     . .         . .           .   .     .     . .
  .   .             .                 .   .     .                   .   .
.     .   .       .   .             .     .   .             .           .   . .
                            .   .                       .     .     .
.           .             .     .   . .   .                 .     .           .
      .     .   .           . .           .                             .
        . .     .                     .             .     .         .
.     . .   .       .         .     .     .                       .
.     .   .       .           .                 .         . .         . .   .
  .                   .     .   .             .   . .   .             .     .
        .                       .         .     .       .         . .
                  .   .     . .           .   .             .     .
                    .           .       .     .         . .   .
  .         .       .               . .         .             .   . .
.     .               .     .       .   .       .   .     .       .     .     .
          .     .   .     .     .       .                 .   .
  .   .           . .         .     . .         .           . .   .
      .     .                             .     .   .       .         .
  .     . .                           . .     .   . .               .
. .     .         .       .                       .           .     .
      .     .   .             .     .   .           .       .     .           .
  .     .           .     .           . .               .                   .
. .         .                 .       .   .             .   . .     .
          .     .             .     .     .         .     . .         . .   . .
                    . .   .     .     .           .     .             .
.           .     .       .   .                                   .
.           .     .   .     . .           .     .           .               . .
        .       .                     . .           .     .   .     .
      . .           .     .   .           .       .     .           .   .     .
          .     . .           .           .   .             .     .
  .     . .         .       .                 .     .

23/11/2012, 17h50	#5
Naindev Étudiant Inscription : novembre 2012 Messages : 8 Détails du profil Informations personnelles : Sexe : Informations professionnelles : Activité : Étudiant Informations forums : Inscription : novembre 2012 Messages : 8 Points : -1 Points : -1	En effet, il n'est question que des nombres premiers dans les entiers naturels. De quelle(s) autre(s) définition(s) veux-tu parler ? Sinon, il est vrai que 1 n'est pas premier. Je l'enlève. En attente d'autres avis...
	00

24/11/2012, 16h57	#7
Naindev Étudiant Inscription : novembre 2012 Messages : 8 Détails du profil Informations personnelles : Sexe : Informations professionnelles : Activité : Étudiant Informations forums : Inscription : novembre 2012 Messages : 8 Points : -1 Points : -1	J'ai utilisé dans mon premier test la boucle for. Cependant, en exécutant, c'est une boucle infinie qui affiche tous les nombres premiers entre 0 et 32 767 ( ce nombre étant la limite maximale des nombres Integer ). J'ai relié cet effet à l'incrémentation qui doit être faite au sein de la boucle, n:=n+1 à la ligne 37 ( J'en profite pour poser ma question : est-ce que l'incrémentation de la variable de la boucle for a quelconque effet sur le fonctionnement de cette boucle ? ). Concernant l'utilisation des fonctions, que ce soit en cours ou seul, je n'ai encore rien appris sur leur utilisation. Enfin, j'aimerais que vous m'expliquiez où/comment trouvez-vous mon code difficile à comprendre.
	00

Outils de la discussion
Afficher une version imprimable Envoyer un lien vers cette page par email