Recherche d'une commande

Version imprimable

25/02/2009, 15h09
alessandro67

Recherche d'une commande

Voilà j'ai un TP à finir et arriver à l'exercice 2)a) je tombe la dessus:

Citation:

a. Concevez et codez une fonction qui prend un entier R en paramètre, et qui affiche R barres verticales à l’écran.

Ce que je vous demande, c'est que faut-il utiliser pour pouvoir afficher ces barre à l'écran? (c'est pour un jeu d'allumette)

Merci
25/02/2009, 15h14
jowo

Bonjour,

le caractère '|' ou '¦' pourrait l'affaire, non?
25/02/2009, 15h15
diogene

Probablement le caractère |
25/02/2009, 19h09
raphamil

Sinon tu demandes à spécifier le caractère dans les arguments de ton programme, et tu prends comme valeur par défaut |.

Je vous remercie, je n'y avais pas penser!
Une autre question dont je ne trouve pas la solution depuis bien 1h:
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 #include <stdio.h> #include <stdlib.h> #include <time.h> float e; int factorielle(int i) { if (i>1) return(i*factorielle(i-1)); else return(1); } int prog (int i, float e){ if(i<100){ i=i+1; e=(1/(factorielle(i)))+prog(i+1, e); } else ; return e; } int main (){ int i; i=1; printf("Approximation de e: %d", prog(i,e)); return 0; }
Je compile => niquel
Je lance le programme => "Exception en point flottant"

Je ne comprend pas :s

P.S: Ou peut-être je me trompe dans l'énoncé?

http://img9.imageshack.us/img9/9716/exo.jpg

26/02/2009, 14h31
emprex

Salut,

en regardant le programme je vois : float e que tu appelles ensuite par %d.
je pense que %f irait mieux.
ensuite dans la formule : e=(1/(factorielle(i)))+prog(i+1, e); il faudrait peut penser à faire un cast : e=(1/(float)(factorielle(i)))+prog(i+1, e);
26/02/2009, 18h52
alessandro67

Quand je corrige les 2 problèmes que tu m'a dis de corriger, j'obtient sa à la compilation:

Citation:

neper.c: Dans la fonction «main» :
neper.c:25: attention : format «%f» expects type «double», but argument 2 has type «int»

Et si je remet %d la compilation marche, mais la valeur de e affiché est :

Citation:

Approximation de e: -2147483648

Je suis perdu là...
27/02/2009, 02h58
alessandro67

Si quelqu'un sait me trouver ou sa cloche assez rapidement sa serait cool ^^
En effet sa fait partie d'un des TP que je dois rendre par email demain :?

Merci
27/02/2009, 10h13
Médinoc

Poste la dernière version du code, s'il te plait.

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
// Alessandro Giuliani M12
// ** TP 3 **
// ** Exercice 3 **
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
float e;
 
int factorielle(int i)
 {
  if (i>1) return(i*factorielle(i-1));
  else return(1);
 }
 
int prog (int i, float e){
 if(i<1000){
 	i=i+1;
	e=(1/(float)(factorielle(i)))+prog(i+1, e); 
 }
 else ;
return e;
}
 
int main (){
 int i;
 i=1;
 printf("Approximation de e: %f\n", prog(i,e));
 return 0;
}

Erreur:

Citation:

neper.c: Dans la fonction «main» :
neper.c:29: attention : format «%f» expects type «double», but argument 2 has type «int»

27/02/2009, 14h46
Médinoc

Ben, c'est pourtant clair...
Qu'est-ce qui te déroute? Le fait que le message d'erreur soit en anglais?
27/02/2009, 15h47
alessandro67

Je vois pas en quoi c'est clair, étant donner que prog(i,e)=e=flottant et pas int... jvois pas pk il veut pas compiler alors que %f est associé à un flottant..
27/02/2009, 15h52
ram-0000

Citation:

Envoyé par alessandro67

Je vois pas en quoi c'est clair, étant donner que prog(i,e)=e=flottant et pas int... jvois pas pk il veut pas compiler alors que %f est associé à un flottant..

Si on lit ton code, prog() est une fonction qui retourne un int

Code:

int prog (int i, float e)

C'est le retour de la fonction (int) qui ne colle pas avec le format (%f) qui fait que le compilateur génére un message d'erreur
27/02/2009, 15h53
rilou

Citation:

Envoyé par alessandro67

Je vois pas en quoi c'est clair, étant donner que prog(i,e)=e=flottant et pas int... jvois pas pk il veut pas compiler alors que %f est associé à un flottant..

Il ne veut peut-être pas compiler pour la bonne raison que tu tente d'afficher LA VALEUR DE RETOUR de ta fonction PROG et non pas un FLOAT.

Le mieux serait que tu retourne un FLOAT et non pas un INT :)

Bonne chance :)
27/02/2009, 16h43
alessandro67

Citation:

Approximation de e: 0.543081

Pas normal cette valeur de e nan ? si je met i<50 sa me met "e: inf"
27/02/2009, 16h54
ram-0000

Citation:

Envoyé par alessandro67

Pas normal cette valeur de e nan ? si je met 50 sa me met "e: inf"

Est ce que tu lis les réponses que l'on te donne car cela fait 3 messages dans lesquels tu as l'explication de ton problème :
Celui de Medinoc, le mien et celui de rilou
27/02/2009, 18h05
alessandro67

Est-ce que tu lis ma question? Le problème de compilation est résolu et je les en remercie, mais le résultat de ma fonction ne me semble pas juste...
27/02/2009, 18h23
rilou

Citation:

Envoyé par alessandro67

Est-ce que tu lis ma question? Le problème de compilation est résolu et je les en remercie, mais le résultat de ma fonction ne me semble pas juste...

Faut pas s'énerver :)

Pourrais-tu envoyer la dernière version du source ?

Ton problème viens peut-être d'un mauvaise interprétation de l'algorithme de ton copain Néper...

Voilà le dernier code en question:

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
float e;
 
int factorielle(int i)
 {
  if (i>1) return(i*factorielle(i-1));
  else return(1);
 }
 
int prog (int i, float e){
 if(i<1000){
 	i=i+1;
	e=(1/(float)(factorielle(i)))+prog(i+1, e); 
 }
 else ;
return e;
}
 
int main (){
 int i;
 i=1;
 printf("Approximation de e: %f\n", prog(i,e));
 return 0;
}

Merci

Alors ton float ne peut contenir une valeur suffisamment grande/petite :s

Le problème c'est que tu tente de diviser 1 par un factoriel 1000 >.> (voir même plus).

Imagine qu'aucun TYPE de variable en C ne soit capable de contenir une précision aussi jolie que cela !

Il te faudrait donc pouvoir utiliser une bibliothèque de très grande précision ou faire tout toi même :p

Dans tout les cas :
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 #include <stdio.h> #include <stdlib.h> #include <time.h> double e; int factorielle(int i) { if (i>1) return(i*factorielle(i-1)); else return(1); } double prog (int i){//on retourne un DOUBLE if(i<1000){ i=i+1; e=(1/(double)(factorielle(i)))+prog(i+1); } else ; return e; } int main (){ int i; i=1; printf("Approximation de e: %lf\n", prog(i));//pas la peine de passer E en param puisqu'elle est globale return 0; }
Depuis tout à l'heure on dit un FLOAT :p ici j'ai testé avec un double mais de toute façon une fois 30 ou 40 dépassé pour i tu ne peut plus afficher...

Ce que tu peut ESSAYER de faire en revanche, c'est de te pencher sur la question du :

Pourquoi ne pas laisser le "1/" de coté pour le moment et essayer deja de faire simplement retourner par ta fonction l'élément suivant :

Code:

(double)(factorielle(i))+prog(i+1);

Pour te donner une idée de par combien tu vas devoir diviser 1 !

27/02/2009, 21h16
Obsidian
Citation:

Envoyé par alessandro67

Est-ce que tu lis ma question? Le problème de compilation est résolu et je les en remercie, mais le résultat de ma fonction ne me semble pas juste...

C'est toi qui ne lis pas les réponses qu'on te donne. Ce n'est pas parce que ton code est syntaxiquement valable qu'il est correct sur le fond :
Citation:
Envoyé par alessandro67

Voilà le dernier code en question:

Code:

1 2 3 4 5 6 7 8 9 10 11 12 ... int prog (int i, float e){ if(i<1000){ i=i+1; e=(1/(float)(factorielle(i)))+prog(i+1, e); } else ; return e; } ...
Ta fonction est de type int, mais renvoie e qui est déclaré comme float. Moralité, à chaque retour de ta fonction, c'est-à-dire à chaque itération de ton sigma, tu ne conserves que la partie entière de ton sous-total !
27/02/2009, 21h17
Médinoc

Citation:

Envoyé par alessandro67

Voilà le dernier code en question:

<snip>

Merci

Ben non, dans ce code le problème de compilation n'est PAS résolu.

Ca a l'air de fonctionner :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
int factorielle(int i)
 {
    if (i>1) return(i*factorielle(i-1));
    else return(1);
 }
double prog (int i,int j)
{
    double e=0.;
    if(i<=j) e=1./(double)(factorielle(i)) + prog(i+1,j);
    return e;
}
int main (void)
{
    int n;
    for (n=0; n<30; n++) printf("Approximation de e (n=%d): %lf\n", n,prog(0,n));
    getchar();
    return 0;
}

Ca ne résout qu'une partie de ton exo car je n'ai pas pris en compte leur histoire d'espilon. Il faudra modifier le code. ;)