38
\$\begingroup\$

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

\$\endgroup\$
9
  • 3
    \$\begingroup\$ Related: count the number of triangles \$\endgroup\$ Feb 12 '20 at 7:29
  • 7
    \$\begingroup\$ You ask: "is this a triangle?" Probably not, but who knows. Is anything really a triangle? \$\endgroup\$
    – lyxal
    Feb 12 '20 at 9:47
  • 2
    \$\begingroup\$ @Lyxal I say you can be anything. I believe in you. Do you? \$\endgroup\$
    – RGS
    Feb 12 '20 at 13:14
  • 8
    \$\begingroup\$ △ △ ▽ ▽ ◁ ▷ ◁ ▷ A B ␂ \$\endgroup\$
    – S.S. Anne
    Feb 12 '20 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 '20 at 7:33

38 Answers 38

32
\$\begingroup\$

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.

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

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

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

screenshot from jzIntv


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

\$\endgroup\$
6
  • 2
    \$\begingroup\$ +1 Marvelous :D \$\endgroup\$
    – RGS
    Feb 12 '20 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 '20 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 '20 at 15:26
  • \$\begingroup\$ Oh, so that is an emulator. The homepage was unclear. \$\endgroup\$
    – S.S. Anne
    Feb 12 '20 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 '20 at 18:20
9
\$\begingroup\$

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
\$\endgroup\$
10
  • \$\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 '20 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 '20 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\$ Feb 12 '20 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\$ Feb 12 '20 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 '20 at 23:53
7
\$\begingroup\$

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

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

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.

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

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

\$\endgroup\$
3
  • 1
    \$\begingroup\$ Could you not use the short lambda syntax from PHP 7.4? \$\endgroup\$ Feb 12 '20 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 '20 at 10:32
  • \$\begingroup\$ Good job on this PHP answer and +1 for this lambda function! \$\endgroup\$
    – RGS
    Feb 12 '20 at 13:15
6
\$\begingroup\$

Wolfram Language (Mathematica), 12 bytes

2Max@#<Tr@#&

Try it online!

\$\endgroup\$
2
  • \$\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 '20 at 13:31
  • \$\begingroup\$ @RGS Yup! and here are some "master tips"... codegolf.stackexchange.com/q/12900/67961 \$\endgroup\$
    – ZaMoC
    Feb 12 '20 at 14:32
6
\$\begingroup\$

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

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!

\$\endgroup\$
4
  • \$\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 '20 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 '20 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\$ Feb 15 '20 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 '20 at 14:49
6
\$\begingroup\$

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!

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

APL (Dyalog Unicode), 7 bytesSBCS

+/>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 bytesSBCS

∧/+/>+⍨

Try it online!

How it works

∧/+/>+⍨
  +/     ⍝ Is sum
    >    ⍝ greater than
     +⍨  ⍝ twice each number?
∧/       ⍝ All of them?
\$\endgroup\$
3
  • 1
    \$\begingroup\$ Thanks for the submission +1 what is up with the weird character you are using in the explanations? \$\endgroup\$
    – RGS
    Feb 12 '20 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 '20 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 '20 at 15:16
5
\$\begingroup\$

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

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.

\$\endgroup\$
4
  • \$\begingroup\$ These Retina solutions keep amusing me! +1 \$\endgroup\$
    – RGS
    Feb 12 '20 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 '20 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 '20 at 11:28
  • 1
    \$\begingroup\$ @RGS I can't see an obvious approach for that one sorry. \$\endgroup\$
    – Neil
    Feb 13 '20 at 18:47
4
\$\begingroup\$

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.

\$\endgroup\$
5
  • 1
    \$\begingroup\$ Obvious +1 for having the same answer. ;) \$\endgroup\$ Feb 12 '20 at 13:23
  • \$\begingroup\$ @KevinCruijssen Likewise my good man. :-) \$\endgroup\$
    – Noodle9
    Feb 12 '20 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\$ Feb 13 '20 at 7:43
  • \$\begingroup\$ @KevinCruijssen Ah, interesting! Ok, I'll stick with what I've got - thanks anyway! :-) \$\endgroup\$
    – Noodle9
    Feb 13 '20 at 9:49
  • \$\begingroup\$ @ceilingcat Nice one - thanks! :-) \$\endgroup\$
    – Noodle9
    Jul 24 '20 at 0:12
3
\$\begingroup\$

Burlesque, 13 bytes

raJ++j>]2.*.>

Try it online!

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

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!

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

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!

\$\endgroup\$
2
  • \$\begingroup\$ Good job on this one! +1 can you please explain me why you need the #import? \$\endgroup\$
    – RGS
    Feb 12 '20 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 '20 at 16:22
3
\$\begingroup\$

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!

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

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

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

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

\$\endgroup\$
4
  • \$\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 '20 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 '20 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 '20 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 '20 at 11:51
3
\$\begingroup\$

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!

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

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

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

\$\endgroup\$
2
  • 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 '20 at 21:50
  • \$\begingroup\$ @RGS okay, you got me, maybe it was kinda intentional. \$\endgroup\$
    – 640KB
    Feb 16 '20 at 14:49
2
\$\begingroup\$

MathGolf, 5 bytes

Σ\╙∞>

Try it online.

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

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

J, 8 bytes

+/>2*>./

Try it online!

Uses xnor's formula

\$\endgroup\$
2
  • \$\begingroup\$ +1 simple port, right? :) \$\endgroup\$
    – RGS
    Feb 12 '20 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\$ Feb 12 '20 at 8:30
2
\$\begingroup\$

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

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.
\$\endgroup\$
3
  • 1
    \$\begingroup\$ Impressive first answer and very well presented. welcome! \$\endgroup\$
    – ZaMoC
    Feb 12 '20 at 12:35
  • \$\begingroup\$ @J42161217 ditto! \$\endgroup\$
    – RGS
    Feb 12 '20 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 '20 at 14:53
2
\$\begingroup\$

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

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

Stax, 7 bytes

å·b→1.R

Run and debug it

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

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
\$\endgroup\$
2
  • \$\begingroup\$ Cool submission! :D +1 \$\endgroup\$
    – RGS
    Feb 14 '20 at 12:46
  • \$\begingroup\$ Interestingly, SUM(A:A) is exactly the same number of bytes as A1+A2+A3 \$\endgroup\$ Jul 25 '20 at 3:05
2
\$\begingroup\$

Julia 1.0, 20 bytes

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

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ Nice and simple Julia submission +1 :) \$\endgroup\$
    – RGS
    Feb 17 '20 at 8:03

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.