Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 11 sur 11
  1. #1

    Homme Profil pro
    Étudiant
    Inscrit en
    novembre 2012
    Messages
    8
    Détails du profil
    Informations personnelles :
    Sexe : Homme

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : novembre 2012
    Messages : 8
    Points : -1
    Points
    -1

    Par défaut Affichage de nombres premiers

    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 :

    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 :
    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 :
    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.

  2. #2
    Rédacteur/Modérateur
    Avatar de M.Dlb
    Inscrit en
    avril 2002
    Messages
    2 340
    Détails du profil
    Informations personnelles :
    Âge : 29

    Informations forums :
    Inscription : avril 2002
    Messages : 2 340
    Points : 3 833
    Points
    3 833

    Par défaut

    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 :
    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.
    M.Dlb - Modérateur z/OS - Rédacteur et Modérateur Pascal

  3. #3

    Homme Profil pro
    Étudiant
    Inscrit en
    novembre 2012
    Messages
    8
    Détails du profil
    Informations personnelles :
    Sexe : Homme

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : novembre 2012
    Messages : 8
    Points : -1
    Points
    -1

    Par défaut

    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 :
    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.

  4. #4
    Expert Confirmé Sénior
    Inscrit en
    août 2006
    Messages
    3 561
    Détails du profil
    Informations forums :
    Inscription : août 2006
    Messages : 3 561
    Points : 4 569
    Points
    4 569

    Par défaut

    Hia,
    Citation Envoyé par Naindev Voir le message
    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
    ...

    Il court en ce moment une espèce de grippe, mais elle ne court pas très vite, car on peut l'attraper sans courir.

  5. #5

    Homme Profil pro
    Étudiant
    Inscrit en
    novembre 2012
    Messages
    8
    Détails du profil
    Informations personnelles :
    Sexe : Homme

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : novembre 2012
    Messages : 8
    Points : -1
    Points
    -1

    Par défaut

    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...

  6. #6
    Rédacteur/Modérateur
    Avatar de Roland Chastain
    Homme Profil pro Roland Chastain
    Inscrit en
    décembre 2011
    Messages
    1 374
    Détails du profil
    Informations personnelles :
    Nom : Homme Roland Chastain
    Âge : 41
    Localisation : France, Moselle (Lorraine)

    Informations forums :
    Inscription : décembre 2011
    Messages : 1 374
    Points : 3 762
    Points
    3 762

    Par défaut

    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 :
    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.
    L'Art est long et le Temps est court.

  7. #7

    Homme Profil pro
    Étudiant
    Inscrit en
    novembre 2012
    Messages
    8
    Détails du profil
    Informations personnelles :
    Sexe : Homme

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : novembre 2012
    Messages : 8
    Points : -1
    Points
    -1

    Par défaut

    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.

  8. #8
    Rédacteur/Modérateur
    Avatar de Roland Chastain
    Homme Profil pro Roland Chastain
    Inscrit en
    décembre 2011
    Messages
    1 374
    Détails du profil
    Informations personnelles :
    Nom : Homme Roland Chastain
    Âge : 41
    Localisation : France, Moselle (Lorraine)

    Informations forums :
    Inscription : décembre 2011
    Messages : 1 374
    Points : 3 762
    Points
    3 762

    Par défaut

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

    Code :
    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 :

    C'est bien qu'il y a un problème de conception, non ?
    L'Art est long et le Temps est court.

  9. #9
    Membre Expert Avatar de Dr.Who
    Inscrit en
    septembre 2009
    Messages
    980
    Détails du profil
    Informations personnelles :
    Âge : 35

    Informations forums :
    Inscription : septembre 2009
    Messages : 980
    Points : 1 299
    Points
    1 299

    Par défaut

    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 :
    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;
    [ Sources et programmes de Dr.Who | FAQ Delphi | FAQ Pascal | Règlement | Contactez l'équipe ]
    Ma messagerie n'est pas la succursale du forum... merci!

  10. #10

    Homme Profil pro
    Étudiant
    Inscrit en
    novembre 2012
    Messages
    8
    Détails du profil
    Informations personnelles :
    Sexe : Homme

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : novembre 2012
    Messages : 8
    Points : -1
    Points
    -1

    Par défaut

    Citation Envoyé par Roland Chastain Voir le message
    Si j'ai bien compris, pour obtenir que ton code fonctionne, tu as dû ajouter cette ligne :

    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 :
    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 ?

  11. #11
    Membre Expert Avatar de Dr.Who
    Inscrit en
    septembre 2009
    Messages
    980
    Détails du profil
    Informations personnelles :
    Âge : 35

    Informations forums :
    Inscription : septembre 2009
    Messages : 980
    Points : 1 299
    Points
    1 299

    Par défaut

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

    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
    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 :
    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 :
    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 :
    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) :
     .. . .   . .   . .   .     . .     .   . .   .     .     . .     .   . .     .
      .     .       .   . .   . .   .             .   .     . .         . .     .
      .   .     .     . .         . .   . .           .           .   . .   .     .
    .         .     .     .     . .     .   . .         .             .   . .   .
              .     .         . .   .     .       .     .     .   .     .       .
    .       .         . .         . .     .   .     .       .   . .   .           .
          .   .       .   .     .           . .                 .     .         .
      .     . .     .         .     .     . .     .     .   . .           .
    . .   .     .     . .           .   .     .       .         .       .         .
          .     .     .   .       .     .   .       .   .             .         .
            . .         . .   . .         .             .   . .   .             .
    . .   .                   .   .       .         .       .   .     .     .
          .   .     .     .       .     .           .   .     . .         . .     .
            . .         . .     .                 .   . .   .     .     .       .
      .     .                     . .         .       .         .     .     .
    .           .   .     .     . .     .           .         .                 . .
      .     . .     .   . .   .           . .     .
    .     .     .       .                 .         .             .   . .   .     .
          .   . .     .           .         . .   . .   .     .           .
      .       .           .     .   .     .       .   .       .   .             .
    .     . .   .     . .     .         .                   .     .   . .
                .   . .         .           . .         .       .     .     .     .
                    .     .   . .           .         .           .       .
          .             .     .   . .   . .         .           .     .     .
              . .               . .                     .     .       .     .   . .
      .       .     .         . .         .             .         .     .
    . .   . .         .           . .               . .     .   . .         .
    .                 .                       .   .     .       .               . .
      .       .               . .   .       .     .     .   .           . .
                .     . .     .   .     .             .     .   . .     .   .     .
              .     .     .             .   .     .           .       .     .   .
                          .                 .         .       .   .     . .     .
                      .           . .               .       .   .           .
          .         . .   .       .     .     .   . .   .     .       .   . .     .
            . .         .       .   .             .         .           . .     .
    . .               .             .   .     .       .     .   .                 .
          .         .     .     .       .         .           .             .   .
      .     . .                           . .         .       .   .             .
    .       .           .     .           .   .     .                   .         .
    .               .                         .   . .           .     .   .
      .     .       .   .       .                     . .   . .           .
                      . .     .     .     .   .     . .           .   .           .
    .         . .               . .               .     .                   .
            .       .   . .   . .                     .       .           .     .
          . .   .     . .     .         . .           .         . .         .
          .     .   .     .       .     .     .               .           . .   .
              .     .   .       .         .       .     .     .
    .     . .         .             .   .     .                 . .         .
          .   . .         .             .   .       .                 .   .     . .
      .     . .           .   .                   .                     .
    . .   .     .     . .     .                     . .     .               .     .
              . .     .           .               . .   .     .             .   . .
                    .                       .         .     . .         . .
    . .         .     . .         . .         .     .       .
          .         . .         .       .     .         .                 .     .
            .           . .                 .     .   .     .     .
    . .         .             .     .   . .   .                       . .
    .     .               .       .     .     .                 .               . .
      .     . .     .     .         .     .           .           .
    . .     .   .                 .       .                       .   . .   .     .
    .           .   .             .                             .         .     .
            .             .     .         .           . .   .     .       .     .
          . .   .             .     .     .   .     . .         . .               .
              .       .                 .   .     .           . .     .     .     .
                              .     .             .   .       .         .       .
            .                 .   . .   .                       .           .     .
    .               .     .     .             .         .             .   .
                        .     .     .     .       .     .   . .           .     .
    . .     .                     .     . .   .                 . .   .           .
    .     .   .                         .     .     .   .       .         .
                          .               . .     .   . .   . .         .
      .     .   .       .         .     .                   .   . .     .
                      .   .       .         .     .     .       .     .           .
      .     . .     .   .     . .         . .               .     .
      .   .           .             .                           .     .
          .   .                 .       .     .   .     .             .     .     .
            . .         .           .       .         . .         .       .
      .         .                       . .   .       .     .   .       .
          .         .     .     . .     .         .           . .         .     .
      .     .       .     .         .     . .     .     .     .         .       .
                        .     .                     . .                 .   .
    .         .                             .       .                 .   . .
      .     . .     .   .                 .       .           .                 .
                .     . .           .     .         . .         . .     .         .
                .   .                       . .               . .         . .
      .                   .   . .   .       .               .     .     . .
      .               .       .   .     .                             . .         .
    .     .   .     .     .       .     .   .           .     .       .           .
      .             .           .         .                       .     .
    .     . .                     .       .                 .         .     .
          .   . .     .         .       .     .   .     .
      .             .         . .           .         . .               . .
            .                       .                 .     .               .
              .     . .                 .   .     . .         .       .         .
      .     .       .   .     . .         . .           .   .     .     . .
      .   .             .                 .   .     .                   .   .
    .     .   .       .   .             .     .   .             .           .   . .
                                .   .                       .     .     .
    .           .             .     .   . .   .                 .     .           .
          .     .   .           . .           .                             .
            . .     .                     .             .     .         .
    .     . .   .       .         .     .     .                       .
    .     .   .       .           .                 .         . .         . .   .
      .                   .     .   .             .   . .   .             .     .
            .                       .         .     .       .         . .
                      .   .     . .           .   .             .     .
                        .           .       .     .         . .   .
      .         .       .               . .         .             .   . .
    .     .               .     .       .   .       .   .     .       .     .     .
              .     .   .     .     .       .                 .   .
      .   .           . .         .     . .         .           . .   .
          .     .                             .     .   .       .         .
      .     . .                           . .     .   . .               .
    . .     .         .       .                       .           .     .
          .     .   .             .     .   .           .       .     .           .
      .     .           .     .           . .               .                   .
    . .         .                 .       .   .             .   . .     .
              .     .             .     .     .         .     . .         . .   . .
                        . .   .     .     .           .     .             .
    .           .     .       .   .                                   .
    .           .     .   .     . .           .     .           .               . .
            .       .                     . .           .     .   .     .
          . .           .     .   .           .       .     .           .   .     .
              .     . .           .           .   .             .     .
      .     . .         .       .                 .     .
    [ Sources et programmes de Dr.Who | FAQ Delphi | FAQ Pascal | Règlement | Contactez l'équipe ]
    Ma messagerie n'est pas la succursale du forum... merci!

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •