Discussion :

[fred61]

Bonjour,

Je voudrais faire un programme qui affiche les nombres premiers et leurs inverses. J'ai déjà la fonction qui permet de calculer si un nombre est premiers ou non mais je ne sais pas comment m'y prendre pour afficher correctement l'inverse.
Car certain nombre nombres obtenus auront des développements décimaux périodique de plusieurs dizaine de chiffres, voir plus, et ce qui m’intéresse justement c'est d'afficher ces développement décimaux.

Comment est ce que vous vous y prendriez ?

Merci.

[Mipwiq]

Si tu veux avoir l'inverse d'un nombre avec une bonne précision tu peux utiliser le type double.

exemple:

Code :

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

1
2
3
4
5
6
7
void afficheInverse(int nombrePremier)
{
  double resultat;
 
 resultat = 1.0 / nombrePremier;
 printf("%f\n", resultat); // le flag %f de printf permet d'afficher des nombre a virgule flotante
}

Si tu ne comprends pas quelque chose hésite pas à le faire savoir.

[fred61]

J'ai essayé comme ça mais le résultat ne me convient pas, par exemple si je fais :
1/43 => 0.023255813953488372000000000000

alors que j'aimerai un résultat du genre de la calculatrice de windows :

1/43 => 0,0232558139534883720932325581395

[edgarjacobs]

Hello,

Si cette précision ne te suffit pas, tu vas devoir passer par une bibliothèque spécialisée, telle que gmp par exemple (que je n'ai jamais utilisé), a moins que l'api windows propose des fonctions mathématiques spécialisées....

[fred61]

Ok merci je vais étudier ça.

[Obsidian]

Sans aller jusqu'à GMP, si tu souhaites obtenir avec une précision arbitraire le résultat en décimal d'un nombre rationnel, donc le quotient de deux nombres entiers, il te suffit d'appliquer le même algorithme que lorsque tu effectues une division sur papier, à savoir effectuer le quotient du poids le plus fort, soustraire le résultat puis descendre la tranche suivante, en décalant en fait la différence vers la gauche en la multipliant par dix :

Code C :

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
/*  Division décimale de nombres rationnels.  */
/* Obsidian pour Developpez.net - 5 sept 2013 */
 
#include <stdio.h>
 
int main (void)
{
    /* a doit toujours être inférieur à 10×b */
 
    long int a=1, b=2; /* a : numérateur ; b : dénominateur */
    long int q=0, r=0; /* q : quotient ;   r : reste        */
 
    unsigned int count = 30; /* Précision */
 
    do
    {
        q=a/b;
        r=a%b;
 
        putchar ('0'+q);
        a=(a-q*b)*10;
    }
    while (count-->0 && r!=0);
 
    return 0;
}

L'avantage ici est que a reste toujours inférieur à b, et en plein milieu de son domaine de définition. On peut donc faire itérer la boucle indéfiniment sans divergence. (ânerie)

[fred61]

oui c'est vrai c'est une bonne solution, je vais essayer comme ça.
Merci.

[fred61]

Merci Obsidian, j'ai adapté ton code à mon programme et ça fonctionne très bien. J'aurai une autre question, au lieu d'afficher le résultat je l'ai stocké dans un tableau, et j'aimerai n'afficher que les développements décimaux périodique, par exemple pour 1/7 afficher que la partie en rouge:

0,142857 142857

Il faudrait parcourir le tableau et repérer à quel moment les chiffres se répètent mais ça ne me parait pas facile, j'ai plusieurs idées mais aucunes ne répond à toutes les situations, en plus c'est assez brouillon je trouve.

Est-ce que vous avez des idées ?

Merci.

[Obsidian]

Merci Obsidian, j'ai adapté ton code à mon programme et ça fonctionne très bien.

Au fait, petite inattention de ma part : à la ligne 21, « a-q*b » est la définition même du reste r. Tu peux donc remplacer cette ligne par a = r*10;.

C'est dû au fait qu'initialement, j'essayais de ne pas calculer le reste inutilement en plus du quotient (même si, de toutes façons, l'un et l'autre sont produits simultanément par la même opération et que le compilo saura en tirer parti) et que j'ai changé d'avis pour pouvoir stopper la boucle en cas de reste nul, donc de calcul exact.

J'aurai une autre question, au lieu d'afficher le résultat je l'ai stocké dans un tableau, et j'aimerai n'afficher que les développements décimaux périodique, par exemple pour 1/7 afficher que la partie en rouge: […] Il faudrait parcourir le tableau et repérer à quel moment les chiffres se répètent mais ça ne me parait pas facile, j'ai plusieurs idées mais aucunes ne répond à toutes les situations, en plus c'est assez brouillon je trouve.

Oui, c'est effectivement ce que tu nous as exposé dans ton premier post.

Il suffit de faire preuve de bon sens mathématique pour essayer de comprendre à quel moment une séquence peut commencer à se répéter. Dans notre boucle, b reste inchangé tout au long du processus, ce qui simplifie considérablement notre tâche. Dès lors, tu sais que ta séquence va se répéter lorsque a retrouvera une valeur par laquelle il est déjà passé. Si c'est le cas, alors « a ÷ b » donnera forcément le même résultat que la fois précédente, tout comme les résultats suivants par récurrence.

L'idéal dans un premier temps consisterait à former une liste chaînée dans laquelle tu insérerais la valeur de a à chaque tour de boucle, mais après quelques essais, il semble que l'on n'obtienne jamais plus de « b+1 » valeurs de a différentes même si, en elles-mêmes, ces valeurs peuvent largement excéder celle de b.

J'ai la flemme d'essayer de démontrer maintenant que c'est vrai mais si c'est le cas, tu peux donc directement créer un tableau d'entiers de b+1 entrées, avec les VLA par exemple et si b reste raisonnable (pour ne pas faire sauter la pile), ou avec malloc(). Tu initialises ce tableau à zéro au départ, tu l'indexes avec la valeur de a à chaque tour et tu déposes dans la cellule correspondante la valeur de count. Mais juste avant de le faire, tu vérifies que cette cellule est bien nulle. Si ce n'est pas le cas, non seulement tu sais que tu viens d'atteindre la fin d'une séquence qui va désormais recommencer, mais la valeur de la cellule te dit à quel endroit elle commence ! :-)

Et comme il ne peut y avoir, jusque là, plus de caractères que de valeurs différentes de a, tu peux également déclarer un tableau de b+1 caractères également et y déposer tous ceux que j'écris actuellement avec putchar() pour pouvoir les retrouver facilement ensuite, voire même les imprimer directement à l'écran avec un printf ("%*s",ptr) bien construit.

[fred61]

ça fonctionne très bien Obsidian, j'étais parti sur quelque chose de compliqué mais comme je le pensais il y a une solution très simple.
Encore merci.

[Obsidian]

ça fonctionne très bien Obsidian, j'étais parti sur quelque chose de compliqué mais comme je le pensais il y a une solution très simple.
Encore merci.

Dans ce cas, n'oublie pas en bas de page.
À bientôt.