Implement a method that accepts 3 integer values a, b, c. The method should return true if a triangle can be built with the sides of given length and false in any other case.

(In this case, all triangles must have surface greater than 0 to be accepted).

Difficulty: introductory

Starter code:

def is_triangle(a, b, c):
	

Solutions:
def is_triangle(a, b, c):
    return (a<b+c) and (b<a+c) and (c<a+b)


def is_triangle(a, b, c):
    a, b, c = sorted([a, b, c])
    return a + b > c


def is_triangle(a, b, c):
    return (a + b) > c and (a + c) > b and (b + c) > a


def is_triangle(a, b, c):
    """Determine if three sides of given lengths can form a triangle.
    
        Args:
            a (int): First side length
            b (int): Second side length
            c (int): Third side lenght
        
        Returns:
            bool: True if the three sides given can form a triangle.
    """
    return a < b + c and b < a + c and c < a + b


def is_triangle(a, b, c):
    
    if(a <= 0 | b <= 0 | c <= 0):
        return False
    elif( a + b <= c or a + c <= b or b + c <= a): 
        return False
    else:
        return True

def is_triangle(a, b, c):
  return abs(a-b) < c < a+b

def is_triangle(a, b, c):
    s=[a,b,c]
    for i in s:
        if sum(s)-i <= i:
            return False
    return True

def is_triangle(a, b, c):
    return 2 * max(a, b, c) < a + b + c

def is_triangle(a, b, c):
  if a+b <= c or a+c <= b or b+c <= a:
    return False
  else:
    return True

def is_triangle(a, b, c):
    return all([a+b>c, a+c>b, b+c>a])


def is_triangle(*args):
    a, b, c = sorted(args)
    return a + b > c

def is_triangle(a, b, c):
    if a + b + c == 0:
        return False
    if a + b <= c:
        return False
    if a + c <= b:
        return False
    if b + c <= a:
        return False
    return True

def is_triangle(a, b, c):
    if a <= 0 or b <= 0 or c <= 0:
        return False
    sum = a + b + c
    if fits(sum, max(a, b, c)):
        return True
    return False

def fits(sum, a):
    return sum - a > a

def is_triangle(a, b, c):
    if a > 0 and b > 0 and c > 0:
        if ((a + b) > c) and ((b + c) > a) and ((a + c) > b):
            return True
        elif a == b == c:
            return True
        else:
            return False
    else:            
        return False


def is_triangle(a, b, c):
    return  max(a, b, c)< (a+b+c-max(a,b, c))


def is_triangle(a, b, c):
    return all([a < b+c, b < a+c, c < a+b]) 


def is_triangle(a, b, c):
    return(b+c > a > abs(b - c))

is_triangle=lambda _,a,b:sum(sorted([_,a,b])[:2])>sorted([_,a,b])[2]



def is_triangle(a, b, c):
    sides = [a, b, c]
    max_side = max(sides)
    if sum(sides) - max_side > max_side:
        return True
    else:
        return False
        


def is_triangle(a, b, c):
    s = a + b + c
    if s - max(a,b,c) > max(a,b,c):
        return True
    return False

def is_triangle(a, b, c):
    return a + b + c - max(a,b,c) > max(a,b,c)


def is_triangle(a, b, c):
    #Triangle inequality
    return a + b > c and a + c > b and b + c > a


def is_triangle(a, b, c):
    cond1 = a + b > c
    cond2 = b + c > a 
    cond3 = a + c > b
    list = [cond1, cond2, cond3]
    if False in list:
        return False
    return True

def is_triangle(x, y, z):
    return (x<y+z) and (y<x+z) and (z<x+y)


def is_triangle(a, b, c):
    t1 = a + b > c
    t2 = a + c > b
    t3 = b + c > a
    
    return t1 and t2 and t3
    #return False


def is_triangle(a, b, c):
    # All you have to do is use the Triangle Inequality Theorem.
    return (a + b) > c and (a + c) > b and (b + c) > a

def is_triangle(*sides):
    return sum(sorted(sides)[:2]) > max(sides)


def is_triangle(a, b, c):
    max_number = max([a, b, c])
    
    if sum([a,b,c])-max_number > max_number:
        return True
    
    return False

def is_triangle(a, b, c):
    if (a>0 and b>0 and c>0):
        if (a+b>c and a+c>b and c+b>a):
            return True
        else:
            return False
    return False


def is_triangle(a, b, c):
    llist = [a,b,c]
    llist.sort()
    highest = llist[2]
    sumrest = llist[0] + llist[1]
    if highest < sumrest:
        return True
    return False

def is_triangle(a, b, c):
    # Check if sum of 2 sides is bigger than the last size
    if a + b > c and a + c > b and b + c > a:
        return True
    
    return False


def is_triangle(a, b, c):
    lst = [int(a),int(b),int(c)]
    lst = sorted(lst)
    if lst[0]+lst[1]>lst[2]:
        return True
    else:
        return False


def is_triangle(a, b, c):
    if (abs(b-a)<c<abs(b+a) and
       abs(c-a)<b<abs(c+a) and
       abs(c-b)<a<abs(c+b)):
           return True
    return False


def is_triangle(a, b, c):
    lengths = [a,b,c]
    x = sorted(lengths)
    print((x,x[0]+x[1]))
    if x[0]+x[1]>x[2]:
        return True
    else:
        return False


def is_triangle(a, b, c):
    if a + b > c:
        
        if a + c > b:
        
            if b +c > a:
                return True
            else:
                return False
        
        else:
            return False
        
    else:
        return False

    
    return False


def is_triangle(a, b, c):
    max_int = max(a,b,c)
    min_int = min(a,b,c)
    
    
    if max_int == a:
        sum = b + c
        if sum > a:
            return True
    if max_int == b:
        sum = a + c
        if sum > b:
            return True
    if max_int == c:
        sum = a + b
        if sum > c:
            return True
            
    return False


def is_triangle(a, b, c):
    if a == None or b == None or c == None:
        return False
    l_tri = sorted([a,b,c])
    if l_tri[2]>=l_tri[0]+l_tri[1]:
        return False
    return True


def is_triangle(a, b, c):
    if(abs(a+b)<=c or abs(a-b) >= c):
        return False
    elif(abs(c+b)<=a or abs(c-b) >= a):
        return False
    elif(abs(c+a)<=b or abs(c-a) >=b):
        return False
    elif(a<=0 or b<= 0 or c <= 0):
        return False
    return True


def is_triangle(a, b, c):
    if (a + b > c) and (b + c > a) and (c + a > b) and (a > 0) and (b > 0) and (c > 0):
        return True
    else:
        return False


def is_triangle(a, b, c):
    tab_coter = [a, b, c]
    tab_coter.sort()
    calc_long_coter = tab_coter[0] + tab_coter[1]
    if (tab_coter[2] < calc_long_coter):
        return True
    return False


def is_triangle(a, b, c):
    s = sorted([a, b, c])
    return False if s[0] < 1 or sum(s[:-1]) <= s[2] else True

def is_triangle(a, b, c):
    # test if any combination of 2 sides is > the remaining side
    if ((a+b) > c) and ((b+c) > a) and ((a+c) > b):
        return True
    
    return False


def is_triangle(a, b, c):
    lts = [a,b,c]
    lts.sort()
    return(lts[2]<lts[1]+lts[0])



def is_triangle(a, b, c):
    if a > 0 and b > 0 and c > 0 and (a + b > c and a + c > b and c + b > a):
        return True
        
    return False


def is_triangle(a, b, c):
    triangleList = [a,b,c]
    triangleList.sort()
    if triangleList[0]+triangleList[1] > triangleList[2]:
        return True
    else:
        return False


def is_triangle(a, b, c):
    out = []
    out.append(a)
    out.append(b)
    out.append(c)
    out.sort()
    if out[2]>= out[0]+out[1]:
        return False
    else:
        return True

def is_triangle(a, b, c):
    if not a + b > c or not a + c > b or not b + c >a:
        print(('AB pair',a+b,c))
        print(('AC pair',a+c,b))
        print(('BC pair',b+c,a))
        return False
    else:
        return True


def is_triangle(a, b, c):
    if a <= 0 or b <= 0 or c <= 0:
        return False
    elif (a + b > c) and (b + c > a) and (c + a > b):
        return True
    return False

def is_triangle(a, b, c):
    if a >=0 or b >= 0 or c >= 0:
        if a+b <= c or a+c <=b or b+c <= a:
            return False
        else:
            return True
    else:
        return False
    return False
   
#по идее мы должны проверить что нет суммы длин двух сторон меньшей либо равной длины третьей


def is_triangle(a, b, c):
    return ((a < b+c) & (b < a+c) & (c < b+a))


def is_triangle(a, b, c):
    if 2*max([a, b, c]) < a + b + c:
        return True    
    else:
        return False
        


def is_triangle(a, b, c):
    """The triangle is possible only when all sides are greater than 0 and
       and sum of any two sides greater than the third side.
    """
    return ((a+b)>c and (b+c)>a and (c+a)>b and a>0 and b>0 and c>0)
    return False


def is_triangle(a, b, c):
    listOfSides = [a,b,c]
    if max(listOfSides) >= (sum(listOfSides) - max(listOfSides)):
        return False
    return True
    
        


def is_triangle(a, b, c):
    sum = a + b + c
    for side in a, b, c:
        if sum - side <= side:
            return False
    return True


def is_triangle(a, b, c):
    x=max(a,b,c)
    for i in a,b,c:
        if x==i and x<(a+b+c-i):
            return True
            
    return False


def is_triangle(a, b, c):
    return c < a+b and c > a-b and b < a+c and b> a-c


def is_triangle(a, b, c):
    if a+b>c and abs(a-b)<c:
        return True
    elif a+c>b and abs(a-c)<b:
        return True
    elif b+c>a and abs(b-c)<a:
        return True
    else:
    
        return False


def is_triangle(a, b, c):
    lst = sorted([a, b, c])
    if lst[2]-lst[1]<lst[0] and lst[0]+lst[1]>lst[2]:
        return True
    else:
        return False
      
    


def is_triangle(a, b, c):

    if a > 0 and b > 0 and c > 0:
        reference = sorted([a, b, c])
        if reference[2] < (reference[0] + reference[1]):
            return True
        else:
            return False
    else:
        return False


def is_triangle(a, b, c):
    if (a + b) > c and (a + c) > b and (b + c) > a:
     print("You can make a triangle with these numbers")
     return True
    else:
     print("You cannot make a triangle with these numbers")
     return False

def is_triangle(a, b, c):
    if a is 0 and b is 0 and c is 0:    
        return False
    elif a+b>c and a+c>b and b+c>a:
        return True
    else: 
        return False

def is_triangle(a, b, c):
    if a and b and c > 0 and ((a + c > b) and (b + a > c) and (c + b > a)):
        return True
    else:
        return False


def is_triangle(a, b, c):
    #triangle inequality theorem
    if a + b > c and a + c > b and b + c > a:
        return True
    return False


def is_triangle(a, b, c):
    if a and b and c > 0:
        return (a + b > c and a + c > b and b + c > a)
    else:
        return False

def is_triangle(a, b, c):
    if any(side <= 0 for side in (a, b, c)):
        return False
    sides = sorted([a, b, c])
    if sides[0] + sides[1] <= sides[2]:
        return False
    return True

#def is_triangle2(a, b, c):
#    lista = sorted([a,b,c])
#    if lista[0] + lista[1] > lista[2]:
#        return True
#    return False

def is_triangle(a, b, c):
    if a + b > c and a + c > b and b + c > a:
        return True
    return False

def is_triangle(a, b, c):
    v = [a,b,c]
    m = max(v)
    v.remove(m)
    return m < sum(v)


def is_triangle(a, b, c):
    my_flag = False
    if (a + b) > c and (c + b) > a and (a + c) > b:
        my_flag = True
    else:
        my_flag = False
        
    return my_flag


def is_triangle(a, b, c):
    result = ''
    if a + b <= c:
        result = False
    elif a + c <= b:
        result = False
    elif b + c <= a:
        result = False
    else:
        result = True
    return result


import math
def is_triangle(a, b, c):
    sides=(a,b,c)
    if sorted(sides)[-1]>=(sorted(sides)[0]+sorted(sides)[1]):
        return False
    return True


def is_triangle(a, b, c):
    if (abs(a-b)<c)and(abs(b-c)<a)and(abs(a-c)<b):
        return True
    return False


def is_triangle(a, b, c):
    table = [a, b, c]
    table.sort()
    return table[0] + table[1] > table[2]


def is_triangle(a, b, c):
    if sum([a, b]) > c and sum ([b, c]) > a and sum([a, c]) > b:
        return True
    else:
        return False


def is_triangle(a, b, c):
    if a >= b+c or b >= c+a or c >= b+a:
        return False;
    else:
        return True
    


def is_triangle(a, b, c):
    largest = max(a,b,c)
    return 2 * largest < a + b + c


def is_triangle(a, b, c):
    if a==0 or b==0 or c==0:
        return 0
    if a+b<=c or b+c<=a or a+c<=b:
        return 0
    else:
        return 1


def is_triangle(a, b, c):
    """Return boolean True if a triangle can be built with 3 given sides, else return False."""
    return (a + b) > c and (a + c) > b and (b + c) > a


def is_triangle(a, b, c):
    """Return boolean True if a triangle can be built with 3 given sides, else return False."""
    return True if (a + b) > c and (a + c) > b and (b + c) > a else False


def is_triangle(a, b, c):
    return True if a+b+c >2*max(a,b,c) else False


def is_triangle(a, b, c):
    list_ = [a, b, c]
    return True if sorted(list_)[0] + sorted(list_)[1] > sorted(list_)[2] and sorted(list_)[0] > 0 and sorted(list_)[1] > 0 and sorted(list_)[2] > 0 else False

def is_triangle(a, b, c):
    list_ = [a, b, c]
    if sorted(list_)[0] + sorted(list_)[1] > sorted(list_)[2]:
        if sorted(list_)[0] > 0 and sorted(list_)[1] > 0 and sorted(list_)[2] > 0:
            return True
    return False

def is_triangle(a, b, c):
    mylist = [a, b, c]
    mylist.sort()
    if (mylist[0] + mylist[1]) > mylist[2]:
        return True
    else:
        return False
    
    


def is_triangle(a,b,c):
    x = a + b
    y = b + c
    z = a + c
    if x > c and y > a and z > b:
        return True
    else:
        return False

def is_triangle(a, b, c):
    if (a or b or c) < 0:
        return False
    v = list()
    v.append(a)
    v.append(b)
    v.append(c)
    v.sort()
    _a = v.pop()
    _b = v.pop()
    _c = v.pop()

    if _a < _b + _c:
        return True
    if _a == _b + _c:
        return False
    return False


def is_triangle(a, b, c):
    if a < b+c and b < a+c and c<a+b:
        return True
    else:
        return False#, "didn't work when sides were {} {} {}".format (a,b,c)
        


def is_triangle(a, b, c):
    if c>=a and c>=b and a+b>c:
        return True
    elif a>=b and a>=c and b+c>a:
        return True
    elif b>=a and b>=c and a+c>b:
        return True
    else:
        return False    
  


def is_triangle(a, b, c):
    """
    The sum of any two sides must be greater than the length of the third side
    """
    if a+b > c and a+c > b and b+c > a:
        return True
    else:
        return False


def is_triangle(a, b, c):
    if (a+b>c)and(b+c>a)and(a+c>b):
        result =  True
        print( result)
    else:
        result = False
        print( result)
    return result


def is_triangle(a, b, c):
    x = [a, b, c]
    x.sort()
    if x[2] >= x[0] + x[1]:
        return False
    else:
        return True


def is_triangle(a, b, c):
    x=max(a, b, c)
    lista=[a, b, c]
    lista.remove(x)
    if x<sum(lista):
        return True
    else:
        return False


def is_triangle(a, b, c):
    if c >= a and c >= b and a + b <= c :
        return False  
    elif a >= b and a >= c and  b + c <= a:
        return False
    elif b >= c and b >= a and c + a <= b:
        return False
    else:
        return True


def is_triangle(a, b, c):
    k = [a+b > c,a+c>b,b+c>a]
    return not False in k

def is_triangle(a, b, c):
    
    if(a<=abs(b-c)) or (b<=abs(a-c)) or (c<=abs(a-b)):
        return False
    else:   
        return True



def is_triangle(a, b, c):
    return a > abs(b - c) and b > abs(a - c) and c > abs(a - b)
    


def is_triangle(a, b, c):
    sides = [a,b,c]
    a = max(sides)
    sides.remove(a)
    if sum(sides) > a:
        return True
    return False


def is_triangle(a, b, c):
    result = False
    if a + b > c:
        if a + c > b:
            if c + b > a:
                result = True  
    return result


def is_triangle(a, b, c):
    biggest_arg = max([a,b,c])
    return True if biggest_arg < sum([a,b,c]) - biggest_arg else False

def is_triangle(a, b, c):
    mylist = [a, b, c]
    mylist = sorted(mylist)
    if mylist[0] < mylist[1] + mylist[2] :
        if mylist[1] < mylist[0] + mylist[2]:
            if mylist[2] < mylist[0] + mylist[1]:
                return True
    return False


def is_triangle(a, b, c):
  sides = (a, b, c)
  sides = sorted(sides)
  c = sides[-1]
  b = sides[1]
  a = sides[0]
  return c < a + b

def is_triangle(a, b, c):
    a = sorted([a, b, c])
    return a[2] < a[0] + a[1]