[Question]
  [
# Task
Write a function/program that, given three positive integers `a`, `b` and `c`, prints a Truthy value if a triangle (any triangle) could have side lengths `a`, `b` and `c` and outputs a Falsy value otherwise.
# Input
Three positive integers in any sensible format, for example:
* three distinct function arguments, `f(2, 3, 5)`
* a list of three numbers, `[2,3,5]`
* a comma-separated string, `"2,3,5"`
You may *not* assume the inputs are sorted.
# Output
A Truthy value if a triangle could have the sides with the lengths given, Falsy otherwise.
# Test cases
```
1, 1, 1 -> Truthy
1, 2, 3 -> Falsy
2, 1, 3 -> Falsy
1, 3, 2 -> Falsy
3, 2, 1 -> Falsy
3, 1, 2 -> Falsy
2, 2, 2 -> Truthy
3, 4, 5 -> Truthy
3, 5, 4 -> Truthy
5, 3, 4 -> Truthy
5, 4, 3 -> Truthy
10, 9, 3 -> Truthy
100, 10, 10 -> Falsy
```
---
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest solution in bytes, wins. Consider upvoting this challenge if you have fun solving it and... Happy golfing!
  
[Answer]
# [Python](https://docs.python.org/2/), 24 bytes
```
lambda l:sum(l)>max(l)*2
```
[Try it online!](https://tio.run/##LYtBDgIhDEX3nKJLMCykDAsn0ZO4wehkSACJMlFPj201aft@f3/bp6/3imM5nkeO5XKNkOfnVnQ2pxLfhB2O15ryDdzcHql2WHSqbevamOEscCkaaMErlN3z7slSXnzH5Ajf8e9PFgIzkFRB8sJJ/vcWDj9ByknDFw "Python 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.
[Answer]
# [CP-1610](https://en.wikipedia.org/wiki/General_Instrument_CP1600) machine code ([Intellivision](https://en.wikipedia.org/wiki/Intellivision)), 12 DECLEs1 = 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
[![output](https://i.stack.imgur.com/L54jB.gif)](https://i.stack.imgur.com/L54jB.gif)
*screenshot from [jzIntv](http://spatula-city.org/~im14u2c/intv/)*
---
*1. A CP-1610 opcode is encoded with a 10-bit value (0x000 to 0x3FF), known as a 'DECLE'.*
[Answer]
# Java 8, ~~52~~ ~~49~~ ~~38~~ 26 bytes
```
(a,b,c)->a+b>c&a+c>b&b+c>a
```
Port of [*@xnor*'s formula](https://codegolf.stackexchange.com/a/199355/52210) 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](https://codegolf.stackexchange.com/a/199354/52210) is actually shorter in Java:
\$(a+b>c)\land(a+c>b)\land(b+c>a)\$
[Try it online.](https://tio.run/##bVFNa8MwDL33V4gcioPV0DrJYSvLP1gvPY4dZNcd7lKnNG5hjP72TPlgJNmwkdDzk554PtGdVqfDZ2NKqmt4Jee/FwDOB3s9krGwa0sAXVWlJQ9G8BMQtgzQfTLxljmPBYc6UHAGduDhBRpBqNHEq4KkLsySpCn0UnOkZtuyLzddMntoulfuAGdeQOzD1fmPt3eguFcPtg5ig3w6qV9AYToGFDPSKSNFNQa4nM5IuUVNZ6h5S4b5FMgxGwM5q8yAbLbHGp/myBo37f3jXWdDx/nP6d6P/Vcd7DmpbiG5sFWh9IJkhJHUXTQyeoZI@sQMPzCIPJof)
**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](https://codegolf.stackexchange.com/a/199362/52210) with input as a Stack of Integers.
[Try it online.](https://tio.run/##dZHBb4IwFMbv/hUvO5WIjYIeNpyJxyXMS4/LDhU6U62FtA8XY/zbWcHOAWahoemP7339eG/PT3yyzw91pri18M6lvowApEZhvngmYNMcAbZFoQTXkJG9q6AVSkUZ8uywfHPSnTArSIPESa8j97LIUWawAQ2vULPJ6sKoLQwSXSkVJEZgZTQwWhYlCZZ@H/s9udZJY1JWW@VMvNepkDkcXTzC0Ei9@/gEHtyyobBIZqF72gR3EIVxF0ROEfcVcRh1gTv2PWJXEvU9omHJPFz0wSKcd8HC3TIA80GOafg8JNNw1qyHlrZtaDW@75TSeyP@RpNKi53JuClo8d35vjaGnxsRGTBLuW05D3ygf@fNHlxvghXxlYzyPF8rRdJfcLYojrSokJZuhqg0ScdPL/A01jQjLPB/e61/AA)
**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
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 23 bytes
```
->*a{a.sort!.pop<a.sum}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf104rsTpRrzi/qERRryC/wAbILs2t/R9tqKMARlxA0khHwViHywgsYgwWMQYJcoFJkBpjsJQRWI0RTMpER8EUzDAFsblMwbogDBOIOQY6CpZQFpBpCMaxeqmJyRnxxTmZyakaxprVNYk6STrJNQUK0WCGThqEjo2t/Q8A "Ruby – Try It Online")
A different approach, xnor's formula would be shorter but I'm satisfied with that.
[Answer]
# Ruby, 19 bytes
```
->*a{2*a.max<a.sum}
```
You can [try it online](https://tio.run/##NYzdCsIwDIXv@xS51BGLS9YLQX2RUSQrGwoOZGOgbHv2uqYK@fk45yTD1Hxid4mHayEzFWJ7eZ/FjlO/xrpE0DLbJARGQ6qwKpxEozNlWC3SDP2tCsEpuMTG6VWGKv85Ipx@tGGp7W0r4X4bn4/Q7ng/L4INhuUFtQJ2eXu/xi8)!
Uses the fact that [this Ruby answer](https://codegolf.stackexchange.com/a/199362/75323) said it didn't want to implement the port of [xnor's answer](https://codegolf.stackexchange.com/a/199355/75323) and at the same time taught me enough syntax to guess how the max of an array is calculated :)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~6~~ ~~5~~ 4 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
O;‹ß
```
-1 byte by porting [*@xnor*'s algorithm](https://codegolf.stackexchange.com/a/199355/52210).  
-1 byte thanks to *@Grimmy* using a derived formula.
[Try it online](https://tio.run/##yy9OTMpM/f/f3/pRw87D8///jzbSAcJYAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfaXLf3/rRw07D8//r/M/OtpQBwhjdYC0kY4xkDYC8o3BfGMdIyANJMHyxkBxI7C8EVTcRMcUTJvqmABpU6B6CG0C0W@gYwllGOgYglBsLAA).
**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](https://tio.run/##yy9OTMpM/f//cMORtsN7tB817Az4/z/aSAcIYwE) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfaXL/8MNR9oO79F@1LAz4L/O/@hoQx0gjNUB0kY6xkDaCMg3BvONdYyANJAEyxsDxY3A8kZQcRMdUzBtqmMCpE2B6iG0CUS/gY4llGGgYwhCsbEA).
**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)
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 30 bytes
Probably the most basic formula.
```
f(a,b,c){a=a+b>c&a+c>b&b+c>a;}
```
[Try it online!](https://tio.run/##dY1BCoMwEEX3nmIQKgmO0BhdFKl3mUQiQmulLe1CvHrTaRaSLEqSIe/9T2Kr0VrvnSA0aOVKZypNbwsqbW8Kw5O6zU/zE640zeJ1mwYJawaw3Fk6wTeA/DD8WzmGhhMK4bdlxDWC3rkOuY5zzZWddeirmFWc1yFP@g1CG3PLauc2vJ9wk/x/RDilgo0KR7KSXbb5j3UXGh@@en8B "C (gcc) – Try It Online")
[Answer]
# [PHP](https://php.net/), ~~45~~ 32 bytes
```
fn($a)=>max($a)*2<array_sum($a);
```
[Try it online!](https://tio.run/##jZBNDsIgEEb3nmJCumgNNhbahemPB1FjiNF000pqTfT0yCBVO2wkLODx5gNGt9pUW91qiMbaXPo4UknddOqBi6Wo1DCo5/F273BfmvOpvQLLOOAEO1YNsDQa451nhyRl@56Vi48pOEhqIiOmcPVz07MwU9oImonsD1O62@k7pbspMLMwU7h6Qd8pQtPW5xwKmoksNAt7QE1kxCzcj@amZ6GZ0356Rru05rB5q99@ehaoluNZ9qtObJLNCw "PHP – 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 `;`)
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 12 bytes
```
2Max@#<Tr@#&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b738g3scJB2SakyEFZ7X9AUWZeSbSyrl2ag3Ksmr5DNVe1oQ4Q1uqAGEY6xiCGkY6CoY6CMURMwVhHwQjEBNFACSjTECpqBBaFKTDRUTCFMk2BPBDTFGwCjGkCM9dAR8ESzgZyDMG4lqv2PwA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [GolfScript](http://www.golfscript.com/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!](https://tio.run/##S8/PSStOLsosKPkfbaxgomAe@1@lLkbX7v9/AA "GolfScript – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 7 bytesSBCS
```
+/>2×⌈/
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///X1vfzujw9Ec9Hfr/0x61TXjU2/eob6qn/6Ou5kPrjR@1TQTygoOcgWSIh2fw/0e9cxVCikpLMiq50g6tUNAwVABCTQUNIwUgBNLGCiYKpmDaVMEESJsqGENpEwVjIG1ooGAJZHCBzHFLzCmGG2MEljYCGgdWBtQGMc4IbLwxUNwIrN1AwRCENAE "APL (Dyalog Unicode) – Try It Online")
Also uses [xnor's formula](https://codegolf.stackexchange.com/a/199355/78410) of `sum(a,b,c) > 2 * max(a,b,c)`.
### How it works
```
+/>2×⌈/
+/       ⍝ Is sum
  >      ⍝ greater than
   2×    ⍝ twice of
     ⌈/  ⍝ max?
```
---
# Alternative 7 bytesSBCS
```
∧/+/>+⍨
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1HHcn1tfTvtR70r/qc9apvwqLfvUd9UT/9HXc2H1hs/apsI5AUHOQPJEA/P4P@PeucqhBSVlmRUcqUdWqGgYagAhJoKGkYKQAikjRVMFEzBtKmCCZA2VTCG0iYKxkDa0EDBEsjgApnjlphTDDfGCCxtBDQOrAyoDWKcEdh4Y6C4EVi7gYIhCGkCAA "APL (Dyalog Unicode) – Try It Online")
### How it works
```
∧/+/>+⍨
  +/     ⍝ Is sum
    >    ⍝ greater than
     +⍨  ⍝ twice each number?
∧/       ⍝ All of them?
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
ṀḤ<S
```
[Try it online!](https://tio.run/##y0rNyan8///hzoaHO5bYBAMZ@6wfNcxR0LVTeNQw1/pwO9fh9kdNayL//4@ONtRRAKFYHQUQ00hHwRjENAKLGkNFjYESIKYxWIEhlGkIFTUCi8IUmOgomEKZpkAeiGkKNgHGNIGZa6CjYAlnAzmGYBwbCwA "Jelly – 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](https://codegolf.stackexchange.com/a/199355/42248) so be sure to upvote that one too!
## Explanation
```
Ṁ    | Maximum
 Ḥ   | Doubled
  <  | Less than:
   S | - Sum of original argument
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 31 bytes
```
\d+
$*
O`1+
^(?!(1+),(1+),\1\2)
```
[Try it online!](https://tio.run/##HYqxCsMwDER3/UWhAae@wZLtIVPHjvkBExxohy4ZQv7fORtJT8fjzt/1P/Y2uU9t5evl@ZK1qpfNvR9O/YyBosXm1hQcURiiGHNkjjDh0Ucao7dhEjKZkSSz05l6P2AZL0D73g "Retina 0.8.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.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~54~~ \$\cdots\$ ~~42~~ 36 bytes
Saved 6 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!!
```
f(a,b,c){a=a+b+c>2*fmax(a>b?a:b,c);}
```
[Try it online!](https://tio.run/##bZJRa4MwEMff@ykOoaA1Mo3tQ@d0D2OfYspIYuyEaovxIUz86nMxGpmu8r9w@r/fRY5j3oWxYShsgihiTkdi4lKXJfhQVETaJKGv5Hl0on4o6xYqUta2s@t2oB72RZoDNB8ZxNBZqXzHqTy/qThZCP6@h1YfaWJs0XLRfpIJChAoYX2GWtgkJ63AH8Pf4nTBFxabVkcNhjo5j/QWZgscrkmsyaPWZK1gLu9ctjzXuOb9tYJ/Mnhxa8Aee5R1zqXC/WhOX0CU3/xW2Ka78zR/UOVOBK6r6xyYRm7@hage8yC1n0UrmxqbPrSZsdlDWyjbbMTa4cpZxrBF740qKWxrnyOYArxkPPcirdVGEAQUAUMgkFoa1SoGkc0X9Lt@@GHFlVzE4F2rXw "C (gcc) – Try It Online")
Uses [xnor](https://codegolf.stackexchange.com/users/20260/xnor)'s formula.
[Answer]
# [Uiua](https://www.uiua.org/), ~~7 bytes~~ 9 bytes (SBCS)
```
|1<+/∘⊏⍖.
```
[Try it online!](https://www.uiua.org/pad?src=VHJpYW5nbGUg4oaQIHwxIDwrL-KImOKKj-KNli4KClRyaWFuZ2xlWzEgMSAxXSAgICAgIyBUcnV0aHkKVHJpYW5nbGVbMSAyIDNdICAgICAjIEZhbHN5ClRyaWFuZ2xlWzIgMSAzXSAgICAgIyBGYWxzeQpUcmlhbmdsZVsxIDMgMl0gICAgICMgRmFsc3kKVHJpYW5nbGVbMyAyIDFdICAgICAjIEZhbHN5ClRyaWFuZ2xlWzMgMSAyXSAgICAgIyBGYWxzeQpUcmlhbmdsZVsyIDIgMl0gICAgICMgVHJ1dGh5ClRyaWFuZ2xlWzMgNCA1XSAgICAgIyBUcnV0aHkKVHJpYW5nbGVbMyA1IDRdICAgICAjIFRydXRoeQpUcmlhbmdsZVs1IDMgNF0gICAgICMgVHJ1dGh5ClRyaWFuZ2xlWzUgNCAzXSAgICAgIyBUcnV0aHkKVHJpYW5nbGVbMTAgOSAzXSAgICAjIFRydXRoeQpUcmlhbmdsZVsxMDAgMTAgMTBdICMgRmFsc3k=)
**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](https://codegolf.stackexchange.com/users/78410/bubbler).
[Answer]
# [J](http://jsoftware.com/), 8 bytes
```
+/>2*>./
```
[Try it online!](https://tio.run/##Tc09CoAwDIbh3VN8uBT/apu2g4IugpOTVxBFXLz/VJuhREKGJ@@QJ5ZaXZhGKLQwGNN2Gsu@rbHpZ6pn3ceqQHEe94sLlkdAcBmU6KQ4UIbjJrBSiEeKRxAE@IzATeB/fwyGFIWGT9bEDw "J – Try It Online")
Uses [xnor's formula](https://codegolf.stackexchange.com/a/199355/75681)
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), 13 bytes
```
raJ++j>]2.*.>
```
[Try it online!](https://tio.run/##SyotykktLixN/Z@TV/2/KNFLWzvLLtZIT0vP7n9tbvT/aEMdBRCK5QKxjHQUjIEsI7CYMUTMGCgMZBmDZQ0hLEOImBFYDCproqNgCmGZAjlAlilYL5RlAjXPQEfBEsYEsg3BOBYA "Burlesque – Try It Online")
```
ra # Read as array
J  # Duplicate
++ # Sum
j  # Swap
>] # Maximum
2.*# Double
.> # Greater than
```
[Answer]
# [Wren](https://github.com/munificent/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!](https://tio.run/##Ky9KzftfllikkFkcUpSZmJeek6pgq/DfLU8vL7W8uqaipkKvKDWlNDm1uiZRJ6kmUTup1g5NyC7JPtEqqVbLqPZ/cGVxSWquXnlRZkmqBsJEveTEnByNaEMdIIzV1PwPAA "Wren – Try It Online")
[Answer]
# [C++ (gcc)](https://gcc.gnu.org/), 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!](https://tio.run/##bZLNboQgEIDvPsXEJi60bOLPeqgae@sT9Lb1YBS3JqsYROJm47NbxP4pJRrkm2@YCVJ03fFSFPP8UDcd4yLh9ELH1KpbARXqRRlFkhaC8USRVOK7Rr0ykSPPbkacR9qWSGIccyoG3oI8@1kiz172tMTjSe3cFtehpJDUrBec5k1q6f2bvG6RZHWJrbsFavwtty@dgtTOauov8Ih@YCJb6BMIttDXZmCYgZK3MNDpngE9w/S1aaafCIQGDBXfwlBXN@HJ7NMl8PwPVdjT73dgii09V4yjfBAMnBEikHh3cPpoCzYISBIY1U9aZpuAva693drPfjJ/x2LAMV0dVKERwwvYb3wQHzdbFbVf82t/s/ESPry3h3htcO3v66a4sTXNnw "C++ (gcc) – Try It Online")
# [C++ (gcc)](https://gcc.gnu.org/), 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](https://codegolf.stackexchange.com/users/58563/arnauld)!*
[Try it online!](https://tio.run/##bZDNboMwDIDveQqLSWuyphI/7WHA0tueYLethxDohtRCBQG1qnh2lhhtHc0isJ2Pz8GKOp1Wn0qNY1lp2FMbJbcxw6jYVb7IZbZUInyi1NQi28o4Y0KZpFgyjA9lpQ5dXkBa1q1uCnkU5Mb6Qum6EYTY046yrGhflzkjVwJmtTqP40lJ/9ZGFgJ6dCYTKwg4PjDwOQw5RHMYohk5ZmTkOYywPXBg4Jghmm77msPGgRvD53CDf3fh2p3T5/D8DzU4wPfnw5AQzPu6obLTNTyeIYae3V0cXq2qOw1pCud3f2ezx8Gb9sHdPtz9dt6WNWAlJofuqT2GYzPHFgZb8N6aTn9dPDOD9yoP7cVj1l58VItkmncatyl011TgJ2QYvwE "C++ (gcc) – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 40 bytes
*-2 bytes thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/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!](https://tio.run/##fZHfboMgFMbveYoTliYw6eaferFa7d2eYHfOC8S6knS6oF3SNT67Y8dsjWUpgZwvv/MdOIBavik1jjWTohSKn2UqvdJTWXjPmNVZuZXrkmfKBsWTYbzTjTocqx1sur7S7cM@I0Q3PbxL3bDPVlecnAnY8QOlMXmRRwWkiKYEKggEThjEHIYCojkM0Rk5zsia5zDC8sCBgeMM0emWrwTEDowtn8MYT3fhyu3TF/D0D7U4wPWbGBKCsW4Nw7dTkIKf2LCBTn/tWvtDxvDHi879gtu85wG/et0PYzeoGV1UAqYFywwW3WtDBf6JKmzxnwwuMiwubd4cUwc39uGwBfpijv3@RGEN9FkeuhPlyXRZMozf "C (gcc) – Try It Online")
# [C (gcc)](https://gcc.gnu.org/), 42 bytes
```
f(a,b,c){a=a+b+c>2*(a>b?a>c?a:c:b>c?b:c);}
```
[Try it online!](https://tio.run/##fZHNboMwDMfveQorUyUy0o2PchgUuO0JdmMcQihrpA6mQCd1Fc/OMqOtoplqJbL189@JE8v1m5TT1DiCV1yys0iFW7kyC@4dkVW5yGQuYhlXxlexZMk43alWHo71Drb9UKvuYZ8RotoB3oVqnc9O1YycCRj7gULroizCElJEcwIj8DkuGPkSBhzCJQxQGVrK0IiXMMRy34K@pQxQaZdvOEQWjAxfwghvt@HG7tPj8PQPNdjH/ZsYE4K@6bSDfychBS8xbgu9@tp1ZkZas8dLXHglM3nXBXb1ux/aHNA4dFVzmDesM1j1ry3lOBNZmuK/0L@EQXlp86bNHdw4h0EO9EUfh/2JQgz0WRz6E2XJ/FgyTt8 "C (gcc) – Try It Online")
[Answer]
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](https://tio.run/##fc9NDoIwEAXgvaeYJZWRMFQSXcANPMTQUH@CYKASb1/bxpiY2CbTTb/XyeuNV17UfH2Y3XqwahoXAxoamzF2qETTct7lqj2xuRR3fn2ut1WITkNfDNM50xkh@BEIZn72YvOrFYKfiEqEPUId19oFIupIJtVtlhGlEuGY4FDaq@Zh@fcnSjCFYlWMZVhOCabEaypddQrnG7Fv)
# JavaScript, 28 bytes
```
(a,b,c)=>a=a+b>c&a+c>b&b+c>a
```
[Try it online](https://tio.run/##fc9BCsMgEAXQfU8xqxDJtGRiA@1C7zJKLC2hKdHm@qm6KBSqMLp53@H74I29Xe@vcNwuu12ePoADtbeMBq1QmhV3RtuGO6tNY@LNObbM02lebq1rCSGNQAjrexKHXx0Q0hRUIpwRxrKOMVDQSLKqcbMsKPUI1wrn0kkdz/7fn6jClIsNJZZ5OVWYKq@pj9Upn29k/wA)
[Answer]
# [Lua](https://www.lua.org/), ~~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!](https://tio.run/##HcxBCsMgEIXhfU4hWTnNII1ZpxcRC1ptIyQaplMolJ7dxm4e/Hzw1per1c@pKIouSOD5870XEiRSFl49Nse3RXrspbmiHaCHUDp2fo0q5WcklowEIubQ7ZTykWa0AxvdZrLD@XI8LGpz779gE2wCJw21jqhx@gE "Lua – Try It Online")
# [Lua](https://www.lua.org/), 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!](https://tio.run/##yylN/P8/USdJJ9lWT0@voCgzr0QjUTtJO9kuN7EkQy83sUIDKK6pZaT5//9/0/9m/80B "Lua – Try It Online")
[Very direct translation of @xnor's algorithm](https://codegolf.stackexchange.com/a/199355/42248)
[Answer]
# 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
```
[Answer]
# [Pepe](//github.com/Soaku/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!](https://soaku.github.io/Pepe/#RRRRv!pE7Sf@&1&0@y_w&@F-gDBM)
[Answer]
# 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](https://codegolf.stackexchange.com/a/199368/84624) to check.
**I/O from DOS test program:**
[![enter image description here](https://i.stack.imgur.com/fkYWq.png)](https://i.stack.imgur.com/fkYWq.png)
For some reason the test program returns `"Hotdog"` if a triangle and `"Not Hotdog"` if not.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 4 bytes
```
∑½<A
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJBIiwiIiwi4oiRwr08QSIsIiIsIlsxMDAsIDEwLCAxMF1cblsxLCAyLCAzXVxuWzIsIDEsIDNdXG5bMSwgMywgMl1cblszLCAyLCAxXVxuWzMsIDEsIDJdXG5bMiwgMiwgMl1cblszLCA0LCA1XVxuWzMsIDUsIDRdXG5bNSwgMywgNF1cbls1LCA0LCAzXVxuWzEsIDEsIDFdXG5bMTAsIDksIDNdIl0=)
[Answer]
# C# 35
```
bool t(int[] s)=>s.Max()*2<s.Sum();
```
:)
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 5 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
Σ\╙∞>
```
[Try it online.](https://tio.run/##y00syUjPz0n7///c4phHU2c@6phn9/9/tKEOEMZyAWkjHWMgbQTkG4P5xjpGQBpIguWNgDSEb6JjCqZNdUyAtClQHYQ2gegz0LGEMgx0DEEoFgA)
Exact port, including same explanation, as [my 5-byte 05AB1E answer](https://codegolf.stackexchange.com/a/199354/52210): sum; swap; max; double; a>b.
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 14 bytes
A port of the Ruby answers.
```
~.{+}*\$)\;2*>
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/v06vWrtWK0ZFM8baSMvu//9oQwMDBUMQigUA "GolfScript – 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
```
[Answer]
## [W](http://github.com/a-ee/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.
```
]