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.


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.


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 so shortest solution in bytes, wins. Consider upvoting this challenge if you have fun solving it and... Happy golfing!

  • 3
    \$\begingroup\$ Related: count the number of triangles \$\endgroup\$ – Kevin Cruijssen Feb 12 at 7:29
  • 6
    \$\begingroup\$ You ask: "is this a triangle?" Probably not, but who knows. Is anything really a triangle? \$\endgroup\$ – Lyxal Feb 12 at 9:47
  • 2
    \$\begingroup\$ @Lyxal I say you can be anything. I believe in you. Do you? \$\endgroup\$ – RGS Feb 12 at 13:14
  • 8
    \$\begingroup\$ △ △ ▽ ▽ ◁ ▷ ◁ ▷ A B ␂ \$\endgroup\$ – S.S. Anne Feb 12 at 15:19
  • 1
    \$\begingroup\$ you should at least admit that your test-cases 1,2,3 are "borderline triangles" as the shorter sides summed give the longest side so you have a "triangle on a line" - while 100,10,10 definitely is false as 10+10 is shorter than 100 \$\endgroup\$ – eagle275 Feb 13 at 7:33

37 Answers 37


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.

  • 3
    \$\begingroup\$ This is also what I had for Python! +1 for us :p \$\endgroup\$ – RGS Feb 12 at 7:22

CP-1610 machine code (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


Instead of testing:


We test:


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:


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


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


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




screenshot from jzIntv

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

  • 2
    \$\begingroup\$ +1 Marvelous :D \$\endgroup\$ – RGS Feb 12 at 9:21
  • 1
    \$\begingroup\$ Do you have to run this on your TV? Maybe an emulator is in order... \$\endgroup\$ – S.S. Anne Feb 12 at 15:15
  • \$\begingroup\$ @S.S.Anne I'm doing 95% of the debugging on jzIntv. For real (much bigger) projects, I do upload the ROM to a real Intellivision from time to time. \$\endgroup\$ – Arnauld Feb 12 at 15:26
  • \$\begingroup\$ Oh, so that is an emulator. The homepage was unclear. \$\endgroup\$ – S.S. Anne Feb 12 at 15:28
  • \$\begingroup\$ I think this should state that it is in machine language, not assembly language. I see that the assembler mnemonics alone are typically four bytes per instruction. PS. +1 Very nice. \$\endgroup\$ – Bit Chaser Feb 12 at 18:20

Java 8, 52 49 38 26 bytes


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:


Try it online.


(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.


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
  • \$\begingroup\$ It is funny that even though you compute the max with a bunch of ?: operators, you can still get it to be shorter than the other answer! \$\endgroup\$ – RGS Feb 12 at 13:20
  • 1
    \$\begingroup\$ Wow! Just looking over the other answers and see we're letter for letter identical (save the C/Java diffs)! I swear I did mine on my own! T_T \$\endgroup\$ – Noodle9 Feb 12 at 13:20
  • 1
    \$\begingroup\$ @RGS Yeah, and the ?: are actually shorter than using the Math.max builtin, since it can only take 2 arguments (Math.max(Math.max(a,b),Math.max(b,c)) is longer than (a>b?a>c?a:c:b>c?b:c)). PS: as List with builtin streams it's even longer: L->L.stream().mapToInt(i->i).sum()>L.stream().max((i,j)->i.compareTo(j)).get()*2 (80 bytes). That was my very first attempt, before I posted my answer and had the 51 bytes alternative. ;) \$\endgroup\$ – Kevin Cruijssen Feb 12 at 13:27
  • 1
    \$\begingroup\$ @RGS That's why it's so fun and I'm still here after almost four years of code-golfing. Although Java will never win a code-golf contest, tbh. Unless it's the only answer of course. ;P \$\endgroup\$ – Kevin Cruijssen Feb 12 at 13:36
  • 1
    \$\begingroup\$ It looks like it's actually shorter to write out a+b>c&b+c>a&c+a>b: TIO \$\endgroup\$ – xnor Feb 12 at 23:53

Ruby, 19 bytes


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

  • \$\begingroup\$ @S.S.Anne Please remember to follow the Code of Conduct. \$\endgroup\$ – Doorknob Feb 15 at 4:45
  • \$\begingroup\$ @Doorknob What did I do? \$\endgroup\$ – S.S. Anne Feb 15 at 14:47

Ruby, 23 bytes


Try it online!

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

  • \$\begingroup\$ +1, I'll take it then :) \$\endgroup\$ – RGS Feb 12 at 8:53

PHP, 45 32 bytes


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

  • 1
    \$\begingroup\$ Could you not use the short lambda syntax from PHP 7.4? \$\endgroup\$ – Guillermo Phillips Feb 12 at 10:25
  • \$\begingroup\$ @GuillermoPhillips thanks a lot, I actually didn't know them, it doesn't appear on the manual (yet?) \$\endgroup\$ – Kaddath Feb 12 at 10:32
  • \$\begingroup\$ Good job on this PHP answer and +1 for this lambda function! \$\endgroup\$ – RGS Feb 12 at 13:15

Wolfram Language (Mathematica), 12 bytes


Try it online!

  • \$\begingroup\$ Thanks for teaching me smth! I'm assuming (1): the single @ can be used to call a function and (2): the trace of a list is its sum. Am I right? \$\endgroup\$ – RGS Feb 12 at 13:31
  • \$\begingroup\$ @RGS Yup! and here are some "master tips"... codegolf.stackexchange.com/q/12900/67961 \$\endgroup\$ – J42161217 Feb 12 at 14:32

05AB1E, 6 5 4 bytes


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

Try it online or verify all test cases.


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


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:


Try it online or verify all test cases.


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


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)
  • \$\begingroup\$ +1 simple enough, right? \$\endgroup\$ – RGS Feb 12 at 7:21
  • \$\begingroup\$ Another alternative 5-byter: xsO‹ß \$\endgroup\$ – Kevin Cruijssen Feb 12 at 13:31
  • 3
    \$\begingroup\$ O;‹ß is 4 bytes. \$\endgroup\$ – Grimmy Feb 12 at 14:50
  • \$\begingroup\$ @Grimmy Ah smart, thanks! \$\endgroup\$ – Kevin Cruijssen Feb 12 at 15:05

C (gcc), 30 bytes

Probably the most basic formula.


Try it online!

  • \$\begingroup\$ Good job recognising the more verbose formula ends up being shorter here! What is the leading a=? Is it for some kind of implicit return? \$\endgroup\$ – RGS Feb 12 at 18:39
  • 2
    \$\begingroup\$ @RGS Yes. The way gcc compiles this, assigning the value to a variable or returning it both put the result in eax and therefore lead to the same behavior. \$\endgroup\$ – Arnauld Feb 12 at 19:16
  • 2
    \$\begingroup\$ I learned so much of C from this answer. I didn't know you could omit the type of parameters, return type, and return statement. \$\endgroup\$ – user1754322 Feb 15 at 11:38
  • 1
    \$\begingroup\$ @user1754322 Just remember to only use it in code golf. This is formally undefined behavior in every C standard. \$\endgroup\$ – S.S. Anne Feb 15 at 14:49

APL (Dyalog Unicode), 7 bytesSBCS


Try it online!

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

How it works

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

Alternative 7 bytesSBCS


Try it online!

How it works

  +/     ⍝ Is sum
    >    ⍝ greater than
     +⍨  ⍝ twice each number?
∧/       ⍝ All of them?
  • 1
    \$\begingroup\$ Thanks for the submission +1 what is up with the weird character you are using in the explanations? \$\endgroup\$ – RGS Feb 12 at 8:11
  • 3
    \$\begingroup\$ @RGS If you mean , it starts a line comment in APL (just like // in C and # in Python). \$\endgroup\$ – Bubbler Feb 12 at 8:15
  • 1
    \$\begingroup\$ @Bubbler But only C99 and after. It's commonly called a "C++-style comment". \$\endgroup\$ – S.S. Anne Feb 12 at 15:16

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!

  • 3
    \$\begingroup\$ you are still using maths :D good job on this! \$\endgroup\$ – RGS Feb 12 at 13:32

Jelly, 4 bytes


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!


Ṁ    | Maximum
 Ḥ   | Doubled
  <  | Less than:
   S | - Sum of original argument
  • 1
    \$\begingroup\$ +1 good job on the port :) \$\endgroup\$ – RGS Feb 12 at 8:48
  • 2
    \$\begingroup\$ @RGS thanks. Nice series of questions recently! \$\endgroup\$ – Nick Kennedy Feb 12 at 8:51
  • \$\begingroup\$ thanks for your feedback, let's keep them coming! \$\endgroup\$ – RGS Feb 12 at 8:57
  • 1
    \$\begingroup\$ Alternative 4 bytes: Ḥ<SẠ for "double of all elements less than sum". \$\endgroup\$ – Bubbler Feb 12 at 9:05

Retina 0.8.2, 31 bytes


Try it online! Link includes test cases. Explanation:


Convert to unary.




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

  • \$\begingroup\$ These Retina solutions keep amusing me! +1 \$\endgroup\$ – RGS Feb 12 at 13:17
  • 1
    \$\begingroup\$ @RGS It's always nice when you can coax Retina to perform functions which seem unrelated to string manipulation. \$\endgroup\$ – Neil Feb 13 at 10:06
  • \$\begingroup\$ Indeed!!! Now I want to see how Retina fares in the count regex matches challenge, which is related to string manipulation! \$\endgroup\$ – RGS Feb 13 at 11:28
  • 1
    \$\begingroup\$ @RGS I can't see an obvious approach for that one sorry. \$\endgroup\$ – Neil Feb 13 at 18:47

C (gcc), 54 \$\cdots\$ 46 42 bytes


Try it online!

Uses xnor's formula.

  • 1
    \$\begingroup\$ Obvious +1 for having the same answer. ;) \$\endgroup\$ – Kevin Cruijssen Feb 12 at 13:23
  • \$\begingroup\$ @KevinCruijssen Likewise my good man. :-) \$\endgroup\$ – Noodle9 Feb 12 at 13:33
  • \$\begingroup\$ You can use the same golf as my Java answer (credit to @xnor): f(a,b,c){a=a+b>c&a+c>b&b+c>a;} EDIT: Nvm, @Arnauld already posted that as a separated C answer. \$\endgroup\$ – Kevin Cruijssen Feb 13 at 7:43
  • \$\begingroup\$ @KevinCruijssen Ah, interesting! Ok, I'll stick with what I've got - thanks anyway! :-) \$\endgroup\$ – Noodle9 Feb 13 at 9:49

Burlesque, 13 bytes


Try it online!

ra # Read as array
J  # Duplicate
++ # Sum
j  # Swap
>] # Maximum
2.*# Double
.> # Greater than
  • \$\begingroup\$ +1 good job working on this :) \$\endgroup\$ – RGS Feb 12 at 8:58

Wren, 54 bytes

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


Try it online!

  • \$\begingroup\$ I have never seen Wren around here, for the short time I've been around \$\endgroup\$ – RGS Feb 12 at 13:25

C++ (gcc), 89 bytes

Array/vector solution as shown in other answers.

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!

  • \$\begingroup\$ Good job on this one! +1 can you please explain me why you need the #import? \$\endgroup\$ – RGS Feb 12 at 15:56
  • \$\begingroup\$ @RGS Because functions (like std::sort) are not implicitly declared in C++, and std::vector is not a builtin. \$\endgroup\$ – S.S. Anne Feb 12 at 16:22

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.


Try it online!

C (gcc), 42 bytes


Try it online!

  • \$\begingroup\$ Good solution +1! It is a shame that the m doesn't save you anything... \$\endgroup\$ – RGS Feb 12 at 15:06

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

JavaScript, 32 bytes


Try it online

JavaScript, 28 bytes


Try it online

  • 1
    \$\begingroup\$ Really good job James! +1 And welcome to the site :D \$\endgroup\$ – RGS Feb 13 at 11:48

Lua, 128 120 bytes

b=io.read()t={}for r in b.gmatch(b,"([^,]+)")do
table.insert(t,r) end

Try it online!

Lua, 37 bytes

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


Try it online!

Very direct translation of @xnor's algorithm

  • \$\begingroup\$ Hey there, if I understand correctly, you are spending quite some bytes reading from input and extracting the integers. Can't you define a shorter function that already takes the integers? And then you do the IO parsing in the header section of TIO? \$\endgroup\$ – RGS Feb 12 at 8:48
  • \$\begingroup\$ @RGS, Yes, absolutely. I can post a solution like that in the comments. Just gimmee a bit.... \$\endgroup\$ – ouflak Feb 12 at 8:49
  • \$\begingroup\$ no need to be in the comments! Rewrite your answer. In this community, and for code-golf, you can usually just write the function that does what is asked, as long as your function accepts the input as specified by the OP. I can't really elaborate on it now nor exemplify with Lua because I don't know lua, but I'm sure you can reduce your byte count by a lot if you do what I mean \$\endgroup\$ – RGS Feb 12 at 8:57
  • \$\begingroup\$ @JoKing, I've really got do some study and wrap my head around how to use TIO's header properly. \$\endgroup\$ – ouflak Feb 13 at 11:51

Pepe, 93 bytes


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


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!

  • \$\begingroup\$ Really funny solution! +1 good job! \$\endgroup\$ – RGS Feb 15 at 8:30

MathGolf, 5 bytes


Try it online.

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

  • \$\begingroup\$ But in this case, it is shorter! \$\endgroup\$ – RGS Feb 12 at 8:12
  • \$\begingroup\$ @RGS What do you mean? Both are 5 bytes, and the exact same explanation. \$\endgroup\$ – Kevin Cruijssen Feb 12 at 8:14
  • \$\begingroup\$ I meant your original O5AB1E one was 6 bytes :p \$\endgroup\$ – RGS Feb 12 at 8:45

J, 8 bytes


Try it online!

Uses xnor's formula

  • \$\begingroup\$ +1 simple port, right? :) \$\endgroup\$ – RGS Feb 12 at 8:12
  • 1
    \$\begingroup\$ @RGS Yes, it's almost identical to Bubbler's APL solution - it's normal, J is APL's relative. \$\endgroup\$ – Galen Ivanov Feb 12 at 8:30

GolfScript, 14 bytes

A port of the Ruby answers.


Try it online!


~              # 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
  • \$\begingroup\$ Good job on this answer! \$\endgroup\$ – RGS Feb 12 at 13:22

W d, 12 10 bytes

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



<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.
  • 1
    \$\begingroup\$ Impressive first answer and very well presented. welcome! \$\endgroup\$ – J42161217 Feb 12 at 12:35
  • \$\begingroup\$ @J42161217 ditto! \$\endgroup\$ – RGS Feb 12 at 13:27
  • 3
    \$\begingroup\$ I feel like there was another higher-up user named a'_' that went missing recently. Hmm... \$\endgroup\$ – S.S. Anne Feb 12 at 14:53

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
maths(stack, '-')
comparative(stack, '>')
if not printed:



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

  • 1
    \$\begingroup\$ Kool answer! +1 To bad you have to spend three bytes reading the integers! \$\endgroup\$ – RGS Feb 12 at 23:11
  • \$\begingroup\$ @RGS whatever do you mean by spending three bytes to read the integers? :P \$\endgroup\$ – Lyxal Feb 12 at 23:14
  • \$\begingroup\$ Nevermind me :) Can't upvote anymore today :( will try to remember to do it tomorrow! \$\endgroup\$ – RGS Feb 12 at 23:19
  • \$\begingroup\$ @RGS I know that feeling :P. \$\endgroup\$ – Lyxal Feb 12 at 23:20
  • \$\begingroup\$ one up!! Go work on those lists now!!! \$\endgroup\$ – RGS Feb 13 at 0:41

Stax, 7 bytes


Run and debug it

  • \$\begingroup\$ Haven't heard of Stax before! Good work on this +1 \$\endgroup\$ – RGS Feb 13 at 8:36

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? 
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: enter image description here

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

  • 1
    \$\begingroup\$ Nice submission! Are you being serious with the "for some reason" or did you make the program return (not) hot dog for Truthy and Falsy? :) \$\endgroup\$ – RGS Feb 15 at 21:50
  • \$\begingroup\$ @RGS okay, you got me, maybe it was kinda intentional. \$\endgroup\$ – 640KB Feb 16 at 14:49

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


Try it online!

Perl 5 -alp, 32 bytes

Otherwise without imports

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

Try it online!

  • \$\begingroup\$ +1 for your answer, and I had never seen people doing "imports" with flags! Amusing :D even though it feels unfair :( \$\endgroup\$ – RGS Feb 12 at 8:12
  • \$\begingroup\$ iv'e added another answer without using imports \$\endgroup\$ – Nahuel Fouilleul Feb 12 at 11:37
  • \$\begingroup\$ you are welcome to use "imports" in the flags! I was just thinking it is quite nice that you can "get away" with it :) \$\endgroup\$ – RGS Feb 12 at 13:23
  • \$\begingroup\$ meta on imports codegolf.meta.stackexchange.com/questions/4776/… \$\endgroup\$ – qwr Feb 14 at 0:13

Japt -e, 5 bytes


Try it online.

  • \$\begingroup\$ for a simple answer. What does "transpiled JS" mean in the Japt console? (Btw looks like the cockpit for a spaceship! +1) \$\endgroup\$ – RGS Feb 12 at 13:29
  • \$\begingroup\$ No, it needs to be UNIX. \$\endgroup\$ – S.S. Anne Feb 12 at 15:09

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.