Tu n'as pas le bon algorithme pour ta fonction puissance (en fait tu vas un cran trop loin). Chez moi (ainsi que partout ailleurs), 3^4 donne 81. Mais pas chez toi, ça donne 243.... soit 3^5
Nonobstant ce petit problème, il y a moyen d'éviter la variable compteur:
int pwr(int base,int exp) {
int res=1;
while(exp>=1) {
res*=base;
exp--;
}
return(res);
}
Edgar;
- Edité par edgarjacobs 9 janvier 2017 à 20:41:41
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
la fonction puissance. Avant de parler code on peut parler algo. L'algo que tu utilises est la version naive, en gros la première qui vient à l'esprit car c'est plus ou moins comme ça qu'on la calcule à la main. En effet, avec les entiers et un exposant positif, a exposant b revient à multiplier une accumulateur avec a b fois. Cet algo a une complexité linéaire par rapport à l'exposant ; cela signifie en gros qu'avec un exposant b tu feras b tour de boucle (c'est linéaire). Par exemple a⁵=a*a*a*a*a → on calcule a,a² puis a³ puis a⁴ puis a⁵.
Une autre façon de coder ça serait en utilisant la récursivité :
int ipow(int b, int e)
{
if (e==0) {
return 1;
} else if (b==0) {
return 0;
} else {
return b*ipow(b,e-1);
}
}
C'est l'application directe de la formule a^b=a*a^(b-1).
Il y a une autre formule pour l'exponentiation entière : a⁵=a*(a²)², on commence par a, puis a², on passe directement à a⁴ (en reprenant le carré) pour finit avec a⁵. Il y a moins d'opérations.
int ipow(int b, int e)
{
if (e==0) {
return 1;
} else if (b==0) {
return 0;
} else if (e%2==0) {
int tmp=ipow(b,e/2);
return tmp*tmp;
} else {
int tmp=ipow(b,(e-1)/2);
return b*tmp*tmp;
}
}
Dans mes code b signifie base et e exposant, j'appelle la fonction ipow pour integer power.
First solve the problem. Then, write the code. ~ John Johnson
@Pico. J'étais hésitant pour utiliser pow car j'avais lu que sur des variables int et long, on rencontrait des erreurs dues à la conversion...
Effectivement j'utilise des versions naîves pour le moment pour prendre des repères dans un premier temps.
Dans ton exemple où tu utilise la récursivité, je ne parviens pas à utiliser ton code. Mon IDE se ferme dès que je rentre un nombre ( je le place peut-être mal ). Peux-tu m'indiquer la totalité de ton code ?
La seconde écriture de ton code m'apparaît flou (de la ligne 7 à la fin ). J'ai compris la logique de créer un temps mais j'ai du mal à expliquer le code. Si tu veux bien l'expliciter un peu, je suis preneur
Effectivement, j'ai commencé par apprendre les structures itératives en langage C. J'avais entendu parler de récursivité mais sans oser m'y aventurer pour le moment.
En fait, je me rend compte que ça correspond à ma façon de penser dans ce type d'exercice. (moi qui pensais réfléchir à l'envers de tout le monde ) Mais ne sachant pas si c'est possible de solutionner un problème avec cette logique, je me réfugiais toujours dans les structures itératives. D'une façon générale, la récursivité n'aura pas besoin de faire appel à des boucles mais ne sera pas forcément utilisable dans tous les cas ?
Je vais regarder les cours à son sujet ;)
Merci
@Marc : J'ai du commettre une petite erreur lors de la copie de mon code...Merci pour ton attention
#include <stdio.h>
#include <stdlib.h>
int puissance(int x, int y)
{
// Déclaration des variables
int compteur, resultat;
compteur = 1;
resultat = 1;
while (compteur <= y){
resultat = resultat * x;
compteur ++;
}
return resultat;
}
int main()
{
// Déclaration des variables
int x,y, resultat;
printf("Insérer la valeur de x : \n");
scanf("%i", &x);
printf("Insérer la puissance y : \n");
scanf("%i", &y);
if (y==0) {
printf("Le resultat est 1");
} else {
if (x==0){
printf("Le resultat est 0");
} else {
resultat = puissance(x,y);
printf("le resultat est : %i",resultat);
}
}
return 0;
}
HEY petite vache ! content de te revoir sur le forum. Ton code est déjà bien plus propre. N'oublie pas que tu peux initialiser une variable en faisant int var=3;
Sinon, super ! Maintenant, on peut regarder pour trouver des codes différents faisant la même chose .
- tu pourrais faire un code avec une boucle for ?
- utiliser le fait que \( a^{2k} = a^k * a^k \) et \( a^{2k+1} = a*a^k * a^k \)
Essaye de coder ces deux algos et montre nous le résultat.
Concernant la programmation récursive, elle permet en effet dans certains cas d'éviter des boucles. et peut être très utile dans des structures spécifique comme les arbres qui sont définis de manière récursive. cependant ce n'est pas toujours une bonne solution et parfois une solution itérative est largement meilleur. Un bon exemple de cela est la suite de fibonacci . \( Un = U_{n-1} + U_{n-2} \) qui programmé de façon naïve en récursif est une horreur
edit : je viens de voir que picodev avait expliqué ce que j'ai dit... perso je trouve sa moyen de donner des codes tout fait mais bon :/
Tes lignes 31, 32 33, 34, 35, 36, 39 et 40 sont inutiles
- Edité par breizhbugs il y a environ 7 heures
Tu es sûr ? Mon calcul ne s'effectue pas sans ces lignes...
@Edouard
Merci. Je t'avouerai que j'ai demandé conseil à un ami avant de poster mon code pour être sûr qu'il soit clair pour tous. Au fur et à mesure, je progresse, mais c'est difficile.
Je me pencherai sur tes algos Effectivement Pico a proposé un code. Je le réfléchis toujours
ta fonction attend des paramètres positifs c'est ce qu'on appelle un prérequis, si les prérequis ne sont pas satisfaits alors la fonction renverra une valeur indéterminée. Si les paramètres que tu lui donnes dépendent d'une source extérieure alors il faut vérifier que les paramètres que tu vas fournir à ta fonction sont ok, dans le cas contraire il faut gérer l'erreur. C'est de la programmation défensive. Si ta fonction est utilisée par un programmateur, il est responsable de sa bonne utilisation. Si les paramètres fournis ne sont pas ok alors tu es en droit de planter l'exécution. On réalise ça via les mécanismes d'assertions (en gros c'est un test de validité qui n'est fait que lors de la phase de création/debogage quand on compile en mode debug). Ce n'est plus de la programmation défensive.
il y a les cas particuliers par exemple dans le cas d'une fonction puissance entière, les cas où la base vaut 0 ou 1 peuvent être traités à part car le résultat est (presque) indépendant de l'exposant ; tout comme les cas où l'exposant vaut 0 ou 1 peuvent être traités comme des cas particuliers. Les cas particuliers sont intéressants à traiter quand ils simplifient les choses. Par exemple dans ton cas avec
Merci pour ces explications Je ne connaissais pas assert.
J'ai lu que pour l'utiliser il fallait mettre en en-tête #include <assert.h>. Tu confirmes bien ? Ca a l'air super efficace.
J'ai bien compris pourquoi ici il n'est pas utile de traiter les cas particuliers, mais j'ai encore du mal à identifier où cela peut être utile ou non...
Je vais jeter un oeil sur la gestion des erreurs en C, en espérant que ça ne m'embrouille pas davantage
Bonne soirée.
- Edité par Petitevache 10 janvier 2017 à 17:24:40
Merci pour ces explications Je ne connaissais pas assert.
J'ai lu que pour l'utiliser il fallait mettre en en-tête #include <assert.h>. Tu confirmes bien ? Ca a l'air super efficace.
oui, mais fais-toi confiance quand tu lis la doc
Petitevache a écrit:
J'ai bien compris pourquoi ici il n'est pas utile de traiter les cas particuliers, mais j'ai encore du mal à identifier où cela peut être utile ou non...
Ça l'est pour les cas où ça t'économise des tours de boucles … si tu calcules 1^1000000 tu vas faire 1000000 de tours «pour rien».
Petitevache a écrit:
Je vais jeter un oeil sur la gestion des erreurs en C, en espérant que ça ne m'embrouille pas davantage
Bonne soirée.
- Edité par Petitevache il y a 11 minutes
La gestion des erreurs va se limiter à une série de if. Mais il faut bien faire la différence entre les erreurs qui viennent de l'extérieur (un fichier qui n'existe pas, un utilisateur qui saisit n'importe quoi, plus de mémoire de dispo, …) qui sont à «anticiper», et les erreurs internes (mauvaise utilisation d'une fonction, fuites mémoire, …) qui sont à débusquer et éradiquer avant de produire une version fonctionnelle.
First solve the problem. Then, write the code. ~ John Johnson
Il y a une quantité d'apprentissage énorme en programmation.
C'est assez impressionnant
Quoi qu'il ne soit, merci pour vos explications.
Ps : J'ai souhaité utiliser le code que tu as indiqué plus haut ( en récursif ), mais je n'y parviens pas. Mon IDE se ferme sans que je puisse saisir une donnée.
Pourrais-tu faire une copie de l'intégralité de ton code ?
Oui, ainsi que rajouté math.h en haut (mais je ne suis pas sûr qu'il faut pour utiliser pow)
Juste pour dire que le code de @PicoDev n’utilise pas pow. Il a juste appelé sa fonction ipow (sûrement pour integer pow), tout comme il aurait pu l’appeler puissance.
Oui, ainsi que rajouté math.h en haut (mais je ne suis pas sûr qu'il faut pour utiliser pow)
Juste pour dire que le code de @PicoDev n’utilise pas pow. Il a juste appelé sa fonction ipow (sûrement pour integer pow), tout comme il aurait pu l’appeler puissance.
Oui, c'est ça :
PicoDev a écrit:
... Dans mes code b signifie base et e exposant, j'appelle la fonction ipow pour integer power.
First solve the problem. Then, write the code. ~ John Johnson
Je commence à fatiguer Je regarderai comment traiter ça avec pow plus tard
1)
A la fin, tu affiches résultat en utilisant %d, alors qu'on a utilisé %i pour les variables. Je ne savais pas qu'on pouvait les mélanger dans un code. Un coup à se mélanger les pinceaux non ?
2)
J'avais pris pour habitude de mettre mes %"" entre guillemets.
A la ligne 32 tu utilises () pour le différencier du texte ?
3)
Par ailleurs il y a %d pendant trois ( 2 pour les variablees, 1 pour résultat j'imagine ).
On doit nécessairement utiliser autant de % qu'il y a de variables pour afficher un résultat final ?
Suite Message modifié :
Bonsoir à tous
Voici mon code me permettant de traiter les puissances
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
float x,y,z;
printf("Veuillez saisir un nombre x \n");
scanf ("%f",&x);
printf("Veuillez saisir une puissance y\n");
scanf ("%f",&y);
z = pow(x,y);
printf(" x exposant y est egale a " "%f", z);
return 0;
}
Si j'utilisais des double plutôt que des float, je pourrais traiter plus de puissance ?
Dans mon dernier printf, comment je pourrai écrire directement les saisies rentrées par l'utilisateur. Par exemple si l'utilisateur rentre 2^4 ; qu'il s'affiche dans la fenêtre 2 puissance 4 ( il faut créer un dernir scanf ?) J'ai testé avec les %f dans le print, mais je n'y arrive pas.
Par ailleurs comment fait-on le signe ^ en code ? Dans la table ascii je n'ai trouvé que les accents circonflexes
Enfin, j'ai toujours du mal à afficher un résultat final. Le dernier %f dans printf spécifient le format de x et y ? Pourquoi n'en utilises-t-on qu'un seul ? Pourquoi n'en mets-t-on pas pour z ?
Ps : Je suis peut-être pointilleux, mais je ne me satisfais pas de quelque chose de fonctionnel, je veux en comprendre tout le fonctionnement.
Merci, bonne soirée
- Edité par Petitevache 11 janvier 2017 à 22:54:25
1) Pour %d et %i, c'est équivalent pour printf, mais pas pour scanf. Lis les manuels de printf et scanf pour apprendre les détails.
2) Perds l'habitude de découper tes chaines littérales autour des caractères de formatage pour qu'ils soient entre guillemets, personne ne le fait et ça nuit à la lisibilité.
Les parenthèses sont utilisées autour des paramètres de fonction en informatique, en mathématiques, c'est une convention d'écriture...
3) Attention, printf reçoit des valeurs, pas des variables. D'ailleurs en C les fonctions ne reçoivent jamais des variables. Ce qui s'en approche le plus, c'est recevoir l'adresse d'une variable. Et oui, bien sûr qu'il faut utiliser autant de % qu'il y a de valeurs, c'est comme cela que printf sait combien de valeurs ont été passées.
Tu devrais utiliser des double, pas des float, car le type double est le type flottant par défaut. D'ailleurs la fonction standard pow prend et retourne des double.
printf("%f exposant %f est égale à %f.\n", x, y, z);
- Edité par Marc Mongenet 13 janvier 2017 à 10:48:13
je ne suis pas sûr de comprendre, tu as des difficultés avec cette ligne par exemple ?
printf("%lg ^ %lg est egal a %lg\n", x, y, z);
Le numéro décimal correspondant au caractère '^' dans la table ascii est le 94, que l'on peut par exemple trouver avec un bête man ascii, ou bien avec une petite ligne de code :
1) Pour %d et %i, c'est équivalent pour printf, mais pas pour scanf. Lis les manuels de printf et scanf pour apprendre les détails.
3) Attention, printf reçoit des valeurs, pas des variables. D'ailleurs en C les fonctions ne reçoivent jamais des variables. Ce qui s'en approche le plus, c'est recevoir l'adresse d'une variable. Et oui, bien sûr qu'il faut utiliser autant de % qu'il y a de valeurs, c'est comme cela que printf sait combien de valeurs ont été passées.
Merci, un petit rappel ne fait jamais de mal J'aime bien être précis avec le lexique que j'utilise, ça permet de prendre de bonnes habitudes et éviter les confusions ! C'est pas toujours évident quand au débute, car il y a tellement de mots nouveaux à assimiler qu'on peut vite se mélanger les pinceaux (Par exemple on m'avait expliqué au début; mais pas ici; que fonction ou procédure c'était la même chose...)
Partant du principe que %d était équivalent que %i en printf, je ne m'étais pas posé la question pour scanf... Faut aller trop vite en informatique et bien comprendre ce que l'on fait.
La ligne de code que tu as écrite correspond bien à ce que je souhaitais afficher.
Je me permets de mettre un lien définissant assez clairement les fonctions printf et scanf :
Mais comme ils indiquaient " accent circonflexe " pour moi ça ne voulait pas dire exposant
J'ai modifié mes float en double. Sur wiki, on indique qu'il faut utiliser %lf pour les double
Type
Lettre
int
%d
long
%ld
float/double
%f / %lf
char
%c
string (char*)
%s
pointeur (void*)
%p
short
%hd
entier hexadécimal
%x
De même pour scanf
Type
Lettre
int
%d
long
%ld
float/double
%lf
char
%c
string (char*)
%s
entier hexadécimal
%x
Il doit y avoir une erreur car quand je rentre 4^2 on m'affiche 4.000000 exposant 2.000000 est égale a 16.000000
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
double x,y,z;
printf("Veuillez saisir un nombre x \n");
scanf ("%lf",&x);
printf("Veuillez saisir une puissance y\n");
scanf ("%lf",&y);
z = pow(x,y);
printf("%lf exposant %lf est egale a %lf.\n", x, y, z);
return 0;
}
J'ai trouvé par contre un lien sur openclass où un utilisateur indique bien que l'on peut utiliser %lg pour les double (avec scanf) et %lg (avec printf). J'ai testé %g et ça marche aussi pour printf.
Avec printf, %lf est équivalent à %f depuis je ne sais plus quelle version du langage. Mais à l'origine, c'était %f pour double. Et float étant promus en double quand passé à printf, c'est pareil que pour double.
Je te laisse chercher par toi même, mais en gros pour te mettre sur la piste : avec f on a 6 décimales par défaut, avec e on a une notation scientifique, avec g on a une écriture automatiquement raccourcie pour gagner en lisibilité (mais possiblement perdre en précision), remarques aussi que l'on peut choisir le nombre de décimales que l'on veut afficher
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent