Neuf-9 : une démonstration amusante avec GMP

Soyez le premier à donner votre avis sur cette source.

Vue 2 136 fois - Téléchargée 218 fois

Description

Neuf-9 est une petite démonstration amusante faite avec GMP en variante de Paul Herman. On part de l'observation très simple que 19, 199 et 1999 sont des nombres premiers. On trouve assez facilement que 139, 1399, 13999, 139999 et 1399999 sont aussi des nombres premiers. D'où l'idée de chercher le plus petit nombre qui donne consécutivement 9 nombres premiers quand on lui ajoute à chaque fois le chiffre 9 à la fin. La solution est : 143639306. On a mis ici le source et les compléments de bibliothèque qui sont nécessaires pour faire la compilation. Il y a aussi l'exécutable main.exe et un fichier main.txt qui permet de voir l'affichage obtenu à l'exécution. On voit très bien que les entiers ayant la longueur aussi grande que nécessaire sont aussi simples à utiliser que les entiers natifs de l'ordinateur.

Source :

 
/*************************************************
*  Petite démonstration de GMP -  @author pgl10  *
*                                                *
*     On utilise la variante de Paul Herman      *
*                                                *
* On calcule ici le plus petit nombre qui donne  *
* 9 fois de suite un nombre premier quand on lui *
* ajoute à chaque fois le chiffre 9 à la fin.    *
*                                                *
*          La solution est : 143639306           *
* Les nombres : 1436393069 à 143639306999999999  *
*             sont tous premiers.                *
*************************************************/
#include <iostream>
#include "Integer.h"
#pragma comment(lib, "gmp.lib")  

int main() { 
    int m=0;
    Integer z=Integer(100000)*100000;
    // z = 10^10
    for(Integer x=1; x<z; x++) {
        int n=0;
        Integer p=x;
        do {
            p=p*10+9;
            n=n+1;
        }while(isprime(p));
        // n-1 est le nombre de fois où p est premier
        if(n>m) {
            // à chaque fois que cet x est meilleur
            m=n;
            p=x;
            std::cout << std::endl;
            for(int i=1; i<n; i++) {
                p=p*10+9;
                std::cout << "   i : " << i << "   x : " << x 
                          << "   p : " << p << std::endl;
            }
            if((n-1)==9) return 0;
        }
    }
    return 0;
}

Conclusion :

Vous pouvez calculer aussi le 2-ième plus petit nombre qui donne consécutivement 9 nombres premiers quand on lui ajoute à chaque fois un 9 à la fin. Et les suivants ? Y en a-t-il un nombre fini ou infini ? Et pourquoi pas chercher le plus petit nombre qui en donne 10 ? On peut imaginer d'autres problèmes pour lesquels l'utilisation de nombres entiers de grande longueur est nécessaire. Merci pour vos commentaires et remarques.

Codes Sources

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.