Python, 24 bytes

lambda l:sum(l)>max(l)*2 

Try it online!

Checks if a+b+c > max(a,b,c)*2. If, say, c is the biggest one, this is equivalent to a+b+c>2*c, or a+b>c, which is want we want for the triangle inequality.

CP-1610 machine code (Intellivision), 12 DECLEs¹ = 15 bytes

A routine taking \$(a,b,c)\$ into R0, R1 and R2 respectively and setting the carry if \$(a,b,c)\$ is not a triangle, or clearing it otherwise.

083 | MOVR R0, R3 0CB | ADDR R1, R3 15A | CMPR R3, R2 02F | ADCR R7 0D3 | ADDR R2, R3 049 | SLL R1 159 | CMPR R3, R1 201 002 | BC @@rtn 048 | SLL R0 158 | CMPR R3, R0 0AF | @@rtn JR R5 

How?

Instead of testing:

$$\cases{a+b>c\\a+c>b\\b+c>a}$$

We test:

$$\cases{a+b>c\\a+b+c>2b\\a+b+c>2a}$$

The left parts of the inequalities are stored into R3. If the first test fails (when \$a+b\$ is stored into R3 and compared with R2), the carry is set and added to the program counter (R7), forcing the next instruction to be skipped. Consequently, R3 is not updated to \$a+b+c\$ and the last 2 comparisons are turned into:

$$\cases{a+b>2b\\a+b>2a}\Leftrightarrow\cases{a>b\\b>a}$$

which of course is never true, so the test is guaranteed to fail as expected.

All in all, this saves a branch which would have cost 1 extra DECLE.

Full commented test code

 ROMW 10 ; use 10-bit ROM width ORG $4800 ; map this program at $4800 ;; ------------------------------------------------------------- ;; ;; main code ;; ;; ------------------------------------------------------------- ;; main PROC SDBD ; set up an interrupt service routine MVII #isr, R0 ; to do some minimal STIC initialization MVO R0, $100 SWAP R0 MVO R0, $101 EIS ; enable interrupts MVII #$200, R4 ; R4 = pointer into backtab SDBD ; R5 = pointer into test cases MVII #tc, R5 MVII #13, R3 ; R3 = number of test cases @@loop MVI@ R5, R0 ; R0 = a MVI@ R5, R1 ; R1 = b MVI@ R5, R2 ; R2 = c PSHR R3 ; save R3 and R5 on the stack PSHR R5 CALL tr ; invoke our routine PULR R5 ; restore R3 and R5 PULR R3 MVII #$80, R0 ; R0 = '0' BC @@draw MVII #$88, R0 ; or '1' if the carry is not set @@draw MVO@ R0, R4 ; draw this character DECR R3 ; next test case BNEQ @@loop DECR R7 ; loop forever ;; ------------------------------------------------------------- ;; ;; test cases ;; ;; ------------------------------------------------------------- ;; tc PROC DECLE 1, 1, 1 ; true DECLE 1, 2, 3 ; false DECLE 2, 1, 3 ; false DECLE 1, 3, 2 ; false DECLE 3, 2, 1 ; false DECLE 3, 1, 2 ; false DECLE 2, 2, 2 ; true DECLE 3, 4, 5 ; true DECLE 3, 5, 4 ; true DECLE 5, 3, 4 ; true DECLE 5, 4, 3 ; true DECLE 10, 9, 3 ; true DECLE 100, 10, 10 ; false ENDP ;; ------------------------------------------------------------- ;; ;; ISR ;; ;; ------------------------------------------------------------- ;; isr PROC MVO R0, $0020 ; enable display CLRR R0 MVO R0, $0030 ; no horizontal delay MVO R0, $0031 ; no vertical delay MVO R0, $0032 ; no border extension MVII #$D, R0 MVO R0, $0028 ; light-blue background MVO R0, $002C ; light-blue border JR R5 ; return from ISR ENDP ;; ------------------------------------------------------------- ;; ;; our routine ;; ;; ------------------------------------------------------------- ;; tr PROC MOVR R0, R3 ; R3 = a ADDR R1, R3 ; R3 = a + b CMPR R3, R2 ; is R3 greater than c? ADCR R7 ; if not, skip the next instruction ADDR R2, R3 ; R3 = a + b + c (or still a + b if skipped) SLL R1 ; R1 = 2b CMPR R3, R1 ; is R3 greater than 2b? BC @@rtn ; if not, return with the carry set SLL R0 ; R0 = 2a CMPR R3, R0 ; is R3 greater than 2a? ; if not, the carry is set @@rtn JR R5 ; return ENDP 

Output

^{screenshot from jzIntv}

_{1. A CP-1610 opcode is encoded with a 10-bit value (0x000 to 0x3FF), known as a 'DECLE'.}

Java 8, 52 49 38 26 bytes

(a,b,c)->a+b>c&a+c>b&b+c>a 

Port of @xnor's formula turns out to be shorter after all, by taking the input as three loose integers instead of a List/array.
-12 bytes thanks to @xnor for reminding me that the first 6-bytes formula I used in my 05AB1E answer is actually shorter in Java:

\$(a+b>c)\land(a+c>b)\land(b+c>a)\$

Try it online.

Explanation:

(a,b,c)-> // Method with three integer parameters and boolean return-type a+b>c // Return whether the sum of a and b is larger than c &a+c>b // and the sum of a and c is larger than b &b+c>a // and the sum of b and c is larger than a 

Previous 52 49 bytes answer:

S->{S.sort(null);return S.pop()<S.pop()+S.pop();} 

Port of @GB's Ruby answer with input as a Stack of Integers.

Try it online.

Explanation:

S->{ // Method with Integer-Stack parameter and boolean return-type S.sort(null); // Sort the input-Stack return S.pop() // Check if the last largest value <S.pop()+S.pop();} // is smaller than the lowest two values added together 

Ruby, 23 bytes

->*a{a.sort!.pop<a.sum} 

Try it online!

A different approach, xnor's formula would be shorter but I'm satisfied with that.

Ruby, 19 bytes

->*a{2*a.max<a.sum} 

You can try it online!

Uses the fact that this Ruby answer said it didn't want to implement the port of xnor's answer and at the same time taught me enough syntax to guess how the max of an array is calculated :)

05AB1E, 6 5 4 bytes

O;‹ß 

-1 byte by porting @xnor's algorithm.
-1 byte thanks to @Grimmy using a derived formula.

Try it online or verify all test cases.

Explanation:

The formula this program uses to determine if three side-lengths \$a,b,c\$ form a triangle is:

\$t=\frac{a+b+c}{2}\$
\$(a<t)\land(b<t)\land(c<t)\$

O # Take the sum of the (implicit) input-list ; # Halve it ‹ # Check if it's larger than each of the values of the (implicit) input-list ß # Get the minimum of those checks # (`P` can be used as alternative to check if all are truthy instead) # (after which this result is output implicitly) 

Original 6-byter:

ÀĆü+‹P 

Try it online or verify all test cases.

Explanation:

The formula this program uses to determine if three side-lengths \$a,b,c\$ form a triangle is:

\$a+b>c\$
\$a+c>b\$
\$b+c>a\$

Which translates to the following code for 05AB1E:

À # Rotate the (implicit) input-list once towards the right: [a,b,c] → [b,c,a] Ć # Enclose it; appending its head to itself: [b,c,a] → [b,c,a,b] ü+ # Sum each overlapping pair: [b,c,a,b] → [b+c,c+a,a+b] ‹ # Check for each whether it's larger than the (implicit) input-list: # [a<b+c,b<c+a,c<a+b] P # And check if all three are truthy by taking the product # (`ß` could be used as alternative, like in the 4-byter program above) # (after which the result is output implicitly) 

C (gcc), 30 bytes

Probably the most basic formula.

f(a,b,c){a=a+b>c&a+c>b&b+c>a;} 

Try it online!

PHP, 45 32 bytes

fn($a)=>max($a)*2<array_sum($a); 

Try it online!

Lambda function that takes an array [a, b, c] and outputs empty string if false or "1" if true, with xnor's formula.

Note that in PHP the ; is only necessary when the function is attributed to a variable, so it's placed in the footer (provided code is valid as it is).

EDIT: thanks to Guillermo Phillips for introducing me to PHP 7.4 short notation! (as a declaration without {}, it now needs the ;)

Wolfram Language (Mathematica), 12 bytes

2Max@#<Tr@#& 

Try it online!

GolfScript, 5 bytes

$~\-> 

Why bother with any of the other math? If the longest side is longer (or equal) than the sum of the shorter two, it can't be a triangle. Otherwise it can.

Input is an array. Output is 0 or 1. If you have the list necessarily sorted, then you can just input as a dumped array (straight onto the stack) and the first two characters are unneeded. If the list can be entered in reverse order, then you can remove the first three characters and flip the greater-than to a lesser-than, leaving only 2 characters needed.

$~\-> #Check if side lengths could make a triangle $ #Sort ~ #Dump array onto stack (stack is now 1 2 3) \ #Swap the top two elements (1 3 2) - #Subtract the top from the second (1 3-2) > #Check if that difference is strictly greater than the smallest value 

This is equivalent to my last answer, but instead of a+b>c, I did a>c-b, which saves a character of stack-shuffling.

Try it online!

APL (Dyalog Unicode), 7 bytes^SBCS

+/>2×⌈/ 

Try it online!

Also uses xnor's formula of sum(a,b,c) > 2 * max(a,b,c).

How it works

+/>2×⌈/ +/ ⍝ Is sum > ⍝ greater than 2× ⍝ twice of ⌈/ ⍝ max? 

Alternative 7 bytes^SBCS

∧/+/>+⍨ 

Try it online!

How it works

∧/+/>+⍨ +/ ⍝ Is sum > ⍝ greater than +⍨ ⍝ twice each number? ∧/ ⍝ All of them? 

Jelly, 4 bytes

ṀḤ<S 

Try it online!

A monadic link taking a list of integers and returning a Jelly boolean (1 = True, 0 = False).

Based on @xnor's Python answer so be sure to upvote that one too!

Explanation

Ṁ | Maximum Ḥ | Doubled < | Less than: S | - Sum of original argument 

Retina 0.8.2, 31 bytes

\d+ $* O`1+ ^(?!(1+),(1+),\1\2) 

Try it online! Link includes test cases. Explanation:

\d+ $* 

Convert to unary.

O`1+ 

Sort.

^(?!(1+),(1+),\1\2) 

Check that the sum of the first two is greater than the third.

C (gcc), ^{54 \$\cdots\$ 42} 36 bytes

Saved 6 bytes thanks to ceilingcat!!!

f(a,b,c){a=a+b+c>2*fmax(a>b?a:b,c);} 

Try it online!

Uses xnor's formula.

Uiua, 7 bytes 9 bytes (SBCS)

|1<+/∘⊏⍖. 

Try it online!

Explanation:

## (Top of stack on the left) ## Stack: [1 3 2] . # Copy input ## Stack: [1 3 2] [1 3 2] ⍖ # Index array by descending value ## Stack: [1 2 0] [1 3 2] ⊏ # Order the input ## Stack: [3 2 1] /∘ # Put the elements on the stack ## Stack: 1 2 3 + # Add the top two items ## Stack: 3 3 < # Test whether the second item is less than the first ## Stack: 0 |1 # Function signature 

Edit: Added function signature (2 extra bytes) to conform to rules. Thanks to @Bubbler.

J, 8 bytes

+/>2*>./ 

Try it online!

Uses xnor's formula

Burlesque, 13 bytes

raJ++j>]2.*.> 

Try it online!

ra # Read as array J # Duplicate ++ # Sum j # Swap >] # Maximum 2.*# Double .> # Greater than 

Wren, 54 bytes

I haven't written Wren in a long time...

Fn.new{|x|x.reduce{|a,b|a+b}>x.reduce{|a,b|a>b?a:b}*2} 

Try it online!

C++ (gcc), 89 bytes

Array/vector solution as shown in other answers.

#import<regex> int f(std::vector<int>v){std::sort(&v[0],&*end(v));return v[2]<v[1]+v[0];} 

Try it online!

C++ (gcc), 56 bytes

int f(int a,int b,int c){a=a+b+c>2*((a=a>b?a:b)>c?a:c);} 

Like the C solution but with more boilerplate.

-2 bytes thanks (indirectly) to Arnauld!

Try it online!

C (gcc), 40 bytes

-2 bytes thanks to Arnauld: stores the result of max in a. Eliminates the variable m used in the previous solution.

f(a,b,c){a=a+b+c>2*((a=a>b?a:b)>c?a:c);} 

Try it online!

C (gcc), 42 bytes

f(a,b,c){a=a+b+c>2*(a>b?a>c?a:c:b>c?b:c);} 

Try it online!

Never done one of these before. Here are two algorithms borrowed from other answers implemented in JavaScript.

JavaScript, 32 bytes

(a,b,c)=>a+b+c>Math.max(a,b,c)*2 

Try it online

JavaScript, 28 bytes

(a,b,c)=>a=a+b>c&a+c>b&b+c>a 

Try it online

Lua, 128 120 bytes

b=io.read()t={}for r in b.gmatch(b,"([^,]+)")do table.insert(t,r) end print(t[1]+t[2]+t[3]+0>math.max(t[1],t[2],t[3])*2) 

Try it online!

Lua, 37 bytes

@Jo King's solution using TIO properly and following the rules of the challenge.

a,b,c=...print(a+b+c>math.max(...)*2) 

Try it online!

Very direct translation of @xnor's algorithm

Excel, 20 bytes

=SUM(A:A)>MAX(A:A)*2 

Input in A1, A2 and A3.

Alternatively, with input on A1, B1 and C1:

=SUM(1:1)>MAX(1:1)*2 

Pepe, 93 bytes

REeEREeEREeEREEEEeEeEREEEeREEEEEEEREEEEEEEErREEEEEerEEEEEerEeEeErEEEEeeRErREErEEEEeREeReEreEE 

Input: a;b;c
Output: -1 for falsy, 1 for truthy

Explanation:

REeEREeEREeE # Push 3 inputs (num) -> (R) REEEEeEeE # Sort the (R) stack REEEe # Move pointer pos to the last -> (R) REEEEEEE # Move last item of (R) (num c in this case) to (r) REEEEEEEE # Sum the stack (note: does not remove the stack completely!) -> (R) # For some reason, the pointer pos of (R) keeps sticking to the last item rREEEEEe # Subtract active item of (R) (a+b) to (r) (num c) -> (R) # ((a+b)-c) # r flag: Preserve the items rEEEEEe # Same as above, but put it to (r) # This switches the expression: (c-(a+b)) or -((a+b)-c) # No more r flag this time, so remove these two items rEeEeE # Absolute of (r) rEEEEee # Divide active item of (R) (a+b) and (r) (num c) -> (r) RE # Push 0 -> (R) rREE # Create loop labelled 0 -> (R) # r flag: Skip until Ee (or REe) rEEEEe # Decrement (0 -> -1) -> (r) REe # Return to where a goto was called last ReE # If the division of (r) returned 0, go inside the loop reEE # Output (r) as number 

Try it online!

x86-16 machine code, 21 bytes

8B D0 MOV DX, AX ; DX = a 03 C3 ADD AX, BX ; AX = a + b 3B C1 CMP AX, CX ; is a + b > c? 76 0C JBE NOT_TRI ; if so, not triangle 03 C1 ADD AX, CX ; AX = a + b + c D1 E2 SHL DX, 1 ; DX = 2a 3B C2 CMP AX, DX ; is a + b + c > 2a? 76 04 JBE NOT_TRI ; if so, not triangle D1 E3 SHL BX, 1 ; BX = 2b 3B C3 CMP AX, BX ; is a + b + c > 2b? NOT_TRI: C3 RET ; return to caller 

Callable function, input AX, BX and CX. Result is in ZF: NZ if triangle, ZR if not.

Uses Arnauld's method to check.

I/O from DOS test program:

For some reason the test program returns "Hotdog" if a triangle and "Not Hotdog" if not.

Vyxal, 4 bytes

∑½<A 

Try it Online!

C# 35

bool t(int[] s)=>s.Max()*2<s.Sum(); 

:)

TypeScript (TS Type System), 94 85 80

type U<A,B,C,R="">=C extends[...A,...B,...{}]?0:R extends"00"?1:U<C,A,B,`${R}0`> 

Expected values for A, B, C are the usual "unary numbers" (i.e. arrays) used for these challenges.

How it works

• Basically triangle inequality checking

• R is a loop counter

• Rotate args until checked 3 times

• How does extends compare numbers?

  Originally I used this cool idea here, but it turns out we can simplify the check if we have an array of the same number. Now, if left >= right, then returns true, so use the false branch to check again.

Type-safe, ungolfed version:

type U2<A extends any[], B extends any[], C extends any[], R extends string = ""> = C extends [...A, ...B, ...infer S] ? 0 : (R extends "00" ? 1 : U2<C, A, B, `${R}0`>) 

TS Playground

MathGolf, 5 bytes

Σ\╙∞> 

Try it online.

Exact port, including same explanation, as my 5-byte 05AB1E answer: sum; swap; max; double; a>b.

GolfScript, 14 bytes

A port of the Ruby answers.

~.{+}*\$)\;2*> 

Try it online!

Explanation

~ # Evaluate the input . # Copy it twice {+}* # Sum the input \$ # Sort the other input )\; # Select the last item # in the sorted list 2* # Double this item > # Compare