def testTri(l1):
    if len(l1) != 3 or sum(l1) != 180 or min(l1) <= 0: return "삼각형이 아니다"
    if 90 in l1: return "직각삼각형"
    if max(l1) > 90: return "둔각삼각형"
    return "예각삼각형"

list1 = [[60, 60, 60],
    [30, 60, 90],
    [20, 40, 120],
    [0, 90, 90],
    [60, 70, 80],
    [40, 40, 50, 50]]


for l1 in list1:
    print(l1, '=', testTri(l1))

def tri(v):
    if len(v) != 3 or sum(v) != 180 or min(v) <= 0: print('삼각형이 아님')
    else: print('둔각 삼각형' if max(v)>90 else '직각 삼각형' if 90 in v else '예각 삼각형')

Swift입니다.

print("Enter 3 angles separated by space");
let givenAngles = readLine()!.split(separator: " ").map({Int($0)!})

func checkAngles(_ angles: [Int]) {
    let totalAngle = angles.reduce(0, +)
    let angleCount = angles.count

    if (totalAngle == 180 && angleCount == 3) {
        let maxAngle = angles.reduce(0, {return $1 > $0 ? $1 : $0})
        print("\( (maxAngle > 90 ? "둔각" : (maxAngle < 90 ? "예각" : "직각") ))삼각형 입니다.")
        return
    }
    print("삼각형이 아닙니다.")
}

checkAngles(givenAngles)

trilist = [[60, 60, 60],[30, 60, 90],[20, 40, 120],[0, 90, 90],[60, 70, 80],[40, 40, 50, 50]]


for i in range(len(trilist)):
    print
    if len(trilist[i]) != 3 or sum(trilist[i])!=180 or min(trilist[i])<=0:
        print(trilist[i],'  삼각형이 아니다.')
    else:
        if max(trilist[i])>90:
            print(trilist[i],' 둔각삼각형')
        elif max(trilist[i])==90:
            print(trilist[i],' 직각삼각형')
        else:
            print(trilist[i],' 예각삼각형')

//C# class Program { /* [60, 60, 60] = 예각삼각형 [30, 60, 90] = 직각삼각형 [20, 40, 120] = 둔각삼각형 [0, 90, 90] = 삼각형이 아니다 [60, 70, 80] = 삼각형이 아니다 [40, 40, 50, 50] = 삼각형이 아니다

    예각삼각형 : 3개의 각이 모두 예각인 삼각형
    직각삼각형 : 1개의 각이 직각인 삼각형
    둔각삼각형 : 1개의 각이 둔각인 삼각형
    ① 각이 3개가 아닐 경우 삼각형이 아니다.
    ② 3개의 각의 합이 180°가 아닐 경우 삼각형이 아니다.
    */
    enum triangletype {
        예약, 직각, 둔각, 삼각형아님
    }
    static void Main(string[] args)
    {
        int[] ary1 = { 60, 60, 60 }; // 예각삼각형
        int[] ary2 = { 30, 60, 90};  //= 직각삼각형
        int[] ary3 = { 20, 40, 120}; // = 둔각삼각형
        int[] ary4 = { 0, 90, 90};   // = 삼각형이 아니다
        int[] ary5 = { 60, 70, 80};  // = 삼각형이 아니다
        int[] ary6 = { 40, 40, 50, 50}; // = 삼각형이 아니다

        int[] ary = ary6; //테스트

        //삼각형체크
        if (!IsTriangle(ary))
        {
            Console.WriteLine("삼각형이 아닙니다.");
            return;
        }

        triangletype type = CheckType(ary);

        switch (type)
        {
            case triangletype.둔각:
                Console.WriteLine("둔각 삼각형입니다.");
                break;
            case triangletype.예약:
                Console.WriteLine("예각 삼각형입니다.");
                break;
            case triangletype.직각:
                Console.WriteLine("직각 삼각형입니다.");
                break;

        }
    }

    //삼각형 여부 체크
    static bool IsTriangle(int[] ary)
    {
        //배열 개수 3개이고, 최고 각도가 0보다크고, 각 배열의 합이 180이면 삼각형
        if (ary.Length == 3 && ary.Sum() == 180 && ary.Min() > 0)
            return true;
        else
            return false;

    }
    //삼각형 타입 체크 
    static triangletype CheckType(int[] ary)
    {
        if (ary.Max() > 90)
            return triangletype.둔각;
        else if (ary.Max() < 90)
            return triangletype.예약;
        else
            return triangletype.직각;
    }
}

import java.io.*;


public class Main {

    public static void checkTriangle(int a[])
    {
        if(a.length!=3)
        {
            System.out.println("삼각형이 아닙니다.");
            return;
        }
        int angle90=0;
        int angle90under=0;
        int angle90upper=0;
        int totalAngle=0;
        for(int i=0 ;i<a.length;i++)
        {
            if(a[i]==90)
            {
                angle90++;
            }else if(a[i]>90)
            {
                angle90upper++;
            }else
                angle90under++;

            totalAngle+=a[i];   
        }
        if(angle90>1 || totalAngle!=180)
        {
            System.out.println("삼각형이 아닙니다.");
            return;
        }
        if(angle90==1)
        {
            System.out.println("직각삼각형 입니다.");
            return;
        }
        if(angle90under==3)
        {
            System.out.println("예각삼각형 입니다.");
            return;
        }
        if(angle90upper==1)
        {
            System.out.println("둔각삼각형 입니다.");
            return;
        }



    }

    public static void main(String[] args)throws Exception  {
        // TODO Auto-generated method stub
        int arr1[]= { 60, 60, 60} ;// 예각삼각형
        int arr2[]= {30, 60, 90} ;// 직각삼각형
        int arr3[]= {20, 40, 120};// = 둔각삼각형
        int arr4[]= { 0, 90, 90};// = 삼각형이 아니다
        int arr5[]= { 60, 70, 80};// = 삼각형이 아니다
        int arr6[]= {40, 40, 50, 50};// = 삼각형이 아니다

        checkTriangle(arr1);
        checkTriangle(arr2);
        checkTriangle(arr3);
        checkTriangle(arr4);
        checkTriangle(arr5);
        checkTriangle(arr6
                );
    }
}

c언어
#include<stdio.h>
#include<string.h>

/*
 삼각형    - 예각, 직각, 둔각
 삼각형 X  - 합이 180가 아닐경우, 입력값이 4개이상인경우, 하나의 각이 0 일 
*/

void display_array(int *, int );

int main()
{
    int degree[3] ={0, };
    int i = 0;
    int count =0;
    int sum = 0;

    printf("3개의 각으로 삼각형의 예각 직각 둔각을 구별하는 프로그램입니다.");
    printf("ex)예각삼각형 : 3개의 각이 모두 예각인 삼각형 \n직각삼각형 : 1개의 각이 직각인 삼각형");
    printf(" 둔각삼각형 : 1개의 각이 둔각인 삼각형 \n각이 3개가 아닐 경우 삼각형이 아니다. \n3개의 각의 합이 180°가 아닐 경우 삼각형이 아니다.\n");
    printf("각도를 입력해 주세요 enter를 누르면 각도가 저장됩니다. ");

    do
    {
        scanf("%d", &degree[count]);
        count++;
    }
    while(getc(stdin) ==' ');

    if(count>3) //입력받은 각이 4개 이상인 경우 
    {
        display_array(degree, count);
        printf(" = 삼각형이 아니다. ");
        return 0;
    }

    display_array(degree, count);

    for(i=0; i<3; i++)
    {
        if(degree[i] == 0)
        {

            printf(" = 삼각형이 아닙니다. \n"); //3각 중 하나가 0인경우  
            return 0; 
        }
    }

    for(i=0; i<3; i++)
    {
            sum += degree[i];

            if(sum == 180 && 1<=degree[i] && degree[i]<90)
            {
                    printf("= 예각 삼각형 "); 

            }
            else if(degree[i]>0 && sum == 180 && degree[i] == 90)
            {
                    printf(" = 직각 삼각형 ");
            }
            else if(degree[i]>0 && sum == 180 && degree[i]>90)
            {
                    printf(" = 둔각 삼각형 ");
            }
            else
            {
                printf(" = 삼각형이 아닙니다. "); //합계가 180 이상이거나 미만인경우 
                return 0; 
            }  
    }   
    return 0;
}

void display_array(int *arr, int size)
{
    int i;

    for(i=0; i<size; i++)
    {
        printf("%d ", arr[i]);
    }
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main(void)
{
    int num1, num2, num3;
    printf("각을 입력하세요: ");
    scanf("%d %d %d", &num1, &num2, &num3);
    if (num1 + num2 + num3 == 180) {
        if (num1 > 90 || num2 > 90 || num3 > 90) {
            printf("둔각삼각형\n");
        }
        else if (num1 == 90 || num2 == 90 || num3 == 90) {
            if ((num1 == 90 && num2 == 90) || (num1 == 90 && num3 == 90) || (num2 == 90 && num3 == 90)) {
                printf("삼각형이 아니다.\n");
            }
            else {
                printf("직각삼각형\n");
            }
        }
        else if ((num1 < 90 && num1>0) && (num2 < 90 && num2>0) && (num3 < 90 && num3>0)) {
            printf("예각삼각형\n");
        }
    }
    else {
        printf("삼각형이 아니다.\n");
    }
    return 0;
}

#삼각형 구별

def search (x,y,z):
    if x+y+z!= 180 or x==0 or y==0 or z==0:
        print('삼각형이 아닙니다')


    else:
        if max(x,y,z)>90 :
            print('둔각삼각형입니다')

        elif max(x,y,z)==90:
            print('직각삼각형입니다')

        else:
            print('예각삼각형입니다')

    return ''
x=int(input('제1각을 입력하세요'))
y=int(input('제2각을 입력하세요'))
z=int(input('제3각을 입력하세요'))

print(search(x,y,z))

4개를 입력받을때 오류띄우는건 다시 해보겠습니당

public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scan = new Scanner(System.in);
        System.out.println("첫번째 각을 입력해주세요.");
        int a = scan.nextInt();
        System.out.println("두번째 각을 입력해주세요.");
        int b = scan.nextInt();
        System.out.println("세번째 각을 입력해주세요.");
        int c = scan.nextInt();
        String result = "";
        if (a+b+c == 180 && a!=0 && b!=0 && c!=0) {     // 삼각형이 맞을 때            
            if (a<90 || b<90 || c<90) {     // 예각 삼각형인가?
                result = "예각 삼각형입니다.";
            }
            if (a==60 && b==60 && c==60) {      // 정삼각형일 떄
                result = "정삼각형입니다.";
            }
            if (a==90 || b==90 || c==90) {      // 직각 삼각형인가?
                result = "직각 삼각형입니다.";
            }   
            if (a>90 || b>90 || c>90) {     // 둔각 삼각형인가?
                result = "둔각 삼각형입니다.";
            }               
        } else {        // 삼각형이 아닐 때
            result = "삼각형이 아닙니다.";
        }
        System.out.println(result);
    }

def triangle(a):
     if sum(a) == 180 and len(a) == 3 and list(True if i>0 else False for i in a).count(False) == 0:
          print('직각삼각형' if a.count(90) == 1 else '둔각상각형' if a.sort()[2] > 90 else '예각삼각형')
     else:
          print('None')

C#

public void GetTriangle(int a, int b, int c)
    {
        int[] arr = new[] { a, b, c };

        if (a + b + c != 180)
        {
            Console.WriteLine("삼각형이 아닙니다");
        }
        else if (a < 90 && b < 90 && c < 90)
        {
            Console.WriteLine("예각 삼각형입니다.");
        }
        else if (a == 90 || b == 90 || c == 90)
            Console.WriteLine("직각 삼각형입니다");
        else
        {
            Console.WriteLine("둔각 삼각형입니다.");
        }
    }

def triangle(data):
    if len(data) !=3 : return print(data,'= 3각이 아니므로 삼각형이 아니다.')
    if sum(int(i) for i in data) != 180 : return print(data,"= 3각이 180이 아니므로 삼각형이 아니다.")

    for i in range(len(data)):
        if data[i] == 0 : return print(data,'= 0도는 삼각형이 아니다.')
        if data[i] == 90: return print(data,"= 직각 삼각형")
        if data[i] > 90 : return print(data,"= 둔각 삼각형")
    return print(data,"= 예각 삼각형")


data =[[60, 60, 60],[30, 60, 90],[20, 40, 120],[0, 90, 90],[60, 70, 80],[40, 40, 50, 50]]

for i in data:
    triangle(i)

using System;
using System.Linq;

namespace CD189
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] triangle;
            triangle = new int[] { 60, 60, 60 };
            Console.WriteLine(GetTriangleType(triangle));
            triangle = new int[] { 30, 60, 90 };
            Console.WriteLine(GetTriangleType(triangle));
            triangle = new int[] { 20, 40, 120 };
            Console.WriteLine(GetTriangleType(triangle));
            triangle = new int[] { 0, 90, 90 };
            Console.WriteLine(GetTriangleType(triangle));
            triangle = new int[] { 60, 70, 80 };
            Console.WriteLine(GetTriangleType(triangle));
            triangle = new int[] { 40, 40, 50, 50 };
            Console.WriteLine(GetTriangleType(triangle));
        }

        static string GetTriangleType(int[] anArray)
        {
            string result = String.Empty;
            if (IsTriangle(anArray))
            {
                result = AngleType(anArray.Max());
            }
            else
            {
                result = "삼각형이 아니다.";
            }
            return result;
        }

        static bool IsTriangle(int[] anArray) 
            => anArray.Min() > 0 && anArray.Length == 3 && anArray.Sum() == 180;

        static string AngleType(int anAngle)
        {
            string result = string.Empty;
            if (anAngle < 90)
            {
                result = "예각삼각형";
            }
            else if (anAngle > 90)
            {
                result= "둔각삼각형";
            }
            else
            {
                result = "직각삼각형";
            }
            return result;
        }
    }
}

import re
angle = []
input_str = input ("삼각형의 세 각을 입력하시오: ")
angle = list(map(int,  re.findall (r"[\w]+", input_str)))
def triangle (angle):
    sum_angle = 0
    for arga in angle: sum_angle += arga 
    if (len(angle)) != 3 or sum_angle != 180:
        print ('삼각형이 아닙니다!')
        return
    else: pass
    if 90 in angle:
        print ("직각입니다")
        return
    elif 90 < max(angle):
        print ("둔각입니다")
        return
    else:
        print ("예각입니다")
        return
triangle(angle)

문제 자체는 엄청 쉽지만, 어떻게 구현하면 가장 불필요한 연산 과정을 줄일 수 있을까 잠깐.. 아주 잠깐 고민해봤습니다.

• 삼각형의 세 각도 중 가장 큰 각도만 알면, 그 삼각형의 형태(예각, 직각, 둔각)를 알 수 있으므로 가장 큰 각을 구한 후 결과값을 추출합니다.
• 삼각형 각도 입력(Scanner) 중에 0보다 작은 값을 입력할 경우 바로 잘못된 입력을 고지합니다.(Return)
• 각도 크기 비교 전에 세 각의 합이 180도가 아닌 경우 삼각형이 아니라고 곧바로 출력합니다.(Return)

import java.util.Scanner;

public class getTriagleType {   
    public static void calAngle(int point) {
        if(point <= 0) {
            System.out.println("ERROR! : 삼각형의 각도는 0보다 커야 합니다.");
            return;
        }
    }

    public static void main(String[] args) {
        int calSlot_1 = 0;
        int calSlot_2 = 0;

        Scanner scanner = new Scanner(System.in);
        System.out.print("첫번째 삼각형의 각도를 입력하세요 > ");
        int point_1 = scanner.nextInt();
        calAngle(point_1);

        System.out.print("두번째 삼각형의 각도를 입력하세요 > ");
        int point_2 = scanner.nextInt();
        calAngle(point_2);

        System.out.print("세번째 삼각형의 각도를 입력하세요 > ");
        int point_3 = scanner.nextInt();
        calAngle(point_3);

        if(point_1 + point_2 + point_3 != 180) {
            System.out.println("ERROR! : 삼각형의 세 각의 합이 180도가 아니면, 삼각형이 아닙니다.");
            return;
        }

        if(point_1 >= point_2 ) {
            calSlot_1 = point_1;
        } else {
            calSlot_1 = point_2;
        }

        if(point_2 >= point_3 ) {
            calSlot_2 = point_2;
        } else {
            calSlot_2 = point_3;
        }

        if(calSlot_1 <= calSlot_2 ) {
            calSlot_1 = calSlot_2;
        }

        if(calSlot_1 < 90) {
            System.out.println("이 삼각형은 '예각 삼각형'입니다.");
        } else if(calSlot_1 == 90) {
            System.out.println("이 삼각형은 '직각 삼각형'입니다.");
        } else {
            System.out.println("이 삼각형은 '둔각 삼각형'입니다.");
        }

        return;
    }
}

int[][] arr = { { 60, 60, 60 }, { 30, 60, 90 }, { 20, 40, 120 }, { 0, 90, 90 }, { 60, 70, 80 },
                { 40, 40, 50, 50 } };

        for (int i = 0; i < arr.length; i++) {
            int sum = arr[i][0] + arr[i][1] + arr[i][2];
            Arrays.sort(arr[i]);
            if (arr[i].length != 3 || sum != 180 || arr[i][0] < 1) {
                System.out.println("삼각형이 아닙니다.");
            } else {

                if (arr[i][2] < 90) {
                    System.out.println("예각 삼각형.");
                } else if (arr[i][2] == 90) {
                    System.out.println("직각 삼각형.");
                } else if (arr[i][2] > 90) {
                    System.out.println("둔각 삼각형.");
                }
            }

def triangle(angle_lst):
    return len(angle_lst) is 3 and sum(angle_lst) is 180 and \
           all([0 < angle < 180 for angle in angle_lst])


for angle_lst in [[60, 60, 60], [30, 60, 90], [20, 40, 120], [0, 90, 90], [60, 70, 80], [40, 40, 50, 50]]:
    if not triangle(angle_lst):
        print('삼각형이 아니다')
    else:
        if max(angle_lst) > 90:
            print('둔각삼각형')
        elif max(angle_lst) is 90:
            print('직각삼각형')
        else:
            print('예각삼각형')

//[60, 60, 60] = 예각삼각형
//[30, 60, 90] = 직각삼각형
//[20, 40, 120] = 둔각삼각형
//[0, 90, 90] = 삼각형이 아니다
//[60, 70, 80] = 삼각형이 아니다
//[40, 40, 50, 50] = 삼각형이 아니다

//예각삼각형 : 3개의 각이 모두 예각인 삼각형
//직각삼각형 : 1개의 각이 직각인 삼각형
//둔각삼각형 : 1개의 각이 둔각인 삼각형
//① 각이 3개가 아닐 경우 삼각형이 아니다.
//② 3개의 각의 합이 180°가 아닐 경우 삼각형이 아니다.
#include <iostream>
#include <string>
#include <assert.h>

#define NOT_TRIANGLE        0
#define SHARP_TRIANGLE      1
#define DEGREE90_TRIANGLE   2
#define WIDE_TRIANGLE       3

using namespace std;

int DetectTriangle(int input[3]);

void test(void)
{
    int input[3] = {60, 60, 60};
    assert(SHARP_TRIANGLE == DetectTriangle(input));

    int input2[3] = {30, 60, 90};
    assert(DEGREE90_TRIANGLE == DetectTriangle(input2));

    int input3[3] = {20, 40, 120};
    assert(WIDE_TRIANGLE == DetectTriangle(input3));

    int input4[3] = {0, 90, 90};
    assert(NOT_TRIANGLE == DetectTriangle(input4));


}

int DetectTriangle(int input[3])
{
    if (input[0]+input[1]+input[2] != 180)
        return NOT_TRIANGLE;
    for (int i=0; i<3; i++) {
        if (input[i] <= 0)
            return NOT_TRIANGLE;
        if (180 <= input[i])
            return NOT_TRIANGLE;
    }

    for (int i=0; i<3; i++) {
        if (input[i] == 90)
            return DEGREE90_TRIANGLE;
        if (input[i] > 90)
            return WIDE_TRIANGLE;
    }

    for (int i=0; i<3; i++) {
        assert (input[i] < 90);   
    }
    return SHARP_TRIANGLE;
}

int main()
{
    test();
    //return 0;

    int input[3];
    for (int i=0; i<3; i++) {
        cout << "input " << i << " : ";
        cin >> input[i]; 
    }
    int result = DetectTriangle(input);
    switch (result) {
    case NOT_TRIANGLE:
        cout << "Not Triangle";
        break;
    case SHARP_TRIANGLE:
        cout << "Sharp Triangle";
        break;
    case DEGREE90_TRIANGLE:
        cout << "90 Degree Triangle";
        break;
    case WIDE_TRIANGLE:
        cout << "Wide Triangle";
        break;
    default:
        cout << "Error!";
        break;
    }
    return 0;

}

def test(xs):
  if len(xs) != 3 or sum(xs) != 180 or any(x <= 0 for x in xs):
    return '삼각형이 아니다'
  if any(x > 90 for x in xs):
    return '둔각삼각형'
  if any(x == 90 for x in xs):
    return '직각삼각형'
  return '예각삼각형'

파이썬 3입니다.

def triangle(angle_list):
    if eval('+'.join(angle_list)) != 180:
        return '삼각형이 아니다'
    for angle in angle_list:
        if not 0 < int(angle) < 180:
            return '삼각형이 아니다'
    for angle in angle_list:
        if int(angle) == 90:
            return '직각삼각형'
        if int(angle) > 90:
            return '둔각삼각형'
    return '예각삼각형'


while True:
    angles = input('세 각을 입력하세요 (띄어쓰기로 구분) : ').split()
    if not angles:
        break
    print(triangle(angles))

def Triangle(A) :
    if sum(A)!=180 :
        return print(str(A) + " = 삼각형이 아니다")
    elif len(A)!=3 :
        return print(str(A) + " = 삼각형이 아니다")
    else :
        for i in A :
            if i==0 :
                result = " = 삼각형이 아니다"   
                break
            elif i==90 :
                result = " = 직각삼각형"
                break
            elif i>90 :
                result = " = 둔각삼각형"
                break
            else :
                result = " = 예각삼각형"
    return print(str(A)+ result)

using Python followed by PEP8 style

def is_valid_triangle(interior_angles_list):
    result = False  # default result

    if len(interior_angles_list) == 3 and \
       sum(interior_angles_list) == 180 and \
       sum([1 for i in interior_angles_list if i > 0 & i <= 90]) == 3:

        result = True

    return result


def print_what_kind_of_triangle(interior_angles_list):
    if is_valid_triangle(interior_angles_list):

        if sum([1 for i in interior_angles_list if i > 90]) == 1:
            print("The figure is an obtuse triangle")  # 둔각 삼각형

        elif sum([1 for i in interior_angles_list if i == 90]) == 1:
            print("The figure is an angled triangle")  # 직각 삼각형

        else:  # 예각 삼각형
            print("The figure is an acute triangle")

    else:  # 삼각형이 아니다
        print("This figure is not triangle")

triangle = [30,90,60]

def is_angle(a_list):
    if(sum(a_list)!=180): return "삼각형이 아니다"
    elif(len(a_list)!=3): return "삼각형이 아니다"
    else:
        if(max(a_list) > 90): return "둔각삼각형"
        elif(max(a_list) == 90): return "직각삼각형"
        else: return "예각삼각형"

print(is_angle(triangle))

def triangle(l):
  if len(l) == 3 and sum(l) == 180:


    if max(l) > 90:
      print('둔각삼각형입니다.')
    elif max(l) == 90:
      print('직각삼각형입니다.')
    else:
      print('예각삼각형입니다.')

  else:
    print('삼각형이 아닙니다.')

ang=input('삼각형의 세 꼭짓점의 각도 입력: ');
if length(ang)~=3 || sum(ang)~=180  || min(ang)==0
    fprintf('삼각형이 아니다.\n');
else
    if max(ang) == 90
        fprintf('직각삼각형\n');
    elseif max(ang) > 90 && max(ang) < 180
        fprintf('둔각삼각형\n');
    elseif max(ang) < 90 && min(ang) > 0
        fprintf('예각삼각형\n');
    else
        fprintf('삼각형이 아니다.\n');
    end
end

x = sorted(map(float, input("삼각형의 세 각을 입력하시오 : ").split()))
if len(x) != 3 or sum(x) != 180 or all(x) == False : print("삼각형 X")
else :
    if (x[0] + x[1]) == x[2] : print("직각삼각형")
    elif (x[0] + x[1]) < x[2] : print("둔각삼각형")
    else : print("예각삼각형")

namespace codingdojang__
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input_array = Console.ReadLine().Split(',');

            bool obtuse = false;
            bool right = false;
            int angle = 0;
            int sum = 0;

            foreach (var i in input_array)
            {
                angle += int.Parse(i);
                sum += 1;
                if (int.Parse(i) == 90)
                {
                    right = true;
                }
                else if (int.Parse(i) > 90)
                {
                    obtuse = true;
                }
            }

            if (angle == 180 && sum == 3)
            {
                if (right == true)
                {
                    Console.WriteLine("직각 삼각형");
                }
                else if (obtuse == true)
                {
                    Console.WriteLine("둔각 삼각형");
                }
                else
                {
                    Console.WriteLine("예각 삼각형");
                }
            }
            else
            {
                Console.WriteLine("삼각형이 아님");
            }
        }
    }
}

det.triangle <- function(x){
  if (length(x) != 3){
    tri_result <- list(error = T, triangle = NULL)
    return(tri_result)
  } else if (sum(x) != 180){
    tri_result <- list(error = T, triangle = NULL)
    return(tri_result)
  } else if (any(x <= 0) | any(x > 180)){
    tri_result <- list(error = T, triangle = NULL)
    return(tri_result)
  } else if (any(x == 90)){
    tri_result <- list(error = F, triangle = 'right triangle')
    return(tri_result)
  } else if (any(x > 90)){
    tri_result <- list(error = F, triangle = 'obtuse triangle')
    return(tri_result)
  } else {
    tri_result <- list(error = F, triangle = 'acute triangle')
    return(tri_result)
  }
}
result.reader <- function(x){
  if (det.triangle(x)$error == T){
    print('not triangle')
  } else {
    print(det.triangle(x)$triangle)
  }
}

#include<stdio.h>


int main(void) 
{
    int i;
    int a[3];
    int x = 0;
    int y=0;
    int sum=0;
    printf("합이 180이 되도록 숫자 3개를 입력하세요:");
    for (i = 0; i < 3; i++)
    {
        scanf_s("%d", &a[i]);
        sum = sum + a[i];
        if (a[i] > 90)
            x++;
        else if (a[i] == 90)
            y++;

    }
    if(sum != 180)
        printf("삼각형이 아닙니다.");
    else if (x == 1 && y == 0)
        printf("둔각삼각형");
    else if (x == 0 && y == 1)
        printf("직각삼각형");
    else if (x == 0 && y == 0)
        printf("예각삼각형");


    return;

}

a = int(input("길이 입력 : "))
b = int(input("길이 입력 : "))
c = int(input("길이 입력 : "))
if a + b + c == 180 :
    if a == 0 or b == 0 or c == 0 :
        tri = "삼각형이 아니다"
    elif a == 90 or b == 90 or c  == 90 :
        tri = "직각삼각형"
    elif a < 90 and b < 90 and c < 90 :
            tri = "예각삼각형"
    elif a > 90 or b > 90 or c > 90 :
            tri = "둔각삼각형"
else :
    tri = "삼각형이 아니다."
print(tri)

tri = list(map(int,input().split()))

def what_triangle(tri):
    if 0 in tri or len(tri) != 3 or sum(tri) != 180:
        return '삼각형이 아닙니다'
    else:
        for i in tri:
            if i > 90:
                return '둔각삼각형'
            elif i == 90:
                return '직각삼각형'
            else:
                continue
        return '예각삼각형'

print(what_triangle(tri))

def Triangle_ex(*args):
    if sum(args)!=180 or min(args)<=0 or len(args)!=3: return "삼각형이 아닙니다."
    elif max(args)>90: return "둔각삼각형"
    elif 90 in args: return "직각삼각형"
    else: return "예각삼각형"    #else 생략가능

print(Triangle_ex(10,80,90))

function triangle(arr){
  let sum = 0
  let over90 = false
  let on90 = false
  for(let i = 0; i< arr.length; i++){
    sum +=arr[i]
    if(arr[i]=== 0){
      return '삼각형이 아니다'
    }else if(arr[i] === 90){
      on90 = true
    }else if(arr[i]>90){
      over90 = true
    }
  }
  if(sum !==180|| arr.length !== 3){
    return '삼각형이 아니다.'
  }else if(on90 === true){
    return '직각 삼각형'
  }else if(over90 === true){
    return '둔각 삼각형'
  }else{
    return '예각 삼각형'
  }
}

def check_triangle(angle):
    if 90 in angle:
        return '직각삼각형'
    elif len(angle) != 3 or min(angle) <= 0 or sum(angle) != 180:
        return '삼각형이 아니다'

    for x in angle:
        if x > 90:
            return '둔각삽각형'
    return '예각삼각형'

static void Main(string[] args)
        {
            Console.WriteLine("*** 코딩도장 Q189 ***");

            // 입력받기
            Console.Write("각도를 ',' 로 구분하여 입력하세요 : ");
            string userInput = Console.ReadLine();
            string[] convertInput = userInput.Split(',');

            int[] convertInt = new int[3];
            int tmp = 0;
            bool gakDo = false;

            // 입력받은 각도를 숫자배열로 반환, 3개 이상일 경우 오류
            try
            {
                foreach (string i in convertInput)
                {
                    convertInt[tmp] = int.Parse(i);
                    Console.WriteLine((tmp + 1) + " 번째 각도는 " + i + " 도 입니다.");
                    tmp++;
                }
            }
            catch (Exception)
            {
                Console.WriteLine("입력한 각도가 3개 이상이므로 삼각형이 아닙니다.");
            }

            if (convertInt.Length==3 && convertInt.Sum()==180 && !convertInt.Contains<int>(0))
            {
                if (convertInt.Contains<int>(90))
                {
                    Console.WriteLine("직각 삼각형 입니다.");
                }
                else
                {
                    foreach (int j in convertInt)
                    {
                        if (j>=120)
                        {
                            gakDo = true;
                        }
                    }
                    if (gakDo==true)
                    {
                        Console.WriteLine("둔각 삼각형입니다.");
                    }
                    else
                    {
                        Console.WriteLine("예각 삼각형입니다.");
                    }
                }
            }
            else
            {
                Console.WriteLine("삼각형이 아닙니다.");
            }
        }

input_angle = [60,60,60]

if sum(input_angle) != 180 or len(input_angle) != 3:
    print(f"{input_angle} = 삼각형이 아니다")
elif max(input_angle) == 90:
    print(f"{input_angle} = 직각삼각형")

elif max(input_angle) > 90:
    print(f"{input_angle} = 둔각삼각형")

elif max(input_angle) < 90:
    print(f"{input_angle} = 예각삼각형")

angle=list(map(int,input().split()))

if sum(angle)!=180 or 0 in angle or len(angle)!=3:
    print("삼각형이 아니다.")

elif 90 in angle:
    print("직각삼각형")

    for i in angle:
        if i>90:
            print("둔각감각형")
else:
    print("예각삼각형")

def main():
    file_input = open("3.inp", "r")
    file_output = open("triangle.out", "w")

    a = int(file_input.readline())
    b = int(file_input.readline())
    c = int(file_input.readline())

    top = max(a, b, c)
    sum_of_power = a**2 + b**2 + c**2 - top**2

    if top < a + b + c - top:
        if top**2 > sum_of_power:
            file_output.write("obtuse")
        elif top**2 < sum_of_power:
            file_output.write("acute")
        else:
            file_output.write("right")
    else:
        file_output.write("no")

    file_input.close()
    file_output.close()

if __name__ == "__main__":
    main()

lis = list(map(int, input('>>>').split(',')))
lis.sort()
if len(lis)!=3 or sum(lis)!=180 or lis[0]<=0:
    print(lis, '= 삼각형이 아니다')
elif lis[0]+lis[1]>lis[2]: print(lis, '= 예각삼각형')
elif lis[0]+lis[1]==lis[2]: print(lis, '= 직각삼각형')
else: print(lis, '= 둔각삼각형')

내 나름의 최선.

from functools import reduce
def triangle(lst):
    if (len(lst) > 3) or (reduce(lambda x, y: x+y, lst) != 180) or ((len([i for i in lst if i ==0])) >= 1):
        print(lst, '= 삼각형이 아니다.')
    else:
        if len([i for i in lst if i < 90]) ==3:
            print(lst, '= 예각삼각형')
        elif len([i for i in lst if i ==90]) ==1:
            print(lst, '= 직각삼각형')
        elif len([i for i in lst if i > 90]) ==1:
            print(lst, '= 둔각삼각형')

test = [[60, 60, 60],[30, 60, 90],[20, 40, 120],[0, 90, 90],[60, 70, 80],[40, 40, 50, 50]]

for t in test:
    triangle(t)

list1 = [60, 60, 60] # 예각

list1 = [30, 60, 90] # 직각

list1 = [20, 40, 120] # 둔각

list1 = [0, 90, 90] # 삼각형아님

list1 = [60, 70, 80] # 삼각형아님

list1 = [40, 40, 50, 50]

sum = 0

if len(list1) == 3 : for i in range(len(list1)): sum += list1[i] if sum != 180: print("삼각형이 아니다.") elif sum == 180: if list1[0]<90 and list1[1]<90 and list1[2]<90: print("예각삼각형") if list1[0]== 90 or list1[1]== 90 or list1[2]== 90: if list1[0]== 0 or list1[1]== 0 or list1[2]== 0: print("삼각형이 아니다") else: print("직각삼각형")

    if list1[0]> 90 or list1[1]> 90 or list1[2]> 90:
        print("둔각삼각형")

elif len(list1) !=3 : print("삼각형이 아니다.")

def istri(L) :
    if sum(L) == 180 and len(L) == 3 and 0 not in L :
        for i in L :
            if i > 90 :
                print('둔각삼각형')
                break
            elif i == 90 :
                print('직각삼각형')
                break
        else :
            print('예각삼각형')
    else :
        print('삼각형이 아니다')

def solution(mylist):
    if sum(mylist) != 180 or len(mylist) != 3:
        return "삼각형이 아니다"
    for i in range(len(mylist)):
        if mylist[i] == 0:
            return "삼각형이 아니다"
        if mylist[i] == 90:
            return "직각삼각형"
        if mylist[i] > 90:
            return "둔각삼각형"
    return "예각삼각형"

print(solution([60, 60, 60]))
print(solution([30, 60, 90]))
print(solution([20, 40, 120]))
print(solution([0, 90, 90]))
print(solution([60, 70, 80]))
print(solution([40, 40, 50, 50]))

python 3.7

t1=[60, 60, 60] # 예각삼각형
t2=[30, 60, 90] # 직각삼각형
t3=[20, 40, 120] #= 둔각삼각형
t4=[0, 90, 90] #= 삼각형이 아니다
t5=[60, 70, 80] #= 삼각형이 아니다
t6=[40, 40, 50, 50] # 삼각형 아님

def what_triang(angle):
    if len(angle) > 4 or sum(angle) != 180 :
        return "It is not a triangle!"
    elif max(angle) > 90:
        return "Obtuse triangle"
    elif 90 in angle:
        return "Right triangle"
    else :
        return "Acute triangle"

print(t1, ":", what_triang(t1))
print(t2, ":", what_triang(t2))
print(t3, ":",what_triang(t3))
print(t4, ":",what_triang(t4))
print(t5, ":",what_triang(t5))
print(t6, ":",what_triang(t6))

angle=[]
while True:
    a=input("각 입력: ")
    if a=="종료":
        break
    else:
        angle.append(int(a))
print(angle)
if len(angle) !=3:
    print("삼각형이 아니다")
elif sum(angle) !=180:
    print("삼각형이 아니다")
elif angle.count(0):
        print("삼각형이 아니다")
else:
    if angle[0]<90 and angle[1]<90 and angle[2]<90:
        print("예각 삼각형")
    elif angle[0]>90 or angle[1]>90 or angle[2]>90:
        print("둔각 삼각형")
    elif angle[0]==90 or angle[1]==90 or angle[2]==90:
        print("직각 삼각형")

a = list(map(int, input().split(' ')))
def Division(length):
    if len(length) == 3:
        for i in length:
            if i == 0:
                return "삼각형이 아닙니다."
        if sum(length) != 180:
            return "삼각형이 아닙니다."
        elif sum(length) == 180:
             if max(length) > 90:
                return "둔각삼각형"
             elif max(length) == 90:
                return "직각삼각형"
             else:
                return "예각삼각형"
    else:
        return "삼각형이 아닙니다."
print(Division(a))

def Triangle(data):
    if len(data) == 3:
        if min(data) > 0 :
            if sum(data) == 180:
                if max(data) < 90:
                    print("예각 삼각형")
                elif max(data) == 90:
                    print("직각 삼각형")
                elif max(data) > 90 :
                    print("둔각 삼각형")
            else :
                print("삼각형이 아니다.")    
        else :
            print("삼각형이 아니다.")    
    else :
          print("삼각형이 아니다.")    

Triangle([60, 60, 60])
Triangle([30, 60, 90])
Triangle([20, 40, 120])
Triangle([0, 90, 90])
Triangle([60, 70, 80])
Triangle([40, 40, 50, 50])

public class 삼각형구별하기 {

    public static void Middle(int[] a) {
        int count = 0;
        if(a.length==3&&a[0]+a[1]+a[2]==180&&a[0]!=0&&a[1]!=0&&a[2]!=0) {
            for(int i = 0; i<a.length; i++) {
                if(a[i]==90) {
                    System.out.println("직각삼각형");
                    break;
                }
                else if(a[i]>90) {
                    System.out.println("둔각삼각형");
                    break;
                }
                else {
                    count++;
                }
            }
            if(count==3) {
                System.out.println("예각삼각형");
            }
        }
        else {
            System.out.println("삼각형이 아니다");
        }
    }
    public static void main(String[] args) {

        int[] list1 = {60, 60, 60};
        int[] list2 = {30, 60, 90};
        int[] list3 = {20, 40, 120};
        int[] list4 = {0, 90, 90};
        int[] list5 = {60, 70, 80};
        int[] list6 = {40, 40, 50, 50};
        Middle(list1);
        Middle(list2);
        Middle(list3);
        Middle(list4);
        Middle(list5);
        Middle(list6);
    }
}

파이썬

def is_tri(n):
    if len(n)==3 and sum(n)==180 and min(n) != 0:    # and 나 or  대신 &, | 을 썼더니 계속 에러나서 하루를 날렸네요;;;
        if max(n) == 90:
            return "직각삼각형"
        elif max(n) > 90:
            return "둔각삼각형"
        else:
            return "예각삼각형"
    elif len(n) !=3 or sum(n) != 180 or min(n) == 0:
        return "삼각형이 아닙니다."

if __name__ == "__main__":
    angle_list=[[60, 60, 60], [30, 60, 90], [0, 90, 90],
                   [20, 40, 120], [60, 70, 80], [40, 40, 50, 50]]

    for i, angles in enumerate(angle_list):
        print(f'{i+1}. {is_tri(angles)}')

#1. 예각삼각형
#2. 직각삼각형
#3. 삼각형이 아닙니다.
#4. 둔각삼각형
#5. 삼각형이 아닙니다.
#6. 삼각형이 아닙니다.

파이썬입니다.

def triangle(*v):
  if len(v) !=3 or sum(v) != 180 or min(v) <= 0: print('삼각형이 아님')
  else: print('둔각삼각형' if max(v) > 90 else '직각삼각형' if max(v) == 90 else '예각삼각형')

angles=list(map(int,input("삼각형의 각들(ex- 60,60,60)을 입력하십시오: ").split(",")))
def ta(angles):
    if min(angles) <= 0 or len(angles) !=3 or sum(angles) != 180:
        return "삼각형이 아닙니다."
    else:
        if 90 in angles:
            return "직각 삼각형입니다."
        if angles[0] > 90 or angles[1] > 90 or angles[2] > 90:
            return "둔각 삼각형입니다."
        if angles[0] < 90 or angles[1] < 90 or angles[2] < 90:
            return "예각 삼각형입니다."
print(ta(angles))

def triangle(*args):
    judgement1 = 0
    judgement2 = 0
    for i in args:
        judgement1 += 1
    list1 = [int(x) for x in args]
    if judgement1 == 3 :
        for k in args:
            judgement2 += int(k)
        if judgement2 == 180:
            if len(list(filter(lambda x : x <= 60, list1))) == 3:
                print("예각삼각형")
            elif any(list(filter(lambda x : x == 90, list1))) :
                print("직각삼각형")
            else :
                print("둔각삼각형")
        else:
            print("삼각형이 아니다")
    else :
        print("삼각형이 아니다")

triangle(40,20,120)

while(True):
    N = input().split()
    if len(N) == 3:break
check = 0
for i in range(len(N)):N[i] = int(N[i])
for i in range(len(N)):
    if N[i] == 0 or sum(N) != 180:
        check = 0
        break
    elif N[i] == 90:
        check = 1
        break
    elif N[i] > 90:
        check = 2
        break
    elif N[i] < 90:
        check = 3

if check == 0:print('삼각형이 아니다')
if check == 1:print('직각삼각형')
if check == 2:print('둔각삼각형')
if check == 3:print('예각삼각형')

a = list(input("숫자를 입력: ").split(","))

b = list(map(int, a))

if sum(b) != 180 or len(b) != 3 :
    print("삼각형이 아닙니다.")

elif 0 in b:
    print("삼각형이 아닙니다.")

elif 90 in b:
    print("직각삼각형")

elif max(b) > 90:
    print("둔각삼각형")

else:
    print("예각삼각형")

def triangle(angle_list):
        if len(angle_list) != 3:
                result = "삼각형이 아닙니다."
                return result
        elif type(angle_list[0]) != 'int' or type(angle_list[1]) != 'int' or type(angle_list[2] != 'int':
                result = "삼각형이 아닙니다."
                return result
        elif angle_list[0] + angle_list[1] + angle_list[2] != 180:
                result = "삼각형이 아닙니다."
                return result
        else:
                for i in range(0, 3):
                        if angle_list[i] > 90:
                                result = "둔각삼각형"
                                return result
                        elif angle_list[i] == 90:
                                result = "직각삼각형"
                                return result
                        else:
                                result = "예각삼각형"
                                return result


a = triangle([23, 56, 37, 67]) # 각이 4개
b = triangle(["angle", 4.5, 28]) #숫자가 아님
c = triangle([23, 56, 78]) # 180도 아님
d = triangle([56, 47, 77]) # 예각삼각형
e = triangle([90, 45, 45]) # 직각삼각형
f = triangle([150, 23, 7]) # 둔각삼각형

print a
print b
print c
print d
print e
print f

"삼각형이 아닙니다." "삼각형이 아닙니다." "삼각형이 아닙니다." "예각삼각형" "직각삼각형" "둔각삼각형"

a = int(input(" a:"))

b = int(input(" b:"))

c = int(input(" c:"))

if (a+b+c) != 180 or  a==0 or b==0 or c==0:

    print("삼각형 아님")

elif a < 90 and b < 90 and c < 90 :

    print("예각 삼각형")

elif a==90 or b==90 or c == 90:

    print("직각삼각형")

else:
    print("둔각 삼각형")

def choose_tri(a, b, c): if (a and b and c <90) and (a+b+c==180): print("예각 삼각형") elif (a or b or c == 90) and (a+b+c==180): print("직각 삼각형") elif (a or b or c > 90) and (a+b+c==180): print("둔각 삼각형") else: print("삼각형이 아니다.")

def choose_tri2(a, b, c, d): print("삼각형이 아니다.")

print(choose_tri(60, 60, 60)) print(choose_tri(30, 60, 90)) print(choose_tri(20, 40, 120)) print(choose_tri(0, 90, 90)) print(choose_tri(60, 70, 80)) print(choose_tri2(40, 40, 50, 50))

Python 3.8.1

def func(angles):
    if sum(angles) == 180 and min(angles) > 0:
        if max(angles) == 90:
            return "직각삼각형"
        elif max(angles) > 90:
            return "둔각삼각형"
        else:
            return "예각삼각형"
    else:
        return "삼각형이 아님"

a = int(input("각 1 : "))
b = int(input("각 2 : "))
c = int(input("각 3 : "))

result = func([a, b, c])
print(result)

def tri(lst):
    if len(lst)==3:
        a,b,c = lst
        if a+b+c == 180:
            if a<90 and b<90 and c<90:
                return '예각삼각형'
            elif 90 in lst:
                return '직각삼각형'
            else:
                return '둔각삼각형'
        else:
            return '삼각형이 아니다'
    else:
        return '삼각형이 아니다'

def tri(*arg):
    count = 0
    result = []
    for i in arg:
        result.append(int(i))
        count += 1
    result.sort()
    if sum(result) == 180 and len(result) == 3 and not 0 in result:
        if result[count-1] == 60:
            print("예각")
        elif result[count-1] == 90:
            print("직각")
        elif result[count-1] > 60:
            print("둔각")
        else:
            print("not triangle")
    else:
        print("Not triangle")

try :
    a,b,c=map(int,input().split())
    if a+b+c==180 :
        if a!=0 and b!=0 and c!=0:
            if a==90 or b==90 or c==90:
                print('직각삼각형')
            elif a<90 and b<90 and c<90:
                print('예각삼각형')
            else:
                print('둔각삼각형')
        else:
            print('삼각형이 아니다')
    else:
        print('삼각형이 아니다')
except:
    print('삼각형이 아니다')

def angle_triangle(data):
    data.sort()
    if sum(data)!=180:
        return "It's not a triangle."
    if data[2]<90:
        return "It's a acute triangle."
    if data[2]==90:
        return "It's a right triangle."
    if data[2]>90:
        return "It's a obtuse triangle."

추가로 세 변의 길이로부터 삼각형을 구분하는 프로그램을 작성했습니다.

def length_triangle(data):
    data.sort()
    if data[0]+data[1]<=data[2]:
        return "It's not a triangle."
    if data[0]**2+data[1]**2<data[2]**2:
        return "It's a obtuse triangle."
    if data[0]**2+data[1]**2==data[2]**2:
        return "It's a right triangle."
    if data[0]**2+data[1]**2>data[2]**2:
        return "It's a acute triangle"

#파이썬

#각 3개를 내림차순으로 정리한후,
#제일 첫값이 90보다 큰지, 90인지를 판별하여 
#각각 둔각 삼각형, 직각삼각형으로 분류하고
#그렇지 않을경우 예각삼각형으로 분류

tri=str(input('a b c.....')).split(' ')
for i in range (len(tri)):
   tri[i]=int(tri[i])

if len(tri)==3:  
   if sum(tri)==180:
      if not (tri.count(90)==2 or (0 in tri)):
         tri.sort(reverse=True) 
         if tri[0]>90:
            print ('둔각 삼각형')
         elif tri[0]==90:
            print ('직각 삼각형')
         else:
            print ('예각 삼각형')

      else:
         print('삼각형 아님')   
   else:
      print('삼각형 아님')
else:
   print('삼각형 아님')

int Triangle(double a, double b, double c)
{
   if((a <= 0) || (b <= 0) || (c <= 0))  return 0;

   double angle = a+b+c;
   if(angle != 180f) return 0;

  if((a > 90f) || (b > 90f) || (c > 90f))  return 1;
  if((a == 90f) || (b == 90f) || (c == 90f))  return 2;

  return 3;
}

def tri(a,b,c):

    if a+b+c ==180:
        if max(a,b,c)>90:
            print('둔각삼각형')
        elif max(a,b,c)==90:
            print('직각삼각형')
        else:print('예각삼각형')

    else:print('삼각형 아님')

a = [int(x) for x in input().strip().split()]

if len(a) != 3 or sum(a) != 180:    
    print("삼각형이 아닙니다")  
else:
    if max(a) < 90:
        print("예각삼각형")
    elif max(a) > 90:
        print("둔각삼각형")
    else:
        print("직각삼각형")

 각도를 띄어쓰기해주시면 알아서 삼각형을 판단해줍니다

def triangle(n):
    List=list(map(int,n.split(",")))
    k=0
    for i in List:
        k=k+i
    if len(List)!=3 or k!=180 or List.count(0)==1:
        print(str(List)+" = "+"삼각형이 아니다")

    else:
        yeah=0
        dun=0
        zik=0
        for i in List:
            if i>90:
                dun=dun+1
            if i==90:
                zik=zik+1
            if i<90:
                yeah=yeah+1
        if yeah==3:
            print(str(List) + " = " + "예각삼각형")
        elif zik==1:
            print(str(List) + " = " + "직각삼각형")
        else:
            print(str(List) + " = " + "둔각삼각형")
N=input()
triangle(N)

import java.util.Arrays;
import java.util.Scanner;

public class Q187 {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String[] input = scan.nextLine().split(",");
        int angleSum = 0;
        int obtuse = 0;
        for (int i = 0; i < input.length; i++) {
            int temp = Integer.parseInt(input[i]);
            angleSum += temp;
            if (temp > 90) {
                obtuse++;
            }
        }

        if (input.length != 3 || angleSum != 180 || Arrays.asList(input).contains("0")) {
            System.out.println("삼각형이 아니다.");
        } else if (Arrays.asList(input).contains("90")) {
            System.out.println("직각삼각형");
        } else if (obtuse != 0) {
            System.out.println("둔각삼각형");
        } else {
            System.out.println("예각삼각형");
        }

        scan.close();
    }
}

lst=list(map(int, input().split(',')))
if len(lst)!=3:
    print('삼각형이 아니다')
elif sum(lst)!=180:
    print('삼각형이 아니다')
else:
    lst.sort()
    if lst[0]==0 or lst[1]==0 or lst[2]==0:
        print('삼각형이 아니다')
    elif lst[2]<90:
        print('예각 삼각형')
    elif lst[2]==90:
        print('직각 삼각형')
    else:
        print('둔각삼각형')

#include <iostream>
using namespace std;
/* 3개의 각으로 삼각형의 예각, 직각, 둔각을 구별하는 프로그램을 만들어라.

[60, 60, 60] = 예각삼각형
[30, 60, 90] = 직각삼각형
[20, 40, 120] = 둔각삼각형
[0, 90, 90] = 삼각형이 아니다
[60, 70, 80] = 삼각형이 아니다
[40, 40, 50, 50] = 삼각형이 아니다

예각삼각형 : 3개의 각이 모두 예각인 삼각형
직각삼각형 : 1개의 각이 직각인 삼각형
둔각삼각형 : 1개의 각이 둔각인 삼각형
① 각이 3개가 아닐 경우 삼각형이 아니다.
② 3개의 각의 합이 180°가 아닐 경우 삼각형이 아니다.. */
#include <iostream>
using namespace std;

int main()
{
    int gack[3],total=0;
    bool small = false;
    bool big = false;
    bool gikak = false;
    cout << "각들을 입력하세용\n";
    for (int i = 0; i < 3; i++)
    {
        cin >> gack[i];
    }


    if ((gack[0]+gack[1]+gack[2]) == 180)
    {
        for (int i = 0; i < 3; i++)
        {
            if (gack[i] > 90)
                big = true;
            else if (gack[i] == 90)
                gikak = true;
        }
        if((big==false)&&(gikak==false))
            small =true;

        if (big)
        {
            cout << "둔각삼각형!";
        }
        else if (gikak)
            cout << "직각삼각형!";
        else
            cout << "예각 삼각형!!";

    }
    else
        cout << "삼각형이 아닌데여?";



    return 0;
}

#include <stdio.h>

int main(){
    int a,b,c;

    scanf("%d",&a);
    scanf("%d",&b);
    scanf("%d",&c);

    if(a+b+c!=180 && a<=0 && b<=0 && c<=0);
        printf("삼각형이 아닙니다");
    else
        if(a==90 || b==90 || c==90);
            printf("직각삼각형입니다.");
        else if(a>90 || b>90 || c>90)
            printf("둔각삼각형입니다.");
        else
            printf("예각삼각형입니다.");
    return 0; 

}

namespace _60일차_9월30일
{        
    class MainApp
    {
        static void Main(string[] args)
        {
            //배열 입력 받기
            Console.Write("Input Triangle Data (Split Setting : ','): ");
            string input_Data = Console.ReadLine();
            string[] string_Array = input_Data.Split(',');
            int[] int_Array = System.Array.ConvertAll<string, int>(string_Array, int.Parse);

            //판별용 임시 데이터 선언
            int total = 0;
            int cnt = 0;

            //입력값 합계 초기화[180 이하 / 이상 판별용]
            for (int j = 0; j < int_Array.Length; j++)
            {
                total += int_Array[j];
            }

            //삼각형 판별용 로직[삼각형 종류에따른 cnt 값 설정]
            for (int i = 0; i < int_Array.Length; i++)
            {
                if (int_Array[i] < 90 && int_Array[i] > 1)
                { cnt++; }

                else if (int_Array[i] == 90)
                { cnt++; cnt++; }

                else if (int_Array[i] > 90)
                { cnt++; cnt++; cnt++; }

                else if (int_Array[i] == 0)
                { cnt++; cnt++; }
            }

            //설정된 배열 출력
            Console.Write("[");
            foreach (int Temp in int_Array)
                Console.Write($" {Temp} ");
            Console.Write("] = ");

            //삼각형 여부 판단 로직
            if (total == 180)
            {
                switch (cnt)
                {
                    case 3:
                        Console.Write("예각삼각형");
                        break;
                    case 4:
                        Console.Write("직각삼각형");
                        break;
                    case 5:
                        Console.Write("둔각삼각형");
                        break;
                    default:
                        Console.Write("삼각형이 아니다");
                        break;
                }
            }
            else
                Console.WriteLine("삼각형이 아니다");
        }
    }
}

def Check_tri(k):
    if sum(k)!=180 or len(k)!=3 or 0 in k:
        print('삼각형이 아니다')
    else:
        if max(k)>90:
            print('둔각삼각형')
        elif max(k)<90:
            print('예각삼각형')
        else:
            print('직각삼각형')
Check_tri([60,60,60])
Check_tri([30,60,90])
Check_tri([20,40,120])
Check_tri([0,90,90])
Check_tri([60,70,80])
Check_tri([40,40,50,50])

class identifyList:
    def __init__(self):
        self.result = ""
    def doTri(self,list):
        izero = 0
        for i in list:
            if i==0:
                izero = 1
        if izero==1:
            list.remove(0)
        if len(list)==3:
            sum = list[0]+list[1]+list[2]
            if sum==180:
                self.result = "An acute triangle"
                for i in list:
                    if i==90:
                        self.result = "A right triangle"
                    elif i>90:
                        self.result = "An obtuse triangle"
            else:
                self.result = "Not a triangle."
        else:
            self.result = "Not a triangle."
        print (list,self.result)

a = identifyList()
a.doTri([60,60,60])
a.doTri([30,60,90])
a.doTri([20,40,120])
a.doTri([0,90,90])
a.doTri([60,70,80])
a.doTri([40,40,50,50])

def triangle(angle):
    result = ""
    if len(angle)!=3 or sum(angle)!=180 or 0 in angle:  result += "삼각형이 아니다"
    elif 90 in angle:   result += "직각삼각형"
    elif max(angle) > 90:   result += "둔각삼각형"
    else:   result += "예각삼각형"
    print(result)

triangle([60, 60, 60])
triangle([30, 60, 90])
triangle([20, 40, 120])
triangle([0, 90, 90])
triangle([60, 70, 80])
triangle([40, 40, 50, 50])

def decide(lis):
    if len(lis) == 3 :
        a = lis[0]
        b = lis[1]
        c = lis[2]

        if a*b*c == 0 :
            return print("삼각형이 아니다")
        elif a+b+c != 180 :
            return print("삼각형이 아니다")
        else:
            deci = 0
            for temp in lis:
                if temp > 90:
                    deci = 1
                elif temp == 90:
                    deci = 2
            if deci == 0:
                return print("예각삼각형")
            elif deci == 1:
                return print("둔각삼각형")
            elif deci == 2:
                return print("직각삼각형")

    else:
        return print("삼각형이 아니다")

decide([40,40,50,50])

def tir(list):

  list.sort()

  if len(list)!=3 or list[0]+list[1]+list[2]<180:

    print("not triangle")

  elif list[0]==0:

    print("not triangle")

  elif list[0]+list[1]<list[2]:

    print("obtuse tirangle")

  elif list[0]+list[1]==list[2]:

    print("Right triangle")

  else:

    print("Acute triangle")

tir([60,60,60])

tir([30,60,90])

tir([20,40,120])

tir([0,90,90])

def triangle(x):
    if len(x)!=3:
        return "삼각형이 아닙니다."
    elif max(x)>90:
        return "둔각삼각형"
    elif max(x)<90 : 
        return "예각삼각형"
    else :
        return "직각삼각형"

l = [60, 60, 60]
if len(l) != 3 or sum(l)!=180 or min(l) <= 0: print("삼각형이 아니다")
elif 90 in l: print("직각삼각형")
elif max(l) >90 : print("둔각삼각형")
else : print("예갹삼각형")

python 3.8.7입니다.

>>> def tri_test(*angles):
...     if len(angles) != 3 or sum(angles) != 180 or min(angles) <= 0:
...         return "삼각형이 아니다"
...     elif max(angles) == 90:
...         return "직각삼각형"
...     elif max(angles) > 90:
...         return "둔각삼각형"
...     else:
...         return "예각삼각형"
...
>>> tri_test(70, 50, 60)
'예각삼각형'
>>> tri_test(1, 2, 3, 174)
'삼각형이 아니다'
>>> tri_test(-90, 100, 170)
'삼각형이 아니다'
>>> tri_test(45, 45, 90)
'직각삼각형'
>>> tri_test(120, 30, 30)
'둔각삼각형'

음수 각이 입력될 경우도 고려했습니다.

tri = list(map(int, input("입력: ").split(', ')))
tri.sort()
total = sum(tri)

if len(tri) != 3 or total != 180 or tri[0]<=0:
    print('삼각형이 아니다')
elif tri[-1] == 90:
    print('직각삼각형')
elif tri[-1] > 90:
    print('둔각삼각형')
else:
    print('예각삼각형')

def check_tri(li):
    if len(li) == 3 and sum(li) == 180 and li.count(0) == 0:
        if 90 in li:
            print("직각 삼각형입니다")

        elif max(li) > 90:
            print("둔각 삼각형입니다")

        else:
            print("예각 삼각형입니다.")

    else:
        print("삼각형 아닙니다")

li = [[80, 40, 60],
[30, 60, 90],
[20, 40, 120],
[0, 90, 90],
[60, 70, 80],
[40, 40, 50, 50]]

for i in li:
    check_tri(i)

def Triangle(X):
    Angle_sum = sum(X)
    if Angle_sum != 180 or len(X) !=3 or min(X) <= 0:
        return('No Triangle')
    if 90 in X:
        return('직각')
    elif max(X) > 90:
        return('둔각')
    elif min(X) < 90:
        return('예각')

A = [-60, 60, 180]
B = [30, 60, 90]
C = [20, 40, 120]
D = [0, 10, 170]

print(Triangle(A))

xyz=list(map(int, (input('각도 입력').split(','))))

def is_triangle(e):
    count = 0

    if len(e) != 3 :
        return '삼각형이 아니다'

    if sum(e) != 180 :
        return '삼각형이 아니다'

    for i in e :
        if i == 0 :
            return '삼각형이 아니다'
        if i > 90 :
            return '둔각삼각형'
        if i == 90 :
            return '직각삼각형'
        if i < 90 :
            count += 1
            if count == 3:
                return '예각삼각형'

print(is_triangle(xyz))

def check_triangle(n):
    if len(n) != 3 or sum(n) != 180 or n.count(0) != 0:
        print('삼각형이 아니다')
    else:
        if len([x for x in n if x==90])==1:
            print('직각삼각형')
        elif len([x for x in n if x>90])==1:
            print('둔각삼각형')
        elif len([x for x in n if x<90])==3:
            print('예각삼각형')

check_triangle([60,60,60])
check_triangle([30,60,90])
check_triangle([20,40,120])
check_triangle([0,90,90])
check_triangle([60,70,80])
check_triangle([40,40,50,50])

a = [20, 40, 120]
if len(a) != 3 or sum(a) != 180 or (0 in a):
     print("삼각형이 아니다")
elif len([i for i in a if i < 90]) == 3:
     print("예각삼각형")
elif len([i for i in a if i == 90]) == 1:
     print("직각삼각형")
else: print("둔각삼각형")

#판별 조건에 삼각형의 정의 써야하는데 귀찮네요 ㅅㄱ

def max_of_ang(a): #list를 받아 그중 최댓값을 반환
    maximum = a[0]
    for i in range(1, len(a)):
        if a[i]>maximum:
            maximum = a[i]
    return maximum

def kind_of_triangle(lst):#각의 리스틀 받아 삼각형 판별
    if not(sum(lst) == 180 and len(lst) == 3 and min(lst)>0): return "삼각형이 아닙니다."
    if max_of_ang(lst) > 90: return "둔각삼각형입니다."
    elif max_of_ang(lst) == 90: return "직각삼각형입니다."
    elif max_of_ang(lst) < 90: return "예각삼격형입니다."
    else: pass

a = [60, 60, 60]
b = [30, 60, 90]
c = [20, 40, 120]
d = [0, 90, 90]
e = [60, 70, 80]
f = [40, 40, 50, 50]

print(kind_of_triangle(a))
print(kind_of_triangle(b))
print(kind_of_triangle(c))
print(kind_of_triangle(d))
print(kind_of_triangle(e))
print(kind_of_triangle(f))

#codingdojing_triangle

a = [60, 60, 60]
b = [30, 60, 90]
c = [20, 40, 120]
d = [0, 90, 90]
e = [60, 70, 80]
f = [40, 40, 50, 50]

K = sorted(f)


if len(K) != 3:
    print("삼각형이 아니다")
else:
    if sum(K) != 180:
        print("삼각형이 아니다")
    elif not all(K):
        print("삼각형이 아니다")
    else:
        if K[2] < 90:
            print("예각삼각형")
        elif K[2] == 90:
            print("직각삼각형")
        else:
            print("둔각삼각형")

파이썬 3.8.10으로 작성되었습니다.

def what_triangle_is(data):
    if len(data) == 3 and sum(data) == 180 and 0 not in data:
        if max(data) > 90:
            print(f'{data} = 둔각삼각형')
        elif 90 in data:
            print(f'{data} = 직각삼각형')
        else:
            print(f'{data} = 예각삼각형')
    else:
        print(f'{data} = 삼각형이 아니다')

triangle_data = [[60, 60, 60], [30, 60, 90], [20, 40, 120],
                 [0, 90, 90], [60, 70, 80], [40, 40, 50, 50]]

for data in triangle_data:
    what_triangle_is(data)

def func(list):
    sum = 0
    for value in list:
        sum += value

    if len(list) >= 4 or min(list) == 0 or sum != 180:
        print("삼각형이 아니다")

    elif max(list) > 90:
        print("둔각삼각형")
    elif max(list) == 90:
        print("직각삼각형")
    else:
        print("예각삼각형")


func([60, 60, 60])
func([30, 60, 90])
func([20, 40, 120])
func([0, 90, 90])
func([60, 70, 80])
func([40, 40, 50, 50])

arr = [1,2,3]

def tri(arr):
    if len(arr) == 3 and sum(arr) == 180 and min(arr) > 0:
        arr.sort()
        if arr[0] + arr[1] < arr[2]: print("둔각")
        elif arr[0] + arr[1] > arr[2]: print("예각")
        else: print("직각")
    else:
        print("삼각형 아님")

def triangle(a):
    if(len(a)!=3 or sum(a)!=180) :
        return "It is not the triangle(삼각형이 아니다)"
    elif 90 in a:
        return "직각삼각형"
    elif max(a) > 90:
        return "둔각삼각형"
    else:
        return "예각삼각형"

if __name__ == '__main__':
    a = [70,50,90]   
    print(triangle(a))        

def triangle(lst):
    if len(lst) !=3 or sum(lst)!=180 or min(lst)<=0:
        print('%s = 삼각형이 아니다.'%lst)
    elif max(lst)>90 : print('%s = 둔각삼각형'%lst)
    elif 90 in lst : print('%s = 직각삼각형'%lst)
    else: print('%s = 예각삼각형'%lst)
lst1=[[60,60,60],[30,60,90],[20,40,120],[0,90,90],[60,70,80],[40,40,50,50]]
for lst in lst1:
    triangle(lst)

# 삼각형 판별기 코드
# 핵심 전략 : if 조건문

sample=[[60, 60, 60], [30, 60, 90], [20, 40, 120], [60, 70, 80], [40, 40, 50, 50], [120,20,40]]


for i in range(len(sample)):

# 2. 삼각형 판별에 필요한 두 가지 조건 설정
    # (1) 모든 각의 합을 계산하는 방법
    a=0
    for j in range(len(sample[i])):
        a+=sample[i][j]

    # (2) 삼각형의 가장 큰 각을 구하기 위한 정렬
    sample[i].sort()

# 2. 삼각형 조건을 벗어난 경우(각이 3개가 아니거나, 세 각의 합이 180도가 되지 않는 경우)
    if len(sample[i])!=3:
        print(f"{sample[i]}는 삼각형이 아니다.")
    elif a!=180:
        print(f"{sample[i]}는 삼각형이 아니다.")

# 3. 삼각형의 조류 판별
    elif sample[i][2]<90:
        print(f"{sample[i]}는 예각삼각형이다.")
    elif sample[i][2]==90:
        print(f"{sample[i]}는 직각삼각형이다.")
    elif sample[i][2]>90:
        print(f"{sample[i]}는 둔각삼각형이다.")

static void triangle(int[] x) {
        if(x.length ==3) {
            Arrays.sort(x);
            if(x[0] + x[1]+ x[2] == 180) {
                if(x[2] < 90)
                    System.out.println(Arrays.toString(x) + " = 예각삼각형");
                else if(x[2] == 90 && x[1] == x[2])
                    System.out.println(Arrays.toString(x) + " = 삼각형이 아니다.");
                else if(x[2] == 90)
                    System.out.println(Arrays.toString(x) + " = 직각삼각형");
                else
                    System.out.println(Arrays.toString(x) + " = 둔각삼각형");
            }else
                System.out.println(Arrays.toString(x) + " = 삼각형이 아니다.");
        }else {
            System.out.println(Arrays.toString(x) + " = 삼각형이 아니다.");
        }
    }

    public static void main(String[] args) {
        int[][] a = {{60,60,60},{30,60,90},{20,40,120},{0,90,90},{60,70,80},{40,40,50,50},{20,20,20}};
        for(int i = 0; i< a.length; i++)
            triangle(a[i]);
    }

def solution (arr) : 
    if len(arr) !=3 or sum(arr) != 180 :
        return print("삼각형이 아닙니다")
    elif max(arr) > 90 :
        return print("둔각삼각형")
    elif 90 in arr :
        return print("직각삼각형")
    else :
        return print("예각삼각형")



a = [20, 40, 120]

solution(a)

a = [60, 70, 80]

if sum(a) == 180:
    if max(a) < 90:
        print('예각 삼각형')
    elif max(a) == 90:
        print('직각 삼각형')
    else:
        print('둔각 삼각형')
else:    
    print('삼각형이 아니다')

def tryangle(data):
    if (len(data) != 3) or (sum(data) != 180) or (0 in data):
        return '삼각형이 아닙니다.'
    else:
        for rad in data:
            if rad == 90:
                return '직각삼각형'
            elif rad > 90:
                return '둔각삼각형'

    return '예각삼각형'
data = [[60, 60, 60],
[30, 60, 90],
[20, 40, 120], 
[0, 90, 90] ,
[60, 70, 80],
[40, 40, 50, 50]] 

for d in data:
    print(d, tryangle(d))

class tri{
    int a, b, c, y;
    public int set(int a, int b, int c) {
        this.a = a;
        this.b = b;
        this.c = c;
        if(a+b+c==180) {
            if(a==60 && b==60 && c==60) {
                this.y = 60;}
            if(a==90 || b==90 || c==90) {
                this.y=90;}
            if(a>90 || b>90 || c>90) {
                this.y = 100;}}
        else {
            this.y = 30;
        }
        return this.y;
    }
    public void print() {
        if(this.y==60) {
            System.out.println("3각이 모두 예각인 삼각형");}
        if(this.y==90) {
            System.out.println("1각이 직각인 삼각형");}
        if(this.y==100) {
            System.out.println("1각이 둔각인 삼각형");}
        if(this.y==30) {
            System.out.println("삼각형이 아닙니다.");}
    }
}

public class test {
    public static void main(String[] args) {
        tri a1 = new tri();
        a1.set(60, 60, 60);
        a1.print();
        a1.set(30, 60, 90);
        a1.print();
        a1.set(20, 40, 120);
        a1.print();
        a1.set(90, 60, 60);
        a1.print();
}
}

def detectTriangle():
  angles = list(map(int, input().split()))

  if len(angles) != 3 or sum(angles) != 180 or 0 in angles:
    print(f"{angles} = 삼각형이 아니다")
  elif 90 in angles:
    print(f"{angles} = 직각삼각형")
  elif [angle for angle in angles if angle > 90]:
    print(f"{angles} = 둔각삼각형")
  else:
    print(f"{angles} = 예각삼각형")

def trg(l):
    if len(l) != 3 or sum(l) !=180 or min(l)<=0:
        return print("삼각형이 아님")
    else:
        if 90 in l: return print("직각삼각형")
        elif max(l)>90: return print("둔각삼각형")
        else: return print("예각삼각형")

trg([])

package com.algorithm.algorithmpractice.dojang;

public class GetT {
    public static int getTypeOfTriangle(int[] angles){
        int totalAngle = 0;
        int maxAngle = 0;
        for(int i = 0; i < angles.length; i++){
            totalAngle += angles[i];
            if(angles[i] > maxAngle){
                maxAngle = angles[i];
            }
        }
        if(totalAngle != 180){
            return -1;
        }
        if(maxAngle <= 60){
            return 1;
        }
        if(maxAngle == 90){
            return 2;
        }
        if(maxAngle > 90){
            return 3;
        }
        return -1;
    }
    public static void main(String[] args) {
        int[] angles = {60, 60, 60};

        int type = getTypeOfTriangle(angles);
        String typeAngle = "";
        switch (type){
            case 1 : {
                System.out.println("예각");
                break;
            }
            case 2: {
                System.out.println("직각");
                break;
            }
            case 3: {
                System.out.println("둔각");
                break;
            }
            default:{
                System.out.println("삼각형이 아닌 듯");
                break;
            }
        }
    }

    //아 풀고보니 enum쓰면 간지 였는데 ㄲㅂ
}

def triangle(x):
    if len(x) == 3 and sum(x) == 180 and x[0]>0 and x[1]>0 and x[2]>0:
        if x[0]<90 and x[1]<90 and x[2]<90: return '예각삼각형'
        elif 90 in x: return '직각삼각형'
        else: return '둔각삼각형'
    else: return '삼각형이 아니다.'

def tri(list_input) : 
    if sum(list_input) > 180:
        return "삼각형이 아니다"
    elif max(list_input) < 90 :
        return "예각삼각형"
    elif max(list_input) == 90 :
        return "직각삼각형"
    else :
        return "둔각삼각형" 

Python.

angles=[120, 20, 40]
if len(angles) == 3 and sum(angles) == 180:
    if angles[0] < 90 or angles[1] < 90 or angles[2] < 90:
        print('예각삼각형입니다.')
    elif angles[0] == 90 or angles[1] == 90 or angles[2] == 90:
        print('직각삼각형입니다.')
    elif angles[0] > 90 or angles[1] > 90 or angles[2] > 90:
        print('둔각삼각형입니다.')
else :
    print('삼각형이 아닙니다.')

python

def find_triangle(angles):
    if sum(angles) != 180 or len(angles) != 3:
        result = "삼각형이 아니다"

    else:   
        for x in angles:

            if x == 0:
                result = "삼각형이 아니다"
                break

            if x == 90:
                result = "직각삼각형"
                break

            if x > 90:
                result = "둔각삼각형"
                break

            if x < 90:
                result = "예각삼각형"

    return result

if __name__ == '__main__':
    angles = [60, 60, 60]
    print(angles, "=", find_triangle(angles))

def triangle(list):
    if len(list) == 3 and list[0] + list[1] + list[2] == 180 and list[0] > 0 and list[1] > 0 and list[2] > 0:
        if 90 in list:
            return "직각삼각형"
        elif list[0] > 90 or list[1] > 90 or list[2] > 90:
            return "둔각삼각형"
        else:
            return "예각삼각형"
    else:
        return "삼각형이 아닙니다."

Python

list = []

# 입력받은 리스트를 정렬
tri = sorted(list)

# 삼각형이 아닌 것들을 먼저 걸러냄
if len(tri) != 3 or sum(tri) != 180 or min(tri) <= 0:
    print("삼각형이 아님")

# 가장 큰 각이 90보다 크면 둔각삼각형, 90이면 직각, 90 미만이면 예각임. 
else:
    if tri[-1] > 90:
        print("둔각")
    if tri[-1] == 90:
        print("직각")
    if tri[-1] < 90:
        print("예각")