C Leia os 3 lados de um triângulo retângulo e imprimir a maior altura e a sua área

Matheus Freitas · 7 de novembro de 2020

eu não entendi esta questão aqui em linguagem c, Leia os 3 lados de um triângulo retângulo e imprima a maior altura possível do triângulo e a sua área.

#include <stdio.h>
int main()
{
float A,B,C;
printf("Digite o tamanho do lado A do triangulo retangulo: ");
scanf("%f",&A);
printf("Digite o tamanho do lado B do triangulo retangulo: ");
scanf("%f",&B);
printf("Digite o tamanho do lado C do triangulo retangulo: ");
scanf("%f",&C);
if(A < (B+C) & B < (A+C) & C < (A+B))

{

if(A==B & B==C) {

area=(B*C)/2;

printf(“\n\nO valor da area do triangulo é igual a: %i\n\n”,area);

}

  return 0;
}

em c@AdrianoSiqueira @Math.Pi @Pedro_HF @devair1010 @Flávio Pedroza

Flávio Pedroza · 7 de novembro de 2020

A maior altura é o segundo maior lado. Por exemplo, em triângulo retângulo de lados 3, 4, e 5, a maior altura é 4. Outro exemplo: 5, 12, 13. A maior altura é 12.

Matheus Freitas · 7 de novembro de 2020

@Flávio Pedroza mas o código está certo?

Flávio Pedroza · 7 de novembro de 2020

if(A==B & B==C) {

area=(B*C)/2;

printf(“\n\nO valor da area do triangulo é igual a: %i\n\n”,area);

}

Remova esse "if". Não tem como os lados serem iguais. Em um triângulo retângulo todos os 3 lados são sempre diferentes.

Ansi C · 10 de maio

Boa dia!

Quando essa pergunta aconteceu ninguém recomendou ativas todos os alertas do compilador:

a.c: In function ‘main’:
a.c:13:10: parênteses em torno da comparação no operando de ‘&’ [-Werror=parentheses]
   13 |    if (A < (B+C) & B < (A+C) & C < (A+B))
      |        ~~^~~~~~~
a.c:13:34: erro: sugira parênteses em torno da comparação no operando de ‘&’ [-Werror=parentheses]
   13 |    if (A < (B+C) & B < (A+C) & C < (A+B))
      |                                ~~^~~~~~~
a.c:15:12: erro: sugira parênteses em torno da comparação no operando de ‘&’ [-Werror=parentheses]
   15 |       if (A==B & B==C)
      |           ~^~~
a.c:17:10: erro: ‘área’ não declarada (primeiro uso nesta função)
   17 |          area=(B*C)/2;
      |          ^~~~
a.c:17:10:nota: cada identificador não declarado é relatado apenas uma vez para cada função em que aparece

A,B e C são flutuantes (float)***

area não existe!***

Com essas correções, o programminha compilou

Leia-os-3-lados-de-um-triângulo-retângulo-e-imprimir-a-maior-altura-e-a-sua-área.c

/*                                EXERCICIO
 ---------------------------------------------------------------------------
*/#include <stdio.h>
  int main ()
  {
   float A,B,C;
   printf("Digite o tamanho do lado A do triangulo retangulo: ");
   scanf("%f",&A);
   printf("Digite o tamanho do lado B do triangulo retangulo: ");
   scanf("%f",&B);
   printf("Digite o tamanho do lado C do triangulo retangulo: ");
   scanf("%f",&C);
   if ((A < (B+C)) & (B < (A+C)) & (C < (A+B)))
     {
///   if ((A==B) & (B==C))
///     {
      float area=(B*C)/2.0f;
      printf("\n\nO valor da area do triangulo é igual a: %f\n\n",area);
///     }
     }
   return 0;
  }

C11 - gcc11.4

devair1010 · 15 de maio

O enunciado diz para ler os lados de um triangulo retângulo e também mostrar a maior altura e também a área do triangulo , então imagino que o programa precisa detectar se o triângulo é retângulo e também a maior altura e a hipotenusa para assim fazer os cálculos , e também coloquei alguns controles para validar o que o usuário digitar na entrada dos dados , e o programa ficou assim :

#include    <stdio.h>
#include    <stdlib.h>
#include    <string.h>
#include    <windows.h>
#include    <math.h>
#include    <time.h>
#include    <locale.h>

int main(int argc, char* argv[] )
{
    srand(time(NULL));
    setlocale(LC_ALL,"");// usar vIrgula para casas decimais
    int   repetir =    0;
    int   ret     =    0;
    float area    =  0.0;
    float A       =  0.0;
    float B       =  0.0;
    float C       =  0.0;
    float c1      =  0.0;
    float c2      =  0.0;
    float h1      =  0.0;
    float h2      =  0.0;
    do
    {
        repetir = 0;
        printf("coloque vIrgula para separar casas decimais dos nUmeros"
               "Digite o tamanho do lado A do triangulo retangulo: ");
        ret = scanf("%f",&A);
        printf("val A = %.2f\nval retorno = %d\n",A,ret);
        if(ret != 1)return 0;
        printf("Digite o tamanho do lado B do triangulo retangulo: ");
        ret = scanf("%f",&B);
        printf("val B = %.2f\nval retorno = %d\n",B,ret);
        if(ret != 1)return 0;
        printf("Digite o tamanho do lado C do triangulo retangulo: ");
        ret = scanf("%f",&C);
        printf("val C = %.2f\nval retorno = %d\n",C,ret);
        if(ret != 1)return 0;
        ///  ver qual eh a hipotenusa ?
        h1 = A;        /// considera que A seja a hipotenuza
        if(B>A && B>C) /// B Eh o maior Lado ?
        {
          h1 = B;
          B  = A;
        }
        else /// C Eh o maior Lado ?
        {
          if(C>A && C>b)
          {
            h1 = C;
            C  = A;
          }
        }
        /// ver se o triangulo eh retAngulo
        c1 = B  * B;
        c2 = C  * C;
        h2 = h1 * h1;     /// ver qual eh a maior altura
        A = B;
        if(C > A) A = C;
        if(h2 != c1 + c2 )/// se hipotenuza ao quadrado diferente da soma do quadrado dos catetos
        {
            printf("esse triangulo não eh retangulo.\n"
                   "Hipotenuza %.2f diferente (B)² %.2f + (C)² %.2f = %.2f\n"
                   ,h2,c1,c2,c1+c2);
            repetir = 1;
        }
    }
    while( repetir != 0);/// repete enquanto não for tringulo retangulo
    area = B * C / 2;    /// calculando a Area do triAngulo
    printf("\nHipotenuza %.2f X %.2f -> %.2f IguaL %.2f => (B)%.2f + (C)%.2f\n"
           "\nEsse TrianGulo eh RetanguLo.       \n\n"
           "A Maior Altura eh %.2f               \n\n"
           "a Area do TrianguLo eh  %.2f         \n\n"
           ,h1,h1,h2, c1 + c2,c1, c2, A, area    );
    return   0;
}

Ansi C · sábado às 11:31

Bom dia,

Essa programação não compilou!

...

a.c: Na função 'main':
a.c:48:23: erro: 'b' não declarado (primeiro uso nesta função)
   48 | if(C>A && C>b)
      |             ^
a.c:48:23: nota: cada identificador não declarado é relatado apenas uma vez para cada função em que aparece
a.c:9:14: erro: parâmetro não utilizado 'argc' [-Werror=unused-parameter]
    9 | int main(int argc, char* argv[] )
      |          ~~~~^~~~
a.c:9:26: erro: parâmetro não utilizado 'argv' [-Werror=unused-parameter]
    9 | int main(int argc, char* argv[] )
      |                    ~~~~~~^~~~~~
cc1: todos os avisos sendo tratados como erros

c11 - gcc11.4

devair1010 · sábado às 16:54

realmente essa variável "b" minúsculo :

h1 = A;        /// considera que A seja a hipotenuza
if(B>A && B>C) /// B Eh o maior Lado ?
{
  h1 = B;
  B  = A;
}
else           /// C Eh o maior Lado ?
{
               /// if(C>A && C>b)
  if( C > A && C > B )
  {
    h1 = C;
    C  = A;
  }
}

não está nesse código , e sim o "B" maiúsculo , pois editei o código no próprio site e ficou assim , porém aqui no codeblocks não apresentou esses outros erros e warning's .

arfneto · sábado às 21:05

Mesmo 4 anos acho que ainda se pode tentar aprender algo de uma questão assim.

Em 07/11/2020 às 01:47, Matheus Freitas disse:

eu não entendi esta questão aqui em linguagem c, Leia os 3 lados de um triângulo retângulo e imprima a maior altura possível do triângulo e a sua área

O lado da geometria

Isso pede um programa em C mas supõe noções de geometria e trigonometria que o estudante pode não ter, apesar de ser algo do ensino fundamental.

Considere o triangulo retângulo clássico com lados 3 4 e 5 como na figura.

A noção de altura h vai depender de qual lado é a base, mas fica claro que a maior altura é o comprimento do maior cateto.

Porque? São 3 alturas. Considere o clássico teorema de Pitágoras do ensino fundamental: para essa dimensão a hipotenusa vale 5. E o teorema diz que a soma dos quadrados dos catetos é igual ao quadrado da hipotenusa. Como algum tamanho (positivo) os catetos tem, se a2 + b2 = c2 então c não pode ser maior a e não pode ser maior que b. E assim h3 no desenho não pode ser maior 3 ou 4 já que os dois triângulos internos também são triângulos retângulo...

Usando mais do ensino fundamental --- sistemas lineares --- é trivial ser que por exemplo nesse caso h vale 12/5 e as duas partes da base no último triângulo medem 16/5 e 9/5

A área do triângulo é a metade do produto da base pela altura. Mas num triângulo retângulo se pode pensar diferente: Como um dos ângulos é reto então o triângulo retângulo é obviamente metade de um retângulo com os lados iguais aos catetos. Basta ver na figura acima e pensar um pouco.

E a área do retângulo é o produto da base pela altura, então bata achar os lados menores do tal triângulo

O lado da linguagem C

Então basta ler os 3 valores e separar o maior, e então calcular a tal área.

Do programa original

Essa é uma condição interessante e impossível:

        if (A == B & B == C)
        {
            area = (B * C) / 2;
            printf(
                "\n\nO valor da area do triangulo é igual "
                "a %i\n\n ",
                area);
        }

Mais do ensino fundamental: a igualdade é transitiva. então duas coisas iguais a uma terceira são iguais entre si. Esse if identificaria um triângulo equilátero. Só que um triangulo retângulo não pode ser equilátero, como está claro pelo teorema de Pitágoras citado acima.

E area não foi declarado.

    printf(
        "Digite o tamanho do lado A do triangulo "
        "retangulo: ");
    scanf("%f", &A);
    printf(
        "Digite o tamanho do lado B do triangulo "
        "retangulo: ");
    scanf("%f", &B);
    printf(
        "Digite o tamanho do lado C do triangulo "
        "retangulo: ");
    scanf("%f", &C);

Isso é muito muito chato de usar. Ao chamar o programa o cara já tem um triângulo em mente. É um porre ter que ficar esperando 3 mensagens óbvias e digitar 3 valores para depois ter as respostas. Permita que o cara passe os valores na linha de comando, e se não passar que digite os 3 valores na mesma linha.

E entenda que tem uma razão para scanf() retornar um int. USE. É bobagem seguir sem testar.

Em 07/11/2020 às 16:55, Flávio Pedroza disse:

Remova esse "if". Não tem como os lados serem iguais. Em um triângulo retângulo todos os 3 lados são sempre diferentes.

Não, não são iguais. Onde se aprende isso? Imagine um quadrado com medida 5. trace a diagonal e vai ver dois triângulos retângulo, com catetos de medida 5 e hipotenusa de medida ao quadrado igual a 50...

Em 15/05/2024 às 00:07, devair1010 disse:

imagino que o programa precisa detectar se o triângulo é retângulo e também a maior altura e a hipotenusa para assim fazer os cálculos

Tem razão, mas não pode usar '!=' para comparar float ou double porque muitas vezes vai dar erro. Não é como int. Pode dar diferença tipo na sexta casa decimal e aí seu cálculo já era. Deve comparar SEMPRE com uma tolerância. Veja no exemplo ao final...

Em 15/05/2024 às 00:07, devair1010 disse:

if(h2 != c1 + c2 )/// se hipotenuza ao quadrado diferente da soma do quadrado dos catetos

Um exemplo

O programa a seguir lê as 3 medidas e se o triângulo for considerado retângulo calcula a área e a maior altura

#include <stdio.h>
int main(int argc, char* argv[])
{
    double l[3] = {0};
    double a, b, c;

    printf(
        "\n\
        Entre com as medidas dos 3 lados do triangulo,\n\
        separadas por ao menos um espaco\n\
\n\
        Medidas: ");
    int res = scanf("%lf %lf %lf", &a, &b, &c);
    if (res != 3)
    {
        fprintf(
            stderr, "Erro ao tentar ler os 3 valores\n");
        return -1;
    }
    // lado 1
    l[0] = a;
    // lado 2
    if (b > l[0])
    {
        l[1] = l[0];
        l[0] = b;
    }
    else
        l[1] = b;
    // lado 3
    if (c > l[0])
    {
        if (c > l[1])
        {
            l[2] = l[1];
            l[1] = l[0];
            l[0] = c;
        }
        else
        {
            l[2] = l[1];
            l[1] = c;
        }
    }
    else
    {
        if (c > l[1])
        {
            l[2] = l[1];
            l[1] = c;
        }
        else
            l[2] = c;
    }

    // sera um triangulo retangulo?
    // t. de Pitagoras
    double delta = .001;
    double diff =
        (l[0] * l[0]) - (l[1] * l[1]) - (l[2] * l[2]);
    if (diff < 0) diff = -diff;
    if (diff > delta)
    {
        printf(
            "\n\
        Medidas lidas: %.2f %.2f %.2f\n\
        Medidas em ordem decrescente: %.2f (hipotenusa) %.2f (maior cateto) %.2f (menor cateto)\n\
\n\
        Esse não e um triangulo retangulo\n",
            a, b, c, l[0], l[1], l[2]);
        return -2;
    }
    double area = l[1] * l[2] * 0.5;
    printf(
        "\n\
        Medidas lidas: %.2f %.2f %.2f\n\
        Medidas em ordem decrescente: %.2f (hipotenusa) %.2f (maior cateto) %.2f (menor cateto)\n\
        area = %.2f\n\
        maior altura = %.2f",
        a, b, c, l[0], l[1], l[2], area, l[1]);
    return 0;
}

Saída do exemplo


        Entre com as medidas dos 3 lados do triangulo,
        separadas por ao menos um espaco

        Medidas: 3. 4. 5.

        Medidas lidas: 3.00 4.00 5.00
        Medidas em ordem decrescente: 5.00 (hipotenusa) 4.00 (maior cateto) 3.00 (menor cateto)
        area = 6.00
        maior altura = 4.00


        Entre com as medidas dos 3 lados do triangulo,
        separadas por ao menos um espaco

        Medidas: 6 7 9.2195

        Medidas lidas: 6.00 7.00 9.22
        Medidas em ordem decrescente: 9.22 (hipotenusa) 7.00 (maior cateto) 6.00 (menor cateto)
        area = 21.00
        maior altura = 7.00


        Entre com as medidas dos 3 lados do triangulo,
        separadas por ao menos um espaco

        Medidas: 6 7 9.2194

        Medidas lidas: 6.00 7.00 9.22
        Medidas em ordem decrescente: 9.22 (hipotenusa) 7.00 (maior cateto) 6.00 (menor cateto)

        Esse não e um triangulo retangulo


        Entre com as medidas dos 3 lados do triangulo,
        separadas por ao menos um espaco

        Medidas: 6 7 9.2197

        Medidas lidas: 6.00 7.00 9.22
        Medidas em ordem decrescente: 9.22 (hipotenusa) 7.00 (maior cateto) 6.00 (menor cateto)

        Esse não e um triangulo retangulo

Em 10/05/2024 às 13:10, Ansi C disse:

Quando essa pergunta aconteceu ninguém recomendou ativas todos os alertas do compilador:

Ativar todos os alertas ou mesmo tratar qualquer alerta como erro é interessante numa primeira compilação ou se sua empresa ou escola assim exige, mas não é essencial. Um erro é um erro e não gera código algum. Variável não declarada é um erro.

E compilar certinho não quer dizer muito. Veja o que expliquei aqui por exemplo.

Ansi C · sábado às 23:39

3 horas atrás, arfneto disse:

Ativar todos os alertas ou mesmo tratar qualquer alerta como erro é interessante numa primeira compilação ou se sua empresa ou escola assim exige, mas não é essencial. Um erro é um erro e não gera código algum. Variável não declarada é um erro.

E daí? Ative todos os alerta e se dê a oportunidade de aprender com eles!

ISSO É BOM!

A propósito, aquela programação não compilou.

a.c: In function ‘main’:
a.c:2:14: error: parâmetro não utilizado ‘argc’ [-Werror=unused-parameter]
    2 | int main(int argc, char* argv[])
      |          ~~~~^~~~
a.c:2:26: error: parâmetro não utilizado ‘argv’ [-Werror=unused-parameter]
    2 | int main(int argc, char* argv[])
      |                    ~~~~~~^~~~~~
cc1: todos os avisos sendo tratados como erros

arfneto · domingo às 01:41

@Ansi C Se você quer rodar algum exemplo que eu escreva aqui pare de usar essas opções de compilação. Já te expliquei isso mais de uma vez.

Isso

2 horas atrás, Ansi C disse:
cc1: todos os avisos sendo tratados como erros

é decisão sua.

Ansi C · domingo às 03:43

@arfneto

2 horas atrás, arfneto disse:

pare de usar essas opções de compilação

Não, não paro, porque o alerta ensina!

EU RECOMENDO.

Midori · segunda-feira às 13:15

Para entender o enunciado deve saber que o triângulo retângulo tem três alturas: Os dois catetos e outro segmento que pode ser traçado do vértice oposto a hipotenusa até ela para formar um angulo de 90º graus. Considere esta figura referente a formação de três entradas/lados do seu código: a, b e c.

O segmento h é uma das alturas. Essa o código não terá que tratar já que ela sempre será menor que qualquer lado. E isso é fácil ver na figura que se divide em dois triângulos retângulos onde a e b são hipotenusas e portanto sempre maiores que h. Por isso seu código só tem que pegar o segundo maior lado (o primeiro c é a hipotenusa da figura).

Para classificar os valores, sem considerar eficiência computacional ou "melhores práticas", resolvi fazer as macros com o resultado do maior e menor entre dois. Assim por exemplo a hipotenusa será MAIOR(MAIOR(a, b), c). No teste para identificar o triângulo retângulo round funcionou bem. Há outras formas para isso, mas assim sem tanta precisão para as entradas com casas decimais 3 foi suficiente para meus testes, p.ex:

Entre com os tres lados: 13 23 26.419
Catetos: 13.00 e 23.00
Hipotenusa: 26.42
Altura h: 11.32
Maior altura: 23.00
Area: 149.50

#include <stdio.h>
#include <math.h>

#define MAIOR(a, b) ((a) > (b) ? (a) : (b))
#define MENOR(a, b) ((a) < (b) ? (a) : (b))

int main(int argc, char* argv[]){
    double a;
    double b;
    double c;

    printf("Entre com os tres lados: ");
    if(scanf("%lf %lf %lf", &a, &b, &c)){
        if(a + b > c && a + c > b && b + c > a){
            double altura = MAIOR(MAIOR(MENOR(a, b), MENOR(a, c)), MENOR(b, c));
            double maior = MAIOR(MAIOR(a, b), c);
            double base = MENOR(MENOR(a, b), c);
         
            if(round(maior * maior) == round(altura * altura + base * base)){
                printf(
                    "Catetos: %.2lf e %.2lf\nHipotenusa: %.2lf\n"
                    "Altura h: %.2lf\n"
                    "Maior altura: %.2lf\n"
                    "Area: %.2lf\n",
                    base, altura, maior,
                    base * altura/maior, altura, base*altura/2.0);
            }else{
                puts("O triangulo não e retangulo");
            }
        }else{
            puts("não e possível formar um triangulo");
        }
    }
   return 0;
}