Discussion :

[alessandro67]

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

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

[jowo]

Bonjour,

le caractère '|' ou '¦' pourrait l'affaire, non?

[diogene]

Probablement le caractère |

[raphamil]

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

[alessandro67]

Je vous remercie, je n'y avais pas penser!
Une autre question dont je ne trouve pas la solution depuis bien 1h:

Code :

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
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é?

[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);

[alessandro67]

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

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 :

Approximation de e: -2147483648

Je suis perdu là...

[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

[Médinoc]

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

[alessandro67]

Code :

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
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:

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

[Médinoc]

Ben, c'est pourtant clair...
Qu'est-ce qui te déroute? Le fait que le message d'erreur soit en anglais?

[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..

[ram-0000]

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 :

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

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

[rilou]

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

[alessandro67]

Approximation de e: 0.543081

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

[ram-0000]

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

[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...

[rilou]

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...

[alessandro67]

Voilà le dernier code en question:

Code :

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
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

[rilou]

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 :

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
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 :

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

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

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