Programa para comprobar la congruencia de dos triángulos

Dadas cuatro arrays de 3 números cada una que representan lados y ángulos de dos triángulos. La tarea es comprobar si los dos triángulos son congruentes o no. También imprime el teorema por el cual son congruentes. Nota: Todos los lados y ángulos dados como entrada son para triángulos válidos. Ejemplos:

Input : side1 = [3, 4, 5]  angle1 = [90, 60, 30]
        side2 = [4, 3, 5]  angle2 = [60, 30, 90]
Output: Triangles are congruent by SSS SAS ASA AAS HL.  

Input : side1 = [3, 5, 6]  angle1 = [80, 50, 50]
        side2 = [1, 1, 1]  angle2 = [60, 60, 60]
Output: Triangles are not congruent

Los triángulos congruentes son dos o más triángulos que tienen todos los lados correspondientes que son iguales o un par de lados y entre los ángulos son iguales o un par de ángulos y el lado entre ellos son iguales o un par de ángulos y el otro lado son iguales o la hipotenusa y un lado son iguales. La congruencia de triángulos se puede demostrar mediante los siguientes teoremas:

  1. Criterio de congruencia Lado-Lado-Lado (SSS): Si todos los lados de un triángulo son iguales a los lados de otro triángulo, se dice que los triángulos son congruentes por la propiedad de Lado-Lado-Lado (SSS). En el triángulo anterior ABC y A’B’C’ si, AB=A’B’ y BC=B’C’ y CA=C’A’ entonces, los triángulos son congruentes.
  2. Lado-Ángulo-Lado (SAS) Criterio de congruencia: si dos lados de los dos triángulos son iguales y el ángulo entre ellos es el mismo en ambos triángulos, se dice que los triángulos son congruentes por la propiedad de Lado-Ángulo-Lado (SAS) . En el triángulo anterior ABC y A’B’C’ si, AB=A’B’ y BC=B’C’ y  \measuredangle ABC    \measuredangle A'B'C'    los triángulos son congruentes.
  3. Ángulo-Lado-Ángulo (ASA) Criterios congruentes: si dos ángulos de los dos triángulos son iguales y la longitud del lado entre ellos es la misma en ambos triángulos, se dice que los triángulos son congruentes por la propiedad de Ángulo-Lado-Ángulo ( ASA). En el triángulo anterior ABC y A’B’C’ si,  \measuredangle ABC    \measuredangle A'B'C'    \measuredangle BCA    \measuredangle B'C'A'    y BC=B’C’ entonces, los triángulos son congruentes.
  4. Ángulo-Ángulo-Lado (AAS) Criterio congruente: si dos ángulos de los dos triángulos son iguales y la longitud del otro lado es la misma en ambos triángulos, se dice que los triángulos son congruentes por la propiedad de Ángulo-Ángulo-Lado (AAS) ). En el triángulo anterior ABC y A’B’C’ si,  \measuredangle ABC    \measuredangle A'B'C'    \measuredangle BCA    \measuredangle B'C'A'    y CA=C’A’ entonces, los triángulos son congruentes.
  5. Hipotenusa-cateto (HL) Criterios congruentes: si la hipotenusa de los dos triángulos es igual y la longitud de cualquier otro lado es la misma en ambos triángulos, se dice que los triángulos son congruentes por la propiedad de hipotenusa-cateto (HL).

A continuación se muestra la implementación de los teoremas anteriores. 

Python

# Python program to check
# similarity between two triangles.
  
# Function for SAS congruency
def cong_sas(s1, s2, a1, a2):
      
    s1 = [float(i) for i in s1]
    s2 = [float(i) for i in s2]
    a1 = [float(i) for i in a1]
    a2 = [float(i) for i in a2]
      
    s1.sort()
    s2.sort()
    a1.sort()
    a2.sort()
      
    # Check for SAS
      
    # angle b / w two smallest sides is largest.
    if s1[0] == s2[0] and s1[1] == s2[1]:
          
        # since we take angle b / w the sides.
        if a1[2] == a2[2]:        
            return 1
              
    if s1[1] == s2[1] and s1[2] == s2[2]:
        if a1[0] == a2[0]:
            return 1
              
    if s1[2] == s2[2] and s1[0] == s2[0]:
        if a1[1] == a2[1]:
            return 1
      
    return 0
     
# Function for ASA congruency
def cong_asa(s1, s2, a1, a2):
      
    s1 = [float(i) for i in s1]
    s2 = [float(i) for i in s2]
    a1 = [float(i) for i in a1]
    a2 = [float(i) for i in a2]
      
    s1.sort()
    s2.sort()
    a1.sort()
    a2.sort()
      
    # Check for ASA
      
    # side b / w two smallest angle is largest.
    if a1[0] == a2[0] and a1[1] == a2[1]:
          
        # since we take side b / w the angle.
        if s1[2] == s2[2]:        
            return 1
              
    if a1[1] == a2[1] and a1[2] == a2[2]:
        if s1[0] == s2[0]:
            return 1
              
    if a1[2] == a2[2] and a1[0] == a2[0]:
        if s1[1] == s2[1]:
            return 1
      
    return 0
     
# Function for AAS congruency
def cong_aas(s1, s2, a1, a2):
      
    s1 = [float(i) for i in s1]
    s2 = [float(i) for i in s2]
    a1 = [float(i) for i in a1]
    a2 = [float(i) for i in a2]
      
    s1.sort()
    s2.sort()
    a1.sort()
    a2.sort()
      
    # Check for AAS
      
    # side other two smallest angle is smallest or 2nd smallest.
    if a1[0] == a2[0] and a1[1] == a2[1]:
          
        # since we take side other than angles.
        if s1[0] == s2[0] or s1[1] == s2[1]:        
            return 1
              
    if a1[1] == a2[1] and a1[2] == a2[2]:
        if s1[1] == s2[1] or s1[2] == s2[2]:
            return 1
              
    if a1[2] == a2[2] and a1[0] == a2[0]:
        if s1[0] == s2[0] or s1[2] == s2[2]:
            return 1
      
    return 0
  
# Function for HL congruency
def cong_hl(s1, s2):
      
    s1 = [float(i) for i in s1]
    s2 = [float(i) for i in s2]
    s1.sort()
    s2.sort()
      
    # Check for HL
    if s1[2] == s2[2]:
        if s1[1] == s2[1] or s1[0] == s2[0]:
            return 1
      
    return 0
     
# Function for SSS congruency
def cong_sss(s1, s2):
      
    s1 = [float(i) for i in s1]
    s2 = [float(i) for i in s2]
    s1.sort()
    s2.sort()
      
    # Check for SSS
    if(s1[0] == s2[0] and s1[1] == s2[1] and s1[2] == s2[2]):
        return 1
      
    return 0
      
  
# Driver Code
s1 = [3, 4, 5]
s2 = [4, 3, 5]
          
a1 = [90, 60, 30]
a2 = [60, 30, 90]
  
# function call for SSS congruency
sss = cong_sss(s1, s2)
  
# function call for SAS congruency
sas = cong_sas(s1, s2, a1, a2)
 
# function call for ASA congruency
asa = cong_asa(s1, s2, a1, a2)
  
# function call for AAS congruency
aas = cong_aas(s1, s2, a1, a2)
 
# function call for HL congruency
hl = cong_hl(s1, s2, )
  
# Check if triangles are congruent or not
if sss or sas or asa or aas or hl :
    print "Triangles are congruent by",
    if sss: print "SSS",
    if sas: print "SAS",
    if asa: print "ASA",
    if aas: print "AAS",
    if hl: print "HL",
else: print "Triangles are not congruent"

Javascript

<script>
// JavaScript program to check
// similarity between two triangles.
 
// Function for SAS congruency
function cong_sas(s1, s2, a1, a2){
 
    s1.sort();
    s2.sort();
    a1.sort();
    a2.sort();
     
    // Check for SAS
     
    // angle b / w two smallest sides is largest.
    if (s1[0] == s2[0] && s1[1] == s2[1]){
        // # since we take angle b / w the sides.
        if (a1[2] == a2[2]){
            return 1;
        }   
                 
    }
                 
    if( s1[1] == s2[1] && s1[2] == s2[2]){
        if( a1[0] == a2[0]){
            return 1;
        }       
    }
         
    if( s1[2] == s2[2] && s1[0] == s2[0]){
        if( a1[1] == a2[1]){
            return 1;
        }       
    }
     
    return 0; 
}
     
 
     
// Function for ASA congruency
function cong_asa(s1, s2, a1, a2){
 
    s1.sort();
    s2.sort();
    a1.sort();
    a2.sort();
     
    // Check for ASA
     
    // side b / w two smallest angle is largest.
    if (a1[0] == a2[0] && a1[1] == a2[1]){
        // since we take side b / w the angle.
        if (s1[2] == s2[2]){
            return 1;
        }           
    }
                     
    if( a1[1] == a2[1] && a1[2] == a2[2]){
         if (s1[0] == s2[0]){
            return 1;
        }      
    }       
             
    if( a1[2] == a2[2] && a1[0] == a2[0]){
          if (s1[1] == s2[1]){
            return 1;
        }     
    }
     
    return 0;
}
 
     
// Function for AAS congruency
function cong_aas(s1, s2, a1, a2){
      
    s1.sort();
    s2.sort();
    a1.sort();
    a2.sort();
     
    // Check for AAS
     
    // side other two smallest angle is smallest or 2nd smallest.
    if (a1[0] == a2[0] && a1[1] == a2[1]){
        // # since we take side other than angles.
        if (s1[0] == s2[0] || s1[1] == s2[1]){
            return 1;
        }           
    }
                 
    if (a1[1] == a2[1] && a1[2] == a2[2]){
        if (s1[1] == s2[1] || s1[2] == s2[2]){
            return 1;
        }       
    }
 
             
             
    if (a1[2] == a2[2] && a1[0] == a2[0]){
        if( s1[0] == s2[0] || s1[2] == s2[2]){
            return 1;
        }       
    }
     
    return 0;
}
 
 
// Function for HL congruency
function cong_hl(s1, s2){
    s1.sort();
    s2.sort();
     
    // Check for HL
    if (s1[2] == s2[2]){
         if( s1[1] == s2[1] || s1[0] == s2[0]){
            return 1;
        }      
    }
     
    return 0; 
}
 
     
// Function for SSS congruency
function cong_sss(s1, s2){
    s1.sort();
    s2.sort();
     
    // # Check for SSS
    if(s1[0] == s2[0] && s1[1] == s2[1] && s1[2] == s2[2]){
        return 1;
    }
         
     
    return 0;  
}
 
     
 
// Driver Code
s1 = [3, 4, 5];
s2 = [4, 3, 5];
         
a1 = [90, 60, 30];
a2 = [60, 30, 90];
 
// function call for SSS congruency
sss = cong_sss(s1, s2);
 
// function call for SAS congruency
sas = cong_sas(s1, s2, a1, a2);
 
// function call for ASA congruency
asa = cong_asa(s1, s2, a1, a2);
 
// function call for AAS congruency
aas = cong_aas(s1, s2, a1, a2);
 
// function call for HL congruency
hl = cong_hl(s1, s2, );
 
// Check if triangles are congruent or not
if (sss || sas || asa || aas || hl){
    document.write("Triangles are congruent by ");
    if(sss) document.write("SSS ");
    if(sas) document.write("SAS ");
    if (asa) document.write("ASA ");
    if (aas) document.write("AAS ");
    if (hl) document.write("HL ");
}
 
else document.write("Triangles are not congruent");
 
// The code is contributed by Nidhi goel
</script>
Producción:

Triangles are congruent by SSS SAS ASA AAS HL

Complejidad del tiempo: O(1) Como las arrays tienen solo 3 elementos, el tiempo total empleado puede tratarse como constante.
Espacio Auxiliar: O(1)

Publicación traducida automáticamente

Artículo escrito por Amber_Saxena y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *