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

R, 27 bytes

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

Attempt This Online!

Completely based on Rui's answer. There was no function defined there, so it was not exactly working.

R, 21 bytes

f=\(x)sum(x)>2*max(x)

Attempt This Online!

ARM64 machine code, 32 bytes

8b010003
eb02007f
8b020023
fa40c064
8b000043
fa41c064
9a9fd7e0
d65f03c0

Try on godbolt

Disassembly:

       0: 8b010003      add     x3, x0, x1
       4: eb02007f      cmp     x3, x2
       8: 8b020023      add     x3, x1, x2
       c: fa40c064      ccmp    x3, x0, #0x4, gt
      10: 8b000043      add     x3, x2, x0
      14: fa41c064      ccmp    x3, x1, #0x4, gt
      18: 9a9fd7e0      cset    x0, gt
      1c: d65f03c0      ret

Pretty straightforward. The conditional compare instruction ccmp helps us combine the tests without branches or additional logic instructions.

This version returns 0 or 1 in x0, like a C function returning bool. If it's acceptable to return the result in the condition codes (zero flag clear if triangle and set if not) then the cset can be omitted, saving 4 bytes.

AWK, 31 bytes

$0=$1+$2>$3&&$1+$3>$2&&$2+$3>$1

Attempt This Online!

Tried a bunch of 'clever' variations but couldn't get it shorter. Prints 1 for truthy, nothing if falsey. Link version prints 0 for falsey.

Nekomata + -e, 3 bytes

∑ä<

Attempt This Online!

Takes input as a list.

∑ä<
∑       Sum
 ä      Divided by 2
  <     Check if every element in the input is less than this

Noulith, 26 bytes

\a,b,c->2*max(a,b,c)<a+b+c

Try it online!

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.

JavaScript (V8), 26 bytes

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

Try it online!

Uiua, 8 bytes

>×2⊃/↥/+

Try it online!

Shorter than Matthew's as a proper function.

sum of the two smaller ones > the largest one is the same as sum of three > twice the max.

>×2⊃/↥/+    input: a vector of three numbers
   ⊃/↥/+    evaluate the max and the sum
 ×2          double the max
>            is the sum greater than double the max?

Go 1.21+, 46 bytes

func(a,b,c int)bool{return 2*max(a,b,c)<a+b+c}

Attempt This Online!

This code works only in Go version 1.21 or later, due to the new min and max builtins introduced in that version.

Headass, 39 bytes

U[U^]OUO]ODO^R^DOD]ONE.U(U<)U(U<)U(U<)?

Try It Online! - prints debug if the input is a triangle, otherwise does nothing

Explanation:

U[U^]OUO]ODO^R^DOD]ONE. block 0
U[                      r2 = a
  U^                    r1 = b
    ]O                  enqueue r1+r2 (a+b)
      UO                enqueue c
        ]O              enqueue c+r2 (a+c)
          DO            enqueue r1 (b), r1 = 0 (unfortunate)
            ^           r1 = b
             R^         r1 += c
               DO       enqueue r1 (b+c)
                 D]O    enqueue r2 (a)
                    NE  go to block 1
                      . end block

U(U<)U(U<)U(U<)? block 1
  U    U    U              if  c   b   a
   <    <    <   is less than
U(   U(   U(                  a+b a+c b+c
    )    )    )    continue
                 else terminate
               ? print 'debug'

This feels mighty golfable but looping in block 1 would be tricky to pull off shorter... i imagine block 0 is refactorable if i finnick with it more but im not in the mood rn

PIC16F88x Machine Code, 12 words (168 bits)

_{Still haven't figured out a good way to list these 14-bit words.}

00100001110000 00011101110001 00001011110010 01100000000011
00000000001000 00110011110010 01011111110010 00011101110010
00001011110000 01110000000011 00001011110001 00000000001000

Takes the arguments in memory locations 0x70-0x72. Sets the carry flag if the values could not make a triangle, and clears it if they can.

For instructions whose names end in F (except BSF), the second argument being 0 indicates the destination is register W, and the second argument being 1 indicates the destination is the first argument.

; Move a into W
00 1000 0111 0000 MOVF 0x70,0
00 1000           MOVF
         111 0000      0x70
        0                   0

; Add b to W
00 0111 0111 0001 ADDWF 0x71,0
00 0111           ADDWF
         111 0001       0x71
        0                    0

; Subtract W from c (c' = c - (a + b))
; SUBWF clears the carry flag when the result is negative, and sets it
; otherwise.
00 0010 1111 0010 SUBWF 0x72,1
00 0010           SUBWF
         111 0010       0x72
        1                    1

; If the carry flag (bit 0 of the status register) is set, return.
01 1000 0000 0011 BTFSC STATUS,0
01 10             BTFSC
         000 0011       STATUS
     00 0                      0
00 0000 0000 1000 RETURN

; Bitshift c right, to divide it by 2.
00 1100 1111 0010 RRF 0x72,1
00 1100           RRF
         111 0010     0x72
        1                  1

; Because RRF performs rotation and not sign-extension, the sign bit is wrong.
; Set it.
01 0111 1111 0010 BSF 0x72,7
01 01             BSF
         111 0010     0x72
     11 1                  7


; Add the new value of c to W, so now W is half the sum of the original
; values.
00 0111 0111 0010 ADDWF 0x72,0
00 0111           ADDWF
         111 0010       0x72
        0                    0

; Subtract W from a, setting the carry flag if a is more than half the sum.
00 0010 1111 0000 SUBWF 0x70,1
00 0010           SUBWF
         111 0000       0x70
        1                    1

; If the carry flag wasn't set, try again with b.
01 1100 0000 0011 BTFSS STATUS,0
01 11             BTFSS
         000 0011       STATUS
     00 0                      0
00 0010 1111 0001 SUBWF 0x71,1
00 0010           SUBWF
         111 0001       0x71
        1                    1

; Return with the carry flag set or clear, depending on the values.
00 0000 0000 1000 RETURN

C# 35

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

:)

Thunno 2 M, 3 bytes

S½<

Try it online!

Port of Kevin Cruijssen's 05AB1E answer.

Explanation

S½<  # Implicit input
S    # Sum the list
 ½   # Halve it
  <  # Compare
     # Minimum
     # Implicit output

Vyxal, 4 bytes

∑½<A

Try it Online!

Vyxal, 5 bytes

Ṗ'ḣ∑≥

Try it Online!

Returns an empty list for valid triangles, nonempty for invalid ones. Fun fact: This works for any polygon.

Ṗ     # Permutations
 '    # Filtered by
  ḣ   # Head
    ≥ # Is greater than or equal to
  ḣ∑  # Sum of the rest

TI-Basic, 7 bytes

sum(Ans)>2max(Ans

Takes input as a list in Ans.

Knight, 32 bytes

O&<=a+0P+=b+0P=c+0P&<b+a c<c+a b

Try it online!

The obvious answer.

Japt -e, 5 4 bytes

Ñ<Wx

Try it here

Husk, 6 bytes

§<ΣoD▲

Try it online!

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.

Julia 1.0, 20 bytes

f(s)=all(sum(s).>2s)

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.

R, 26 bytes

function(x)sum(x)>2*max(x)

Try it online!

If the sum of 3 numbers is greater than twice the greater of those numbers, then the triangular inequality holds.

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!

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

T-SQL, 29 bytes

Returns 1 for true and 0 for false

DECLARE @ table(x INT)
INSERT @ values(1),(1),(1)


SELECT-sum(x)/~max(2*x)FROM @

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

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

Charcoal, 6 bytes

›Σθ⊗⌈θ

Try it online! Link is to verbose version of code. Takes input as an array and outputs a Charcoal boolean, i.e. - for true, nothing for false. Uses @xnor's algorithm. Explanation:

  θ     Input array
 Σ      Summed
›       Is greater than
     θ  Input array
    ⌈   Maximum
   ⊗    Doubled
        Implicitly print

Stax, 7 bytes

å·b→1.R

Run and debug it

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

Keg, -hr, 7 5 bytes

÷⑭$->

Try it online!

Woot! Port of the 5-byte golfscript answer. TIO won't work because the version stored has a bug with the ⑭ command, while the most recent version doesn't. (For those interested, I believe TIO is ~20 commits behind the official repo).

This gets converted into the following python program:

from KegLib import *
from Stackd import Stack
stack = Stack()
printed = False
item_split(stack)
sort_stack(stack)
swap(stack)
maths(stack, '-')
comparative(stack, '>')
if not printed:
    raw(stack)

Explained

÷

First, we take the sides as input. Keg doesn't do lists very well at the moment (I'm working on improving that though), so each number needs to be taken individually. The ¿ takes the input and evaluates it as a literal. Forget I ever said that. One can actually take a list as input lol. So instead of taking three individual numbers, we go ahead and item split the implicit input list.

⑭$->

Then, like the golfscript answer, we sort the stack (⑭), swap the top two items ($) subtract those two items (-) and then finally compare the two with >.

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!

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'.}

Pyth, 8 6 bytes

<yeSQs

Kinda unfortunate that pop is two bytes :'(

Saved 2 bytes thanks to @RGS

Try it online!

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!

Red, 31 bytes

func[a][(sum sort a)>(2 * a/3)]

Try it online!

A port of @xnor's algorithm

Thanks to S.S. Anne for finding an unnecessary newline!

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!

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!

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)

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!

Wolfram Language (Mathematica), 12 bytes

2Max@#<Tr@#&

Try it online!

W d, 12 10 bytes

I'm quite satisfied because W doesn't have a max function. OR a function sorting the array.

▼╪m╜w♣S×∟╖

Uncompressed:

<a&b|R       % Max.
      2*     % Double.
        S    % Swap.
         +r  % Sum.
           < % Less than.
% It's in the wrong order because
% I can golf a few bytes off the max function.

% BTW the max function is implemented like this:
(b<a) && (a) || (b)
% The reduction reduces this function over the whole list.

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

Perl 5 -alp -MList::Util=max,sum, 18 bytes

$_=sum(@F)>2*max@F

Try it online!

Perl 5 -alp, 32 bytes

Otherwise without imports

/ .* /;$_=!grep$_*2>=$`+$&+$',@F

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 ;)

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.

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 :)

Burlesque, 13 bytes

raJ++j>]2.*.>

Try it online!

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

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

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.

J, 8 bytes

+/>2*>./

Try it online!

Uses xnor's formula

MathGolf, 5 bytes

Σ\╙∞>

Try it online.

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

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?

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.