begin process at 2012 02 10 02:49:23
  Trouver un code source :
 
dans
 
[ Dernières recherches ]
Accueil > 

Code

 > 

Maths & Algorithmes

 > NOMBRES PREMIERS - ERATOSTHENE QUASI ILLIMITÉ

NOMBRES PREMIERS - ERATOSTHENE QUASI ILLIMITÉ


 Information sur la source

Note :
Aucune note
Catégorie :Maths & Algorithmes Classé sous :premiers, eratosthene, iteratif, crible Niveau :Initié Date de création :13/10/2006 Date de mise à jour :13/10/2006 17:28:28 Vu :4 778
Auteur : bzrd

Ecrire un message privé
Commentaire sur cette source (19)
Ajouter un commentaire et/ou une note

 Description

Ce petit programme (80 lignes) affiche tous les nombres premiers.
Paramètre : combien vous en voulez (100 par défaut).
Il est basé sur le fameux crible d'Eratosthène, mais contrairement à l'habitude on ne parcourt le tableau qu'une fois, en
'cochant' les non-premiers au fur et à mesure. Attention, pas de test d'erreur dans ce code !
Le programme est très simple, l'algo aussi (si, si!), mais vous aurez peut-être quand même du mal à suivre ...

A l'origine je voulais le soumettre, après 'amélioration', à un concours ObfuscatedC, mais je n'ai pas le temps !

ps. J'ai fait le même en Piet, pour les amateurs ...

Source

  • /* **************************************************** */
  • /* Erat.C */
  • /* **************************************************** */
  • /* Affichage des N premiers premiers */
  • /* **************************************************** */
  • /* (c) BZRD - 2006 */
  • /* **************************************************** */
  • #include "stdio.h"
  • #include "stdlib.h"
  • #include "memory.h"
  • unsigned long *P;
  • /*
  • // Pour afficher le contenu du buffer, éventuellement (ce qui explique que P soit en globale)
  • void dumpPile(char *msg, int n)
  • {
  • int i;
  • printf("%s -- ", msg);
  • n = 2*n + 4;
  • for (i=n-1; i>=0; i--)
  • printf("%d ", P[i]);
  • printf("\n");
  • }
  • */
  • void main(int argc, char **argv)
  • {
  • unsigned long n = 2;
  • unsigned long a,b,c;
  • unsigned long k, i;
  • unsigned long MAXPILE = 100;
  • if (argc > 1)
  • MAXPILE = atoi(argv[1]);
  • P = (unsigned long *)malloc(2*MAXPILE*sizeof(unsigned long));
  • // Il faut au moins avoir les valeurs 3 et 5 -- premiers premiers impairs
  • P[0] = 3; P[1] = 9;
  • P[2] = 5; P[3] = 10;
  • P[4] = 7; P[5] = 14;
  • printf("Liste des %d premiers nombres premiers\n 2 - 3 - 5 - 7 ", MAXPILE);
  • MAXPILE -= 2;
  • while (n < MAXPILE)
  • {
  • c = P[0];
  • b = P[1];
  • a = b+c;
  • if (a >= P[3])
  • {
  • for (k=1; k<=n; k++)
  • {
  • P[2*(k-1)] = P[2*k];
  • P[2*(k-1)+1] = P[2*k+1];
  • if (a <= P[2*(k+1) + 1])
  • {
  • P[2*k] = c;
  • P[2*k+1] = a;
  • break;
  • }
  • }
  • }
  • i = (b+1) | 1;
  • b = P[1];
  • c = P[2*n+1];
  • for (; i<b; i+=2)
  • {
  • if (i!=c)
  • {
  • n++;
  • P[2*n] = i;
  • P[2*n+1] = 2*i;
  • printf("- %d ", i);
  • }
  • }
  • }
  • } 
/* **************************************************** */
/*                     Erat.C                           */
/* **************************************************** */
/* Affichage des N premiers premiers                    */
/* **************************************************** */
/* (c) BZRD - 2006                                      */
/* **************************************************** */

#include "stdio.h"
#include "stdlib.h"
#include "memory.h"

unsigned long *P;

/*
// Pour afficher le contenu du buffer, éventuellement (ce qui explique que P soit en globale)
void dumpPile(char *msg, int n)
{
   int   i;

   printf("%s -- ", msg);
   n = 2*n + 4;
   for (i=n-1; i>=0; i--)
      printf("%d ", P[i]);
   printf("\n");
}
*/

void main(int argc, char **argv)
{
   unsigned long   n = 2;
   unsigned long   a,b,c;
   unsigned long   k, i;
   unsigned long MAXPILE = 100;

   if (argc > 1)
      MAXPILE = atoi(argv[1]);

   P = (unsigned long *)malloc(2*MAXPILE*sizeof(unsigned long));

   // Il faut au moins avoir les valeurs 3 et 5 -- premiers premiers impairs
   P[0] = 3; P[1] = 9; 
   P[2] = 5; P[3] = 10;
   P[4] = 7; P[5] = 14;

   printf("Liste des %d premiers nombres premiers\n 2 - 3 - 5 - 7 ", MAXPILE);
   
   MAXPILE -= 2;

   while (n < MAXPILE)
   {
      c = P[0];
      b = P[1];
      a = b+c;

      if (a >= P[3])
      {
         for (k=1; k<=n; k++)
         {
            P[2*(k-1)]   = P[2*k];
            P[2*(k-1)+1] = P[2*k+1];
            if (a <= P[2*(k+1) + 1])
            {
               P[2*k] = c;
               P[2*k+1] = a;
               break;
            }
         }
      }
      i = (b+1) | 1;

      b = P[1];
      c = P[2*n+1];
      
      for (; i<b; i+=2)
      {
         if (i!=c)
         {
            n++;
            P[2*n]   = i;
            P[2*n+1] = 2*i;
            printf("- %d ", i);
         }
      }
   }
}

 Conclusion

Si ça interesse quelqu'un j'essaierai de commenter.

Limitation à 2^31 pour les nombres affichés, mais ça dépend de toute façon de votre mémoire : pour afficher les N premiers nombres,
j'alloue un tableau de 2N longs.
Et puis, pour exploser mémoire et capacité de calcul, il vous faudra quand même être patient !

Affichage avec Erat 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 - 101 - 103 - 107 - 109 - 113 - 127 - 131 - 137 - 139 - 149 - 151 - 157 - 163 - 167 - 173 - 179 - 181 - 191 -
193 - 197 - 199 - 211 - 223 - 227 - 229 - 233 - 239 - 241 - 251 - 257 - 263 - 269 - 271 - 277 - 281 - 283 - 293 -
307 - 311 - 313 - 317 - 331 - 337 - 347 - 349 - 353 - 359 - 367 - 373 - 379 - 383 - 389 - 397 - 401 - 409 - 419 -
421 - 431 - 433 - 439 - 443 - 449 - 457 - 461 - 463 - 467 - 479 - 487 - 491 - 499 - 503 - 509 - 521 - 523 - 541


 Historique

13 octobre 2006 17:28:28 :
Modification de mots clés !

 Sources du même auteur

Source avec Zip DEMINEUR : CRÉATION ET SOLUTION
Toutes les sources de bzrd

 Sources de la même categorie

Source avec Zip UN EXAMPLE D'APPLICATION EN CUDA DE L'ALGORITHME DE SCAN POU... par oguzaras
Source avec Zip Source avec une capture CHIFFREMENT DE VIGENERE par lajouad
Source avec Zip Source avec une capture ANALYSE SYNTAXIQUE par lajouad
Source avec Zip Source avec une capture STRUCTURE D'UNE MATRICE PAR LES LISTE LINÉAIRE (NON CONTUGUS... par benzarabel
Source avec Zip Source avec une capture DESSINER UNE ARBRE BINAIRE( MODE CONSOLE): par benzarabel
Toutes les sources de la catégorie Maths & Algorithmes

 Sources en rapport avec celle ci

Source avec Zip Source avec une capture CRIBLE D'ERATOSTHÈNE OPTIMISÉ par pgl10
Source avec Zip FACTORISATION D'UN NOMBRE EN NOMBRE PREMIER par Tearsofdestiny
Source avec Zip Source avec une capture OBTENIR TOUTES LES NOMBRES PREMIERS DANS UNE GRANDE RANGÉE A... par elkasimi2007
Source avec Zip VB/DELPHI/C++ QUEL EST LE MEILLEUR? par zac

Commentaires et avis

Commentaire de nightlord666 le 13/10/2006 18:47:19

Bon j'ai deux ou trois reproches à faire sur l'écriture de ton programme :
- Normalement, les includes standards s'écrivent sous la forme <stdio.h>, et pas "stdio.h" : les "" cherchent dans le répertoire courant de l'application.
- On met uniquement les noms des constantes en majuscule, même si ce n'est pas une obligation, c'est une norme que tout le monde devrait respecter, car ça aide beaucoup dans la lecture d'un programme inconnu.

Ensuite, tu ne vérifie pas les valeurs de retour des fonctions : tu alloue de la mémoire sans vérifier si elle est bien allouée (très risqué dans un programme comme ça), et si elle n'est pas bien allouée, tu t'en fiches, ça provoquera juste une erreur de segmentation...

Encore une autre erreur que j'ai trouvé : quand tu met un nombre en dessous de 6 dans le nombre de nombres premiers à afficher, tu accèdera à la case mémoire P[5], qui sera invalide, et qui provoquera une erreur de segmentation.

Sinon, commente ton programme, car je ne vois pas du tout comment il fonctionne (remarque que j'ai pas non plus beaucoup cherché aussi ;)).

Sinon, le programme marche bien, et il m'a l'air assez rapide.

Commentaire de Kirua le 14/10/2006 12:52:02

Qu'est-ce que tu appelles "quasi illimité" ? La mémoire d'un bon PC va te restreindre assez vite (j'ai déjà obtenu la liste des nb premiers inférieurs à 700 000 000, mais pas bcp plus loin).

Si tu veux obtenir ts les nombres premiers codables sur 32 bits, le plus facile (pas forcément le plus rapide, hmm ^^) est d'utiliser eratosthène jusque la racine carrée de 2^32, soit 2^16 = 65 536: ça ça prend même pas une milliseconde. Ensuite, pour ts les nombres de 2^36 + 1 à 2^32 - 1 tu testes la divisibilité (% = 0) par les nombres premiers ainsi trouvés. Tu passes évidemment les multiples de 2, ça va sans dire, mais il y a moyen de passer encore plus de nombres que ça.

Ça tournera pendant quelques secondes, voire une pleine minute, mais ça marchera je pense (1/3 des nombres impairs étant divisible par 3 (et en continuant le calcul), c'est facile de montrer que dans la plupart des cas, tu ne feras pas plus de 4-5 opérations % sur les nombres testés. Pour les nombres effectivement premiers, tu feras par contre pi(2^16 - 1) opérations, ce qui vaut 6542. Nb: la fonction "pi(n)" renvoie le nombre de nombres premiers inférieurs à n.

Avec cette méthode, la mémoire ne sera pas un problème puisque tu auras simplement à enregistrer (par exemple tout de suite sur le disque) les nombres effectivement premiers.

Bonne continuation, c'est cool les algos pr les nombres premiers ^^.

PS: il y a moyen d'énormément optimiser le crible d'eratosthène; passe un peu de temps à observer quels tests sont inutiles. Par exemple, quand tu "barres" les nombres, comme tu as sûrement déjà barré les nombres pairs à l'avance, c'est pas la peine de les rebarrer.

Commentaire de Bel0 le 15/10/2006 15:42:26

Petite correction sur la fonction mathématique "pi".

Ce n'est pas pi(n) mais phi(n) et elle renvoit les nombres premiers à n et inférieur à n et pas les nombres premiers !

Commentaire de Kirua le 15/10/2006 18:25:56

"la fonction "pi(n)" renvoie le nombre de nombres premiers inférieurs à n"

http://villemin.gerard.free.fr/Wwwgvmm/Premier/quantiPi.htm

je ne crois pas me tromper.

Commentaire de Pole4 le 15/10/2006 21:04:59

phi(n) renvoie le nombre de nombre inférieur à n premier avec n.
Un nombre est premier avec un autre si leur PGCD est 1.
pi(n) renvoie bien le nb de nb premier inférieur à n.

Commentaire de bzrd le 16/10/2006 11:28:16

Pour nightlord666.
D'accord avec toi pour les include, mais comme le compilateur ne fait pas la différence, je mets une fois l'un, une fois l'autre !
En ce qui concerne la variable en majuscules, au départ c'était une constante, mais j'ai décidé d'en faire un paramètre (grosse flemme, quoi !).
Pas de test des codes retours : en fait au départ j'ai écrit ce programme pour le faire marcher en BrainFuck et en Piet (en gros, sur une machine de Turing), donc mettre en place des tests ce n'était pas vraiment facile, et ensuite je voulais le soumttre à un OCC, donc plus c'est court et abscons et mieux c'est. OK, pour ce post, j'aurais dû faire mieux ! D'ailleurs, tu n'as pas remarqué que je ne libère pas non plus la mémoire allouée ;)
Paramètre en dessous de 6 : ça fonctionne ! Mais en dessous de 4, on affiche toujours 4 valeurs au minimum. Par contre ça plante pour 1 (rappel : aucun test !).

pour Kirua.
Je ne "barre" aucune valeur, c'est ce qui fait la spécificité de cet algo.

Dès que j'ai un peu de temps, je mets un petit texte explicatif.

Merci pour vos commentaires.

Commentaire de audranchar le 16/10/2006 22:07:05

D'abord bravo au posteur pour cet algo, mais j'ai juste une question. Quel est le but de cet algo, je veux dire en terme d'application ? Parceque pour trouver de grand nombres premiers et réduire le temps d'execution ne vaut-il pas mieux utiliser le théorème de Fermat ou le test de miller-rabin ,plus approprié ?

Commentaire de Pole4 le 17/10/2006 17:02:58

Oui mais ce code renvoit TOUT les nb premiers <n. Pas si n est premier.
On peut facilement trouver un nombre premier de 1000 chiffres, mais on est loin de savoir combien il y a de nb premiers jusqu'à 10^1000(record : 4*10^22) et encore plus de les connaître tous (record : 10^16).

Commentaire de bzrd le 24/10/2006 17:57:42

Pour AUDRANCHAR : ce code devait me permettre de faire une version du crible pour une machine à pile.
Pour POLE4 : ce code ne renvoie pas tous les premiers<n mais les n premiers.

Je sais que l'explication qui suit n'est pas simple, mais je ne sais pas comment vous le dire autrement !

Exemple de dump pour expliquer le fonctionnement

Premiers :  2 - 3 - 5 - 7
14-7 10-5 9-3                             Pile initiale
14-7 12-3 10-5                            Multiple de 3 suivant, bien placé (9+3 -> 12-3)
15-5 14-7 12-3                            Multiple de 5 suivant, bien placé (10+5 -> 15-5)
Premier : 11                              10+1 < 12 donc 11 premier
                                          (comparaison "10-5" et "12-3")
22-11 15-5 15-3 14-7                      11 mis dans la liste, avec son premier multiple (22)
Premier : 13                              12+1 < 14 donc 13 est premier  ("12-3" et "14-7")
26-13 22-11 21-7 15-5 15-3                13 est mis dans la liste et le multiple de 7 est placé
26-13 22-11 21-7 18-3 15-5                Multiple de 3 suivant, bien placé (15+3 -> 18-3)
26-13 22-11 21-7 20-5 18-3                Multiple de 5 suivant, bien placé (15+5 -> 20-5)
Premier : 17                              15+1 < 18 donc 17 est premier (impair suivant 15+1=16)
34-17 26-13 22-11 21-7 21-3 20-5          17 est mis dans la liste
Premier : 19                              18+1 < 20 donc 19 est premier
38-19 34-17 26-13 25-5 22-11 21-7 21-3    Multiple de 5 suivant, bien placé (20+5 -> 25-5)
38-19 34-17 26-13 25-5 24-3 22-11 21-7    ...

Une fois qu'on a supprimé tous les pairs, on prend la première valeur non barrée : 3 et on regarde ses multiples.
2*3 = 6 ! On a sauté au-dessus de 5 (impair), donc 5 est premier. On regarde les multiples de 5. 2*5=10.
Entre 5 et 9 (prochain multiple de 3), on a 7, qui est donc premier.
On reprend 3, puisqu'on est arrivé à 9, pour calculer 9+3=12. Entre 10 (dernier multiple de 5 trouvé) et 12, on a un impair : 11. Donc il est premier. etc.

En ligne 52, 'c' contient le premier en cours de traitement, 'b' son dernier multiple calculé et 'a' le multiple suivant.

En ligne 56, on regarde si ce nouveau multiple est plus grand que le dernier multiple calculé du nombre premier suivant dans la liste ! (facile !)

Si oui, on insère la paire (multiple premier) = (a c) à sa place dans la liste (décalage paire par paire, qui aurait pu être un décalage de bloc, mais pas dans un contexte de machine à pile).

En ligne 70, on trouve le nombre impair suivant 'b' : ex : si 'b'=10, alors (('b'+1) | 1) = (11 | 1) = 11; si 'b'=19, alors (('b'+1) | 1) = (20 | 1) = 21.

En ligne 72, 'b' est le dernier multiple calculé du nombre premier qu'on traitera ensuite, et 'c' est le multiple du dernier de la liste (a priori la plus grande valeur trouvée jusque là).

La boucle en ligne 75, énumère les nombres impairs entre le nombre impair suivant calculé précédemment et 'b', les ajoute à la liste (avec leur premier multiple : 2x) et affiche les nombres trouvés.
A priori la boucle doit ête inutile car il me semble qu'on ne peut trouver qu'un nombre à la fois, mais dans le doute ...

Voilà, vous savez tout !
ps. mon avatar, s'il veut bien s'afficher) est la version Piet de ce programme (cf http://www.dangermouse.net/esoteric/piet.html)

Commentaire de _michel le 27/10/2006 22:19:20

Moi, j'ai essayé avec "prem 100", a ramé pendant 1 minute pour ne m'afficher que les nombres premiers jusqué 13.
Ensuite, je l'ai fermé.
Est-ce normal?
Sinon, si ca t'interesse, moi aussi j'ai fait un générateur de nombre peremier (pas trop mal, j'en suis fier, mais on m'a donné des conseils pour l'optimisation).

Commentaire de Kirua le 27/10/2006 23:18:04

C'est pas un crible alors :)

Commentaire de bzrd le 28/10/2006 15:42:31

Pour KIRUA. Si c'est un crible quand même ! C'est vraiment le même algorithme à la base : on élimine les multiples des nombres premiers trouvés. Simplement au lieu de barrer tous les multiples d'un nombre dans une boucle, on le fait pour tous au fur et à mesure.

_MICHEL : ce n'est pas normal : Sur mon PIV, 2.4Ghz, un "prem 1000" dure moins d'une seconde. Faute de frappe ?

Commentaire de _michel le 28/10/2006 18:19:28

Il est du devoir du développeur de prendre en compte toutes les erreurs de l'utilisateur.
lol
Non, sans blague, j'ai executé ton programme sans argument, et même comme ça il fonctionne pas.
C'est peut-être à cause du compilateur.

Commentaire de bzrd le 30/10/2006 12:27:04

Pour _MICHEL : je ne fais que ça depuis bientôt 20 ans ! :(
J'ai repris le source fourni tel quel et je l'ai recompilé : no problem !
Essaie de supprimer les optimisations dans les options de compilation (/Od pour µSoft Visual C++).
En général les optimisations créent plus de problèmes que ça n'en résout !
En ligne 40 tu peux aussi ajouter :
   if (!P)
   {
   printf("Impossible d'allouer %d octets.\n", 2*MAXPILE*sizeof(unsigned long));
   return;
   }
pour le cas où l'allocation aurait raté !
Sinon, tu n'as plus qu'à mettre des "printf", pour voir où tu bloques ...
Tu peux aussi mettre la fonction suivante (modifiée par rapport au source fourni)
void dumpPile(int n)
{
   int i;

   n = 2*n ;
   for (i=n+1; i>=0; i-=2)
printf("%d:%d ", gP[i], gP[i-1]);       /* +grd multiple trouvé : premier */
   printf("\n");
}
et insérer un "dumpPile(n);" avant la ligne 52.
Pour Erat 10, tu dois obtenir :

Liste des 10 premiers nombres premiers
2 - 3 - 5 - 7 14:7 10:5 9:3
14:7 12:3 10:5
- 11 22:11 15:5 14:7 12:3
- 13 26:13 22:11 15:5 15:3 14:7
26:13 22:11 21:7 15:5 15:3
26:13 22:11 21:7 18:3 15:5
- 17 34:17 26:13 22:11 21:7 20:5 18:3
- 19 38:19 34:17 26:13 22:11 21:7 21:3 20:5
38:19 34:17 26:13 25:5 22:11 21:7 21:3
38:19 34:17 26:13 25:5 24:3 22:11 21:7
38:19 34:17 28:7 26:13 25:5 24:3 22:11
- 23 46:23 38:19 34:17 33:11 28:7 26:13 25:5 24:3
46:23 38:19 34:17 33:11 28:7 27:3 26:13 25:5
46:23 38:19 34:17 33:11 30:5 28:7 27:3 26:13
46:23 39:13 38:19 34:17 33:11 30:5 28:7 27:3
46:23 39:13 38:19 34:17 33:11 30:5 30:3 28:7
- 29

Commentaire de _michel le 30/10/2006 13:45:34

Oui, alors en fait, ça m'a l'air d'être un truc de dingue :
J'ai essayé plusieurs fois (avec 100 ou sans argument c'est la même chose), et les résultats sont variables!!!
Un coup il le fait instantanément, je réessaye et la il plante.
Curieux, non?
En tout cas moi j'ai jamais vu ça.
D'autant plus que de la part d'un programme de 80 lignes, c'est étonnant.

Enfin bref, j'ai vérifié l'allocation : nickel.
Je vais voir ça plus précisement, parce que ça m'intrigue.

Pour l'instant, je pense qu'il y a un P[x] non alloué quelque part, et des fois ça pose pas de souci, des fois si.

PS : J'ai essayé avec deux compilateurs (bcc55 et dev-cpp), a priori mêmes résultats.

Commentaire de bzrd le 31/10/2006 12:01:24

_MICHEL : Mets "P = (unsigned long *)malloc((2+2*MAXPILE)*sizeof(unsigned long));" pour l'allocation !
On pourrait avoir un plantage en ligne 62! :((
Je n'ai jamais rencontré ce problème, mais quand n=MAXPILE-1 , on y calcule P[2*MAXPILE+1] et ça fait un peu trop dans la mesure où on alloué 2*MAXPILE ...

Quand même curieux que je n'aie jamais rencontré ce cas !!

Commentaire de _michel le 01/11/2006 12:06:13

Non, décidement ça ne change rien, c'est très curieux.
Je vais essayer de chercher la faille, si je trouve le temps et la motivation (quel plaisir, la chasse aux bugs...).
En tout cas, j'espère que ce n'est pas mon PC, je l'ai depuis à peine trois mois !
En attendant de trouver le problème, bonne programmation.

Commentaire de bzrd le 03/11/2006 16:42:43

_MICHEL : Une idée, comme ça : en ligne 45, ajoute P[6]=P{7]=(unsigned long)0xffffffff;
Il faudrait aussi vérifier que Maxpile > 4 (à toi de voir ...)

Commentaire de _michel le 06/11/2006 09:08:16

Ah ben voila, maitenant ca marche beaucoup mieux.
Enfin je préfère le bon vieux crible, il me semble quand même plus performant (la preuve : l'algorythme le plus (ou peut être un des plus) puissant est basé sur le crible lui-même (crible d'Atkin)).

 Ajouter un commentaire


Discussions en rapport avec ce code source dans le forum

crible d'eratosthene [ par youzbachi3amal ] bonjour,jé un tp ki me géne:il porte sur la determination dé nbr premié plu peti k'un nbr n doné,s'apuian sur le crible d'eratosthene,en utilisant obl une aide pour écrire un algo et un prog sur le nbr premiers [ par Julius Caesar ] Bonjour, je n'arrive pas écrire l'algo et le prog de ce sujet:"Ecrivez un algo et un prog, qui affiche les nbrs premiers inferieurs à un entier n (ave Supprimer les n premiers octet d'un fichier [ par arc59 ] Bonjour, dans mon programme de modification des ID 3 tag, je voudrai permettre à l'utilisateur de supprimer les Id3tag de version 2. Ces tag sont plac Découpage de n premiers caractères d'une chaine [ par Guidelor ] BonjourJ'ai une chaine1 ="aaaaaaaaa123456"J'aimerais enlever "aaaaaaaaa"comment faire sachant que ce que je ve enlever est situé entre le 1er et le 10 Mes premiers pas sous linux sniff je suis ému [ par asmanur ] Alors voila je me suis mis à la prog sous linux et j'ai quelqes prob & questions - quand je tape g++ main.cpp il me met qu'il ne conait pas g++ -quan Premiers pas avec visual c++ express edition... [ par gdpasmini ] Hello ! je débute avec visual c++ express edition, ma question va peut etre sembler stupide. J'ai créé un nouveau projet "windows form application". Nombres premiers en C Urgent [ par maxfrancky ] il me faut réaliser un programme permettant de lister les n premier nombres premier n utilisnat une liste chainée de structure contenant le nombre pre factorial factors [ par brahimhakkou ] svp aidez moi c urgentin this problem we want to determine the maximum number of integer terms (excluding1) that can be used to express n! par exemple affichage 3 premiers caractere [ par OTHKREEN ] <td id="HB_Focus_Element" valign="top" width="100%" b Probleme de tri [ par bebeesther ] Si tu peux m'aider, je serai tres reconnaissant!!!!!!!!Merci d'avance.


Nos sponsors


Sondage...

Comparez les prix


Archos 5 Internet Tablette 500 Go
Entre 396€ et 444€

Visiter le guide achat

CalendriCode

Février 2012
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
272829    

Consulter la suite du CalendriCode
 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 3,994 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales
Outils Convertisseur VB/C# Snippets et scripts Outils en ligne La ToolBox
Communauté Programmation Photographie Technologie Newsgroups Emploi Forum Blogs
Guide d'achat Téléphonie mobile Image et son Informatique Bureautique Jeux vidéo
Logiciels Internet & Réseau Développement Market Android Jeux & Loisirs Graphisme Multimédia Sécurité Pilotes
Loisirs Cartes virtuelles Vidéos droles Jeux en ligne Géoguide AndroLib (Android Market)