Discussion :

[myoui]

Bonjour / Bonsoir,

Je suis en période d'examen et je ne croyais pas que ces structures etaient aussi difficiles woah.
Voici l'énoncé:

- Donner la définition d'une structure permettant de représenter un triangle par la longueur de ses 3 cotés.
(ça, ca va, mais apres..)

- Donner le code complet d'une fonction qui a deux paramètres d'entrées, un entier n > 0 qui est le nombre de triangles rectangles recherché, un entier borne > 0 l'entier qui borne la longueur de chaque coté des ces triangles. Cette fonction a aussi un paramètre de sortie representant le nombre de triangle trouvés. Cette fonction renvoie un tableau de n triangles rectangles dont les longueurs des cotés est borné par "borne" et tel que les perimetres des triangles trouvé soient tous differents.

Ce que je comprends c'est qu'elle renvoie un tableau de structures.
Que veut il dire par "parametre de sortie"?? c'est la meme chose que ce qu'il appelle n non?

J'ai essayé mais je n'arrive pas a terminer, voici :

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
 
struct triangle { 
int a; 
int b; 
int c; }; 
 
triangle tab[n] fonction(int n, int borne) 
{ 
int p=0; 
while (p<=n) { 
for (int c=0; c<=borne; c++) 
{ for(int b=0; b<=borne; b++) 
for(int a=0; a<=borne; a++) 
if (a*a+b*b=c*c) 
p=p+1 
.....

Je m'arrete ici, car je ne sais pas comment stocker les valeurs a,b,c qui verifient le triangle rectangle dans une structure "nouvelle" a chaque fois..

mercii !!

[dalfab]

Bonjour,

En effet l'énoncé n'est pas clair, il parle de paramètre de sortie représentant le nombre de triangle trouvés et la fonction renvoie un tableau de n triangles rectangles.
Hors en C++, une fonction ne peut pas retourner un tableau (à la rigueur une référence ou bien mais un pointeur sur une zone dynamique oui, mais c'est du C et à oublier en C++).
Voilà l'interface correspondant à cela :

Code :

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

1
2
3
4
5
6
7
8
triangle* fonction( int n , int borne , int *pNbTrouves ) {
   ...
   triangle* tabTriangles = new triangle[ nbTrouves ];
   tabTriangles[i].a = ...
   ...
   *pNbTrouves = nbTrouves; // retour par paramètre de sortie
   return tabTriangles ; // retour d'un tableau dynamique, l'appelant devra faire delete[] du tableau recu
}

[JolyLoic]

Je ne sais pas ce que tu as vu en cours, mais pour moi, un tableau de triangles, ça s'écrit : std::vector<Triangle>, et ça on peut le retourner sans problèmes d'une fonction.

[myoui]

Bonjour, je vous remercie d'avoir pris le temps de me répondre!

dalfab, oui tu as raison car la prof m'a répondu en email et a bien mis un pointeur dans les paramètres, cependant je ne vois pas beaucoup moi.. Comment avoir l'idée de mettre un pointeur en paramètre ? Que veux tu dire par "retour par paramètre de sortie"..

JolyLoic, je n'ai pas vu ça en cours donc je suppose que on ne doit pas procéder comme ça..

Ensuite voici le code que je lui ai envoyé et qu'elle a "commenté" :

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
#include <iostream>
 
struct triangle{
int a;
int b;
int c; };
 
// on doit utiliser double ou float (voir le texte)
 
triangle * fonction(int n, int borne, int * nb)
// il manque un paramètre de sortie pour le nb de triangles trouvés
{
int cpt=0;
/*il faut créer un tableau de triangles de taille n, même si ce tableau risque d'être trop grand.
*/
 
while (cpt<=n) {
for(int c=0; c<=borne; c++) {
  for(int b=0; b<=borne; b++)
  for(int a=0; a<=borne; a++)
//il faut penser à générer des triangles distincts.
   if (a*a+b*b=c*c)
    cpt=cpt+1; 
 
 
 
// à la fin, *nb=cpt
 
return ...

Voilà donc on doit bien créer un tableau dynamique comme été mentionné par dalfab, mais taille n comme dit la prof: triangle* tabTriangles = new triangle[ n ]; Mais que veut elle dire par "des triangle distincts, je sais qu'elle fait référence à l'énoncé ou on dit que les triangles ne doivent pas avoir le meme périmetre mais je bloque ici..

ce qui me ramène à écrire ce code:

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
#include <iostream>
 
struct triangle{
int a;
int b;
int c; };
 
// on doit utiliser double ou float (voir le texte)
 
triangle * fonction(int n, int borne, int * nb)
// il manque un paramètre de sortie pour le nb de triangles trouvés
{
int cpt=0;
triangle* tabTriangles = new triangle[ n ];  /*il faut créer un tableau de triangles de taille n, même si ce tableau risque d'être trop grand.
*/
 
while (cpt<=n) {
for(int c=0; c<=borne; c++) {
  for(int b=0; b<=borne; b++)
  for(int a=0; a<=borne; a++)
//il faut penser à générer des triangles distincts. COMMENT?
   if (a*a+b*b=c*c)
    cpt=cpt+1; 
// je vais remplir le tableau //
tabTriangle [cpt]= struct { int a; int b; int c} // Est ce qu'on peut remplir le tableau comme ça? vu que a,b,c changent avec la boucle..
 
 
 
// à la fin, *nb=cpt
 
return tabTriangle;
}

Si mon remplissage est juste, il me reste à modifier le code pour que les triangles n'aient pas le meme périmètre!!

[dalfab]

Pour l'initialisation d'un triangle en une fois, il faut définir un constructeur triangle (as-tu appris cela?).

Quelque chose me perturbe encore dans l'énoncé.
Il faut retourner des triangles rectangles où chaque côté est inférieur à une limite. Rien ne dit que les côtés ont une valeur entière, s'ils sont flottants on a une infinité de possibilités. Inversement, il existe peu de possibilités telles que les 3 côtés soient tous des nombres entiers.
Si on pose que le côté 'c' est l'hypoténuse et qu'elle doit être entière,

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
for ( a = 1 ; a <= borne ; ++a ) { // on commence a 1, un cote ne peut pas etre nul
   for ( b = a ; b <= borne ; ++b ) { // on force b>= a pour ne pas prendre 2 triangles symetriques et qui seraient elimines au test du perimetre
      double cote_c = std::sqrt( a*a + b*b ); // longueur 'brute' du cote c
      int c = std::lround(cote_c);   // on prend la valeur entiere la plus proche
      if ( a*a + b*b == c*c ) {  // on verifie bien que cela tombe juste
         if ( c <= borne ) { // c aussi doit etre inferieur a la borne {
            // triangle elligible a condition qu'il n'ai pas le même perimetre qu'un precedent
            int perimetre = a + b + c;
            // faire ici une boucle de recherche dans les triangles precedents et comparer les perimetres
            ...
            if ( ! dejaVuUnTriangleAvecCePerimetre ) {
               tabTriangle[nbTrianglesTrouves].a = a;
               tabTriangle[nbTrianglesTrouves].b = b;
               tabTriangle[nbTrianglesTrouves].c = c;
               ++nbTrianglesTrouves;
            }
         }
      }
   ...

[Pyramidev]

Est-ce que la prof qui t'a répondu par email est celle qui a rédigé l'énoncé ?
Je pose cette question car :

• Quand j'étais en école d'ingé, un seul prof écrivait les énoncés des exercices mais plusieurs encadrants de TP le corrigeaient, chacun pour les élèves de son groupe de TP.
• Utiliser un flottant pour les longueurs des côtés des triangles est moins cohérent qu'un entier, du moins avec les informations présentes dans ton premier message.

C'est moins cohérent pour deux raisons :

• Dans l'énoncé, la borne de la longueur de chaque côté d'un triangle est un entier, pas un flottant.
• Comme le dit dalfab, si les longueurs des triangles étaient des flottants, on aurait une infinité de possibilités.
  Par exemple, la fonction suivante retournerait un triangle rectangle :
  

  Code :

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

  1
  2
  3
  4
  Triangle creerTrianglePytagoricien(double perimetre) {
      Triangle result{perimetre/4, perimetre/3, perimetre*5/12};
      return result;
  }

  Pour avoir un nombre fini de possibilités, il faudrait une contrainte supplémentaire, par exemple devoir parcourir une collection prédéfinie de triangles.
  La fonction aurait alors un nouveau paramètre d'entrée : ladite collection.
  Or, l'énoncé dit bien que la fonction n'a que 2 paramètres d'entrée, pas 3.
  Ou alors, ladite collection est une variable globale à laquelle la fonction accède directement, mais c'est moche.