Discussion :

[couturierclaire]

Bonjour, je dois faire programme qui peut:
–initialiser un polynôme au polynôme nul
–lire un polynôme, calculer sa dérivée par rapport à x et écrire le résultat
–lire deux polynômes, calculer leur somme et écrire le résultat

Selon moi, il faut écrire 3 fonctions à part (void initialiser, void somme, ...) mais pour le contenu, quelqu'un pourrait t-il m'aider?
Merci d'avance

J'ai

Code :

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

1
2
3
4
5
typedef struct Monome {
    double coefficient; 
    long degre;
    struct Monome * next;
} Monome;

Et

Code :

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

1
2
3
4
typedef struct{
    List * monomes;
    long degre;
} Polynome;

[BufferBob]

salut,

<insérer ici exactement ce que l'on veut, l'utilisateur ne le lira pas et n'y répondra pas non plus à l'image de ses 5 autres threads sur le même modèle>

[Obsidian]

Bonjour,

La dérivation de polynômes est effectivement un exercice fréquent et toujours aussi à propos.

Selon moi, il faut écrire 3 fonctions à part (void initialiser, void somme, ...) mais pour le contenu, quelqu'un pourrait t-il m'aider?
Merci d'avance

En effet, c'est une bonne approche mais sais-tu déjà dériver un polynôme ? (sur papier, s'entend). C'est extrêmement simple mais ça ne s'invente pas forcément si on ne sait pas le faire. Si ce point est clair pour toi, alors le côté algorithmique de la chose devrait te venir plus ou moins naturellement.

Code :

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

1
2
3
4
typedef struct{
    List * monomes;
    long degre;
} Polynome;

C'est assez pertinent mais souviens-toi que le degré d'un polynôme est celui de son plus haut monôme, et comme ceux-ci doivent normalement être triés dans ta liste chaînée, alors le degré de ton polynôme est celui de ton premier maillon. Il est donc inutile de le répéter dans la structure « Polynome ». Et comme, du coup, ta structure « Polynome » ne contient plus qu'un pointeur vers le début de la liste, elle devient elle-même sans objet. Par contre, certains professeurs sont parfois tentés de cacher le pointeur derrière un typedef, ce qui est une TRÈS mauvaise habitude. :-)

[Sve@r]

Bonjour Obsidian, bonjour BufferBob, bonjour les autres

En effet, c'est une bonne approche mais sais-tu déjà dériver un polynôme ? (sur papier, s'entend).

Tu devrais aller lire tout ça.
http://www.developpez.net/forums/d15...ine-caracteres
http://www.developpez.net/forums/d15...ine-caracteres
http://www.developpez.net/forums/d15.../c/pointeurs-c

A mon avis non il ne sait pas et en fait il n'en a rien à cirer...

C'est extrêmement simple mais ça ne s'invente pas forcément si on ne sait pas le faire. Si ce point est clair pour toi, alors le côté algorithmique de la chose devrait te venir plus ou moins naturellement.

A mon avis, le coté algorithmique de la chose sera long long long à venir, même plus ou moins naturellement...

Et comme, du coup, ta structure « Polynome » ne contient plus qu'un pointeur vers le début de la liste, elle devient elle-même sans objet.

Perso je préfère quand-même garder un type dédié à la liste. Déjà ça déporte le soucis du double pointeur (au lieu de devoir gérer un t_monome** dans les fonctions d'insertions de maillon, tu gères juste un t_polynome*) mais surtout ça aide à l'évolutivité. Si demain tu veux rajouter des outils dans ta liste (comme par exemple le nombre d'éléments ou autre), te suffit de le rajouter dans le t_polynome* et toutes les fonctions de gestion de ta liste y ont alors instantanément accès...

[couturierclaire]

Bonjour, j'ai réussi à faire le programme ci-dessous, cependant je n'ai pas utilisé la structure que mon enseignant m'a donné(voir en bas), j'aimerais savoir si quelqu'un pourrait m'aider à modifier mon programme de telle sorte que la structure que j'ai faite soit remplacée par celle de mon enseignant (que mon programme utilise plutôt la structure donnée par mon ensegnant)?
Merci d'avance

Code :

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

1
2
3
4
5
6
7
8
9
10
typedef struct Monome {
 double coefficient;
 long degre;
 struct Monome * next;
} Monome;
typedef Monome List;
typedef struct{
 List * monomes;
 long degre;
} Polynome;

Voici ce que j'ai fait :

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#include <stdio.h>
#include <stdlib.h>
typedef struct polynome{
int degre;
float *coeff;
}polynome;
 
 
 
polynome *initialiser()
{
polynome *p;
int deg;
float *tab;
int i;
printf("Degre =\n");
scanf("%d", &deg);
tab = (float *) malloc(deg * sizeof(float));
for (i=0; i<=deg; i++)
{
printf("Coeff x^%d = ", i);
scanf("%f", tab+i);
}
p = (polynome *) malloc(sizeof(polynome));
p->degre = deg;
p->coeff = tab;
return p;
}
 
 
 
void afficher(polynome *p)
{
int i;
printf("P(x) = ");
for (i=p->degre; i>0; i--)
{
if (p->coeff[i] != 0)
printf("%f*x^%d + ", p->coeff[i], i);
}
printf("%fx^0\n\n", p->coeff[0]);
}
 
polynome *ajouter(polynome *p1, polynome *p2)
{
polynome *res;
int deg_max;
float *tab;
int i;
if (p1->degre < p2->degre)
deg_max = p2->degre;
else
deg_max = p1->degre;
tab = (float *) malloc(deg_max * sizeof(float));
for (i=0; i<=deg_max; i++)
tab[i] = p1->coeff[i] + p2->coeff[i];
res = (polynome *) malloc(sizeof(polynome));
res->degre = deg_max;
res->coeff = tab;
return res;
}
 
 
int main(int argc, char **argv)
{
polynome *p1, *p2, *p3;
p1 = initialiser();
afficher(p1);
p2 = initialiser();
afficher(p2);
p3 = ajouter(p1, p2);
afficher(p3);
free(p1);
free(p2);
free(p3);
exit(0);
}

[couturierclaire]

je suis désolé, c'était pas bon le code ,je l'ai modifié,veuillez revoir mon message précédent

[Obsidian]

Il faut absolument que tu tiennes compte des remarques que l'on te fait et que tu consultes tes messages privés :

Consulter mes messages privés

Ensuite, ce que tu as écrit est encourageant mais inutilement compliqué. Et même beaucoup trop ! Par exemple, pourquoi allouer un float avec malloc() et recueillir son adresse dans le pointeur tab, alors que tu pourrais directement déclarer un flottant en tant que variable locale comme tu le fais déjà pour deg ?

Ensuite, tu n'as pas encore dérivé ton polynôme. Fais une recherche sur ce site. il y a un an, quelqu'un a eu exactement le même problème et la solution est quelque part dans les forums.

[couturierclaire]

Finalement voici le début de mon programme, mais il me manque la fonction d'affichage, quelqu'un pourrait t-il m'aider?

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
void lecture_polynome(Polynome * polynome, char * filename)
{
    double coefficient;
    long degre;
    int n;
 
    Monome * nouveau = NULL;
    Monome * debut = polynome->monomes;
 
    FILE * source = NULL;
    source =  fopen(filename,"r");
    if (source == NULL)
    {
        fprintf(stderr, "ERREUR ouverture de %s t \n", filename);
        return 1;
    }
 
    while ((n = fscanf(source,"%lf %ld ", &coefficient, &degre)) == 2)
    {
        nouveau = (Monome*) malloc(sizeof(Monome));
        if (nouveau != NULL)
        {
            //insertion eb tête
            nouveau->next = debut;
            nouveau->coefficient = coefficient;
            nouveau->degre = degre;
            debut = nouveau;
        }
        printf("Coefficient = %lf\tDegre = %ld\n", nouveau->coefficient, nouveau->degre);
    }
 
    polynome->degre = debut->degre;
 
    fclose(source);
}
 
 
 
int main()
{
    Polynome polynome;
 
 
    lecture_polynome(&polynome, "bis.txt");
 
 
    return 0;
}

[Sve@r]

Par exemple, pourquoi allouer un float avec malloc() et recueillir son adresse dans le pointeur tab, alors que tu pourrais directement déclarer un flottant en tant que variable locale comme tu le fais déjà pour deg ?

T'as pas bien étudié son code (ceci dit, vu sa quantité impressionnante de commentaires explicatifs...)
Il a défini sa structure polynôme comme contenant un tableau de flottants ; chaque flottant représentant alors un monôme individuel (mais les monômes étant, chez-lui, non chainés). Donc au début il alloue "deg" flottants...