Congruence, similarité et triangles rectangles

Question

Je dois tester si deux triangles sont semblables, congruents, et si les côtés donnés sont des triangles rectangles. J'ai inclus un fichier d'en-tête. J'ai essayé d'exécuter ce programme, mais je continue d'obtenir les mauvaises réponses.

tête:

/* 
* triangles.h 
* Header file for triangle class. 
*/ 
// make sure this file is not included multiple times: 
#pragma once 

#include <vector> 
using std::vector; 

class triangle { 
    public: 
     // member functions: 
     // constructor: 
     triangle(unsigned long a=3, unsigned long b=4, unsigned long c=5): 
      s1(a),s2(b),s3(c) {} 
     unsigned long perimeter(); 
     unsigned long area(); 
     void print(); // prints to standard output 
     // member variables: 
     // integers for the 3 sides: 
     unsigned long s1; 
     unsigned long s2; 
     unsigned long s3; 
}; 

vector<triangle> findRightTriangles(unsigned long l, unsigned long h); 
bool congruent(triangle t1, triangle t2); 
bool similar(triangle t1, triangle t2); 

Fonctions

#include <vector> 
using std::vector; 
#include <algorithm> 
using std::sort; 

// note the "triangle::" part. We need to specify the function's 
// FULL name to avoid confusion. Else, the compiler will think we 
// are just defining a new function called "perimeter" 
unsigned long triangle::perimeter() { 
    return s1+s2+s3; 
} 

unsigned long triangle::area() { 
    // TODO: write this function. 
    // Note: why is it okay to return an integer here? Recall that 
    // all of our triangles have integer sides, and are right triangles... 
    // put the sides in an array: 
    unsigned long sides[3] = {s1,s2,s3}; 
    // sort the array: 
    sort(sides,sides+3); 
    // at this point, sides[0] <= sides[1] <= sides[2] 

    unsigned long b = sides[0]; 
    unsigned long h = sides[1]; 
    return (b*h)/2; 
} 

void triangle::print() { 
    cout << "[" << s1 << "," << s2 << "," << s3 << "]"; 
} 

bool congruent(triangle t1, triangle t2) { 
     // TODO: write this function. 
    int a, b, c; 
    a = t1.s1; 
    b = t1.s2; 
    c = t1.s3; 
    unsigned long tr1[3] = {a,b,c}; 
    // sort the array: 
    sort(tr1,tr1+3); 
    // at this point, tr1[0]<= tr1[1] <= tr1[2] 
    int d,e,f; 
    d = t2.s1; 
    e = t2.s2; 
    f = t2.s3; 
    unsigned long tr2[3] = {d,e,f}; 
    // sort the array: 
    sort(tr2,tr2+3); 
    // at this point, tr2[0] <= tr2[1] <= tr2[2] 

    if(tr1[0] == tr2[0] && tr1[1] == tr2[1] && tr1[2] == tr2[2]){ 
    true; 
    } 

    else false; 
} 

bool similar(triangle t1, triangle t2) { 
    // TODO: write this function. 
    int a, b, c; 
    a = t1.s1; 
    b = t1.s2; 
    c = t1.s3; 
    unsigned long tr1[3] = {a,b,c}; 
    // sort the array: 
    sort(tr1,tr1+3); 
    // at this point, tr1[0]<= tr1[1] <= tr1[2] 
    int d,e,f; 
    d = t2.s1; 
    e = t2.s2; 
    f = t2.s3; 
    unsigned long tr2[3] = {d,e,f}; 
    // sort the array: 
    sort(tr2,tr2+3); 
    // at this point, tr2[0] <= tr2[1] <= tr2[2 

    if(tr1[0]%tr2[0] == 0 && tr1[1]%tr2[1] == 0 && tr1[2]%tr2[2] == 0){ 
    true; 
    } 

    else false; 
} 

vector<triangle> findRightTriangles(unsigned long l, unsigned long h) { 
    // TODO: find all the right triangles with integer sides, 
    // subject to the perimeter bigger than l and less than h 
    vector<triangle> retval; // storage for return value. 
    triangle t1; 
    t1.s1=l; 
    t1.s3=h; 

    for (unsigned long p = 0; p < t1.s3; p++) { 
     t1.s2=p; 
     if (p >= t1.s1 && p <= t1.s3 && (((t1.s1*t1.s1)+(p*p)) == (t1.s3*t1.s3))){ 
      retval.push_back(t1); 

      break; 
     } 
    } 

    return retval; 
} 

Answer 1

Le principal problème est que vous n'êtes pas en train d'écrire return. Par exemple, la fonction congruent et la fonction similar doivent se terminer comme ceci:

return true; 

} 

else return false; 

En dehors de cela, il y a un problème avec votre fonction similar. Les triangles sont similaires si le rapport entre leurs côtés est le même. Vous vérifiez si l'un est un multiple d'un autre, mais cela n'a pas besoin d'être vrai. Par exemple, les triangles avec les côtés (6, 8, 10) et (9, 12, 15) sont similaires, mais l'un n'est pas un multiple de l'autre. Vous devriez vérifier si tr1[i]/tr2[i] est la même pour tous les 3 côtés. Cela vous donnera des problèmes si vous utilisez des divisions entières, vous pouvez donc utiliser la condition suivante qui évite les divisions:

if(tr1[0]*tr2[1] == tr2[0]*tr1[1] && tr1[2]*tr2[1] == tr2[2]*tr1[1]) 

qui vérifie si tr1[0]/tr2[0] est le même que tr1[1]/tr2[1], puis il vérifie si tr1[2]/tr2[2] est le même que tr1[1]/tr2[1]

Je n'ai pas vérifié vos autres fonctions.