text:
Can I join the music box?
The magic music box (MMB)
This explains the motivation for the challenge, feel free to ignore.
The magic music box is a word game played by a group of people, where one is the owner of the magic music box and the other people are trying to put words inside the magic music box.
Rules for the game with humans: the game goes in turns, one person at a time. In your turn, you have to say a word you want to put in the MMB and the MMB owner says if your word can get in or not, depending on the game criterion. If you are the MMB owner, you have to say a word that can go in the MMB.
The task
You have to code a function/program that receives a word as input (in any sensible format) and outputs Truthy or Falsy. Truthy if the word can go in the MMB and Falsy otherwise.
For a word to be able to go in the MMB, it has to contain at least one of the following seven strings:

do
re
mi
fa
sol
la
si

Input
A lowercase "word" in any sensible format, for example:

a string
a list of characters
a list of ASCII values of the characters

Test cases
(Edited test cases to include obsolete, also, some answers may not have it yet)
far -> Truthy
solace -> Truthy
boat -> Falsy
shrimp -> Falsy
fire -> Truthy
summit -> Truthy
biscuit -> Falsy
bullet -> Falsy
doctor -> Truthy
blast -> Truthy
college -> Falsy
subsidiary -> Truthy
obsolete -> Truthy
also -> Falsy

Is the input guaranteed to be in lower case?

@Arnauld you can assume that, even though it was not in my original plans :p

05AB1E, 15 14 bytes
’ïêo‡Åefa’7äåà

Try it online!
’ïêo‡Åefa’        # dictionary string "soldosimilarefa" (using the words sold and similar)
          7ä      # split in 7 parts of almost-equal length (excess length goes to the first parts)
            å     # for each part, check if it’s in the input
             à    # maximum

+1 for the nice fact that you golfed the musical notes! Do you have any idea if the string compression bit is similar to how string compression works in Jelly?

Jelly,  18  14 bytes
-4 thanks to Nick Kennedy & Grimmy's 05AB1E answer
7“Ẉ|nŻUḋ}»œsfẆ

A monadic Link accepting a list of characters which yields a, possibly empty, list of lists.
Try it online!
How?
Note that in Jelly an empty list is falsey, while a non-empty list is truthy (as employed by the if-else, ”T”FÇ?, in the footer of the Try it online link, above).
7“Ẉ|nŻUḋ}»œsfẆ - Link: list of characters, w
7              - seven
 “Ẉ|nŻUḋ}»     - "solfa"+"similar"+"edo"
          œs   - split into (seven) equal chunks
                  -> ["sol","fa","si","mi","la","re","do"]
             Ẇ - all sublists (w)
            f  - filter keep

Aside: solfa is a name of a solfège method, where tones are given single syllable names, and was when si first became ti.

+1 nice solution, it is just a shame that you didn't manage to compress sol together with the other 6 musical notes

let me rephrase that :) it is a shame that compressing sol didn't allow for a well-golfed solution :/ it may be interesting including your 19 byte in the answer and noting that it would've been longer.

I've added an 18 with it in now.

“⁴ịṚn;ỊæṂ»œs7$fẆ 16 based on yours and @Grimmy’s.

@NickKennedy ah yeah "sol" at the front allows œs

@NickKennedy make that 14 :)

Very nice job, too bad I can't go for +2 :p

Python, 52 bytes
import re
re.compile('do|re|mi|fa|sol|la|si').search

Try it online!
Yup, a regex. A match produces a Truthy match object, and a non-match produces a Falsey None. Using re.compile to make an compiled pattern as a function is a bit shorter than a direct lambda:
55 bytes
lambda w:re.search('do|re|mi|fa|sol|la|si',w)
import re

Try it online!
For comparison, without regex:
58 bytes
lambda w:any(map(w.count,'do re mi fa sol la si'.split()))

Try it online!
We can almost save a byte by writing 1in map(...), but this doesn't catch the string appearing two or more times.

+1 good job on exploring multiple options!

@RGS Thanks, I forgot to change that.

In case someone tries it, using do|re|[ms]i|[fl]a|sol saves a total of 0 bytes, and just looks worse.

CP-1610 assembly (Intellivision), 41 DECLEs1 ≈ 52 bytes
A routine taking a pointer to a NUL-terminated string into R4 and setting the carry if the test is successful, or clearing it otherwise.
275         |         PSHR    R5
2A0         | @@read  MVI@    R4,     R0
338 061     |         SUBI    #'a',   R0
20B 01B     |         BMI     @@rtn
04C         |         SLL     R0,     2
04C         |         SLL     R0,     2
048         |         SLL     R0
3E0         |         XOR@    R4,     R0
2A1         |         MVI@    R4,     R1
33C 002     |         SUBI    #2,     R4
001         |         SDBD
2BD 0C6 048 |         MVII    #@@tbl, R5
368         | @@loop  CMP@    R5,     R0
204 00D     |         BEQ     @@rtn
001         | @@next  SDBD
37D 0CC 048 |         CMPI    #@@so,  R5
22C 008     |         BNEQ    @@loop
368         |         CMP@    R5,     R0
22C 01B     |         BNEQ    @@read
379 06C     |         CMPI    #'l',   R1
22C 01F     |         BNEQ    @@read
2B7         | @@rtn   PULR    R7
00F         | @@tbl   DECLE   $00F
245         |         DECLE   $245
1E9         |         DECLE   $1E9
0C1         |         DECLE   $0C1
101         |         DECLE   $101
229         |         DECLE   $229
22F         | @@so    DECLE   $22F

How?
Each note made of the ASCII codes \$(c_0,c_1)\$ is encoded as a single DECLE with the following formula:
$$((c_0-97)\times 32) \operatorname{xor} c_1$$
The edge case "sol" is encoded as "so" and put at the end of the lookup table. There's an additional test for the "l".
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

        SDBD                      ; R5 = pointer into the test case index
        MVII    #tc.tbl,R5
        MVII    #$200,  R3        ; R3 = backtab pointer
        MVII    #14,    R1        ; R1 = number of test cases

@@loop  MVI@    R5,     R4        ; R4 = pointer to next string
        SDBD
        ADDI    #tc.00, R4

        PSHR    R5                ; save the test variables
        PSHR    R3
        PSHR    R1
        CALL    mmb               ; invoke our routine
        PULR    R1                ; restore the test variables
        PULR    R3
        PULR    R5

        MVII    #$88,   R0        ; R0 = '1'
        BC      @@draw

        MVII    #$80,   R0        ; or '0' if the carry is not set

@@draw  MVO@    R0,     R3        ; draw this character
        INCR    R3                ; increment the backtab pointer

        DECR    R1                ; next test case
        BNEQ    @@loop

        DECR    R7                ; done: loop forever

        ENDP

        ;; ------------------------------------------------------------- ;;
        ;;  test cases                                                   ;;
        ;; ------------------------------------------------------------- ;;
tc      PROC

@@tbl   DECLE   @@00 - @@00, @@01 - @@00, @@02 - @@00, @@03 - @@00
        DECLE   @@04 - @@00, @@05 - @@00, @@06 - @@00, @@07 - @@00
        DECLE   @@08 - @@00, @@09 - @@00, @@10 - @@00, @@11 - @@00
        DECLE   @@12 - @@00, @@13 - @@00

        ;; truthy
@@00    STRING  "far", 0
@@01    STRING  "solace", 0
@@02    STRING  "fire", 0
@@03    STRING  "summit", 0
@@04    STRING  "doctor", 0
@@05    STRING  "blast", 0
@@06    STRING  "subsidiary", 0
@@07    STRING  "obsolete", 0

        ;; falsy
@@08    STRING  "boat", 0
@@09    STRING  "shrimp", 0
@@10    STRING  "biscuit", 0
@@11    STRING  "bullet", 0
@@12    STRING  "college", 0
@@13    STRING  "also", 0

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

        PSHR    R5                ; save the return address on the stack

@@read  MVI@    R4,     R0        ; R0 = current character
        SUBI    #'a',   R0        ; turn it into an index in [0..25]
        BMI     @@rtn             ; if the result is negative, it means
                                  ; we've reached the end of the string:
                                  ; we return with the carry cleared by SUBI

        SLL     R0,     2         ; multiply R0 by 32
        SLL     R0,     2
        SLL     R0

        XOR@    R4,     R0        ; XOR it with the next character
        MVI@    R4,     R1        ; and load a 3rd character in R1
        SUBI    #2,     R4        ; rewind the pointer by 2 characters

        SDBD                      ; R5 = pointer into the lookup table
        MVII    #@@tbl, R5

@@loop  CMP@    R5,     R0        ; compare the lookup table entry with R0
        BEQ     @@rtn             ; match? (if yes, the carry is set)

@@next  SDBD                      ; if we haven't reached the end of the table,
        CMPI    #@@so,  R5
        BNEQ    @@loop            ; try again with the next entry

        CMP@    R5,     R0        ; last test with 'so'
        BNEQ    @@read            ; abort if it doesn't match

        CMPI    #'l',   R1        ; otherwise, make sure it's followed by a 'l'
        BNEQ    @@read            ; abort if it doesn't match
                                  ; otherwise, the carry is set

@@rtn   PULR    R7                ; return

        ;; lookup table: 'do', 're', 'mi', 'fa', 'la', 'si', 'so'
@@tbl   DECLE   ('d' - 'a') * 32 XOR 'o'
        DECLE   ('r' - 'a') * 32 XOR 'e'
        DECLE   ('m' - 'a') * 32 XOR 'i'
        DECLE   ('f' - 'a') * 32 XOR 'a'
        DECLE   ('l' - 'a') * 32 XOR 'a'
        DECLE   ('s' - 'a') * 32 XOR 'i'
@@so    DECLE   ('s' - 'a') * 32 XOR 'o'

        ENDP

Output

screenshot from jzIntv

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

Nice. Haven't seen this language yet.

What is this?! +1 for the effort

@S.S.Anne In your defence, the Intellivision is a bit outdated. It's a 40-year old console. :-p (And the CP-1600 CPU family was not used in many other systems.)

This is either 51.25 bytes or 61.5 bytes, depending on how the opcodes are stored.

Perl 6, 26 bytes
{?/do|re|mi|fa|sol|la|si/}

Try it online!
Boring regex solution that checks for any of the strings.

I am aware that regex is a straightforward, and rather boring (as you put it) solution. I am hoping someone does something neat without regex! I edited the challenge to explicitly allow for lists of ascii values as input. Maybe someone can work with that.

C (gcc), 58 characters, 70 bytes
c;f(int*s){for(c=7;c&&!strstr(s,L"潤敲業慦慬楳\x6c6f73"+--c););}

Creative method required to save bytes/characters.
-17 thanks to Arnauld!
-8 bytes thanks to gastropner!
-2 bytes and -12 characters thanks to ceilingcat!
Try it online!

+1 for a C answer. I think it would be neater to return 1 for a Truthy and it doesn't change the byte count. If the method doesn't return explicitly, doesn't it count as returning null? Isn't that an acceptable Falsy?

@RGS The return; returns true for a Truthy because of the way the return register works. It saves two bytes from return 1;. The return 0; is the Falsy value. That's outside of the loop, when all of the possible strings have been checked.

@Arnauld I can best that and fix an idiotic bug that I made. -- or get the same thing, with your latest comment.

@Arnauld I didn't look but I think I got the same thing as you. Let me take a look.

79 bytes

Riffing on @Arnauld's comment: 72 bytes.

@ceilingcat Where do you generate those weird UTF-8 strings?

Google for something like "unicode 6f64" for "do\0\0"

Java 8, 43 bytes
s->s.matches(".*(do|re|mi|fa|sol|la|si).*")

Try it online.
Explanation:
s->           // Method with String parameter and boolean return-type
  s.matches(  //  Check if the String matches this regex fully:
    ".*       //   Any amount of optional leading characters
       (do|re|mi|fa|sol|la|si)
              //   Followed by one of our music sounds
     .*")    "//   Followed by any amount of optional trailing characters

Why do you check for the "full match"? I'm assuming checking for a substring with the regex would be longer..? +1 for a Java submission.

@RGS Yeah, Java's regex-contains method is extremely verbose. It would be this instead: s->java.util.regex.Pattern.compile("do|re|mi|fa|sol|la|si").matcher(s).find() (77 bytes)

AWK, 47 \$\cdots\$ 31 30 bytes
{print/do|re|mi|fa|sol|la|si/}

Try it online!
awk automatically compares any regex with $0 (current line).

Good job! +1 Haven't seen much awk recently!

Retina, 21 bytes
do|re|mi|fa|sol|la|si

Try it online!
Very obvious and boring solution. 0 for false, nonzero for true.

+1 for doing it anyway. if sol were so would you manage to do something shorter?

@RGS They probably would be able to by one byte.

Python 3, 60 bytes
lambda w:any(i in w for i in'do re mi fa sol la si'.split())

Try it online!

Simple solution :) +1

Red, 63 bytes
func[s][parse s[to["do"|"re"|"mi"|"fa"|"sol"|"la"|"si"]to end]]

Try it online!

Thanks for your submission! Red is a nice colour +1

@RGS Yes, it is! BTW, I think Red comes from reduce (the sofware complexity)

interesting! Thanks for sharing :D

Scratch 3.0, 13 blocks/135 + 21 = 156 bytes
+21 for having a predefined list n. Y'all do that by creating a new list within Scratch and entering each item manually. It took 21 keystrokes to manually create the list.

As SB Syntax:
when gf clicked
ask()and wait
set[o v]to(0
set[i v]to(1
repeat(7
change[o v]by<(answer)contains(item(i)of[n v
change[i v]by(1
end
say(o

This was a rather simple approach, as thankfully, there were appropriate built-ins. Zero is falsey and anything else is truthy.
I still don't have access to my old account, but y'all can still Try it online Scratch!

Where do you define n?

It's a predefined list.

You need to include the definition in your code. I doubt it only costs 15 bytes to declare an array

Your scratch submissions inspire me +1

R, 44 40 bytes
Another simple regex implementation. Fixed stupid mistake, thanks @Giuseppe.
grepl("do|re|mi|fa|sol|la|si",scan(,''))

Try it online!
One could also save a character by using grep instead of grepl, where integer(0) is falsey and everything else truthy... but that's not a big change and can't process a whole list at once.

Thanks for your R submission! Isn't there a shorter way to write an arrow function or something like that, so save the characters from scan(,'') ?

@RGS you could do it with magrittr or similar to create a functional sequence but that wouldn't be base R.

Pyth, 20 bytes
At least it's as long as the regex...
See TIO for the two unprintables in the packed string.
:z."a|ê)H·>ÔMv´#°"

Try it online!

Thanks for your submission! +1 for a Pyth answer.

Pyth, 17 bytes
}#zc7."asÐ@»„¸Ï

Try it online!
Makes use of Pyth's string compression feature, .", to compress the string soldosimilarefa, then chops that string into 7 pieces, extra length in the first one, then filters which of those strings are contained in the input. If there is at least one, the result is truthy.

Cool submission, +1 for you. Somewhat similar to some of the other solutions in golfing languages, right?

@RGS Yes, the "chop into 7 pieces and check" part is the same. All the rest is really just the language's built-in compression techniques. Pyth's are OK, but not the best. Thanks!

J, 42 bytes
[:>./^:_(;:'do re mi fa sol la si')&=@<\\.

There's probably a way to golf the string, but I had a hard enough time coming up with this as is. Fun challenge!
Explanation:
[:              NB. Capped fork
  >./^:_        NB. Get the largest value in the resulting array, i.e. 1 or 0
        (;:'do re mi fa sol la si') NB. Array of boxed words
        &       NB. Bind words to
         =@<    NB. Box and compare
            \   NB. With the prefixes
             \. NB. Of the suffixes

Try it online!

+1 for your nice J submission! Glad you liked it :)

35 bytes.

Japt, 20 19 bytes
`ÎolÌ·nè^`qÍøUã

Try it

+1 for not writing explicitly the musical notes. How did you encode them? String compression?

@RGS, the backticks contain a compressed string, you can see what it decompresses to in the "transpiled" field. From there, I'm just splitting it to an array on ns and checking whether any of its elements appear in the input.

Scratch that, now it checks if any of the substrings of the input are contained in the array.

Alright, thanks for the explanation!

Zsh, 36 35 bytes
[[ $1 =~ 'do|re|mi|fa|sol|la|si' ]]

Try it online!
Try it online!
The =~ operator enables regex matching with the zsh/regex module, which is one byte shorter than glob matching using = (see previous answer).

If truthy-falsy convetions can be swapped, then 35 bytes:
[ ${1:#*(do|re|mi|fa|sol|la|si)*} ]

Try it online!
In any case, writing all syllables out is just as short as any combination, such as (do|re|[ms]i|[fl]a|sol).

+1 thanks for your submission

I think any truthy-falsy value works.

Interesting choice. In Bash and Ksh the 1st  solution could be 2 characters shorter due to unnecessary single quotes: Try it online!.

GolfScript, 34 bytes
:a;7,{a"sdrmflsooeiaail"@>7%/,2=},

Try it online!
Explanation
:a;                                # Assign the input to the "accumulator"
   7,                              # Yields [0 1 2 3 4 5 6]
     {                          }, # Keep all that full fill this condition
                                   # Item = current item
                                   # ac = accumulator
      a"sdrmflsooeiaail"           # Stack: <item> <ac> "sdrmflsooeiaail"
                        @          # Stack: <ac> "sdrmflsooeiaail" <item>
                         >         # The slice begins at the current item
                          7%       # With a step of 7
                            /      # Try to split the input by the sliced item
                             ,2=   # Is the slice was successful?

+1 for a solution in a different answer. Thanks for your submission!

I like to acknowledge people's work :) in my opinion, from the OPs standpoint, any answer that solves the challenge and is an honest attempt at golfing deserves an upvote from the OP. Further upvotes are given by the community to the answers they like the most and are better golfed, etc :) I hope this makes sense.

Keg, -rR 53 bytes
@h2|/÷!1≠:[⑹]øƒ0&᠀®s`do,re,mi,fa,sol,la,si`\,/÷(©s@hƒ

Try it online!
A rather regex-less approach for a rather regex-less language. :P
Zero is falsey, any other value is truthy.
Explained
This program has two parts: the helper function (h) and the main part. Here is the extracted function:
@h2|/÷!1≠:[⑹]øƒ

This function h takes 2 parameters from the stack, both of which are going to be strings.
@h2|            # Function definition
    /÷          # Split the first string (input) on the second string (note) and push individual items
      !1≠       # Push the length of the item splitted stack and see if it doesn't equal 1
         [⑹]    # If the above comparison results in true, increment the register
            øƒ  # Clear the stack of all remaining items and end the function

Now that the function is out of the way, we can get on to the real fun stuff: the body of the program.
0&᠀®s`do,re,mi,fa,sol,la,si`\,/÷(©s@hƒ
0&                                      # Store 0 in the register
  ᠀®s                                   # Take the input as a string and store it in var "s"
     `do,re,mi,fa,sol,la,si`\,/÷        # Push the string "do,re,mi,fa,sol,la,si", split on ","s and item split
                                (©s@hƒ  # Apply function "h" to each and every item in that list.
# -rR automatically prints the value stored in the register at End Of Execution

Good work on that regex-less approach for a regex-less language +1 :D

Python 3, 59 bytes
lambda w:any('sdrmflsooeiaail'[i::7]in w for i in range(7))

Try it online!

C# (Visual C# Interactive Compiler) with /u:System.Text.RegularExpressions.Regex-flag, 37 bytes
s=>IsMatch(s,"do|re|mi|fa|sol|la|si")

Try it online.
Explanation:
s=>                           // Method with string parameter and bool return-type
  IsMatch(s,                  //  Check if the string contains the following regex-match:
    "do|re|mi|fa|sol|la|si")  //   One of the music sounds

That is one looooooong flag, maybe longer than the answer :p if you liked the challenge, consider upvoting it ;)

@RGS Yeah. Luckily you don't have a leader-board, otherwise the flag in my answer would make it unreadable, haha. Happened once before. ;p

and you didn't learn the lesson! Also, is the leaderboard good practice? Or is it just for challenges with a lot of upvotes already?

@RGS I personally never use it, but if you want to add a leader-board to your challenge feel free to copy it from another challenge and edit it in. Here is my previous answer where I used it and someone mentioned I broke the leader-board.

Too bad you already edited the flag out of the header :P Thanks for the link!

JavaScript (Node.js), 33 bytes
s=>s.match`do|re|mi|fa|sol|la|si`

Try it online!

Thanks for your submission, +1! Why did you go for "javascript (node.js)"? Is the node.js part relevant?

Thanks! It's just the option I chose in this case, it's not specifically needed. Just relies on tagged templates, an ES6 feature.

W d, 24 22 bytes
I finally managed to compress the string!
Take your input in the form "['your string']". Languages without grouping are having a terrible time here.
☺¶4∙)╘┐►↔₧uVÿñ☼╠◙╤Γ()¿

Uncompressed:
1y56WX0y`2,"Wb,R`3,+,ak2=W

Explanation
1y56WX0y`2,                # Split "farmiesila" into chunks of 2
           "Wb,R`3,+       # Add "sol" and "do" wrapped into a list into the list
                    ,      # Try to split the input by all these strings
                     ak2=W # Choose all lengths that are equal to 2 (i.e. split successful)

+1 for you submission in W being a new language in the challenge! Good job. Can you add a TIO link?

Unfortunately I requested it just after Dennis began to feel sick. So, no TIO yet!

oh ok :/ I will have to trust you, then!

However, you can still run the interpreter online. Repl it! But repl.it doesn't have a permalink feature...

J, 33 bytes
[:OR@,do`re`mi`fa`sol`la`si E.&><

Try it online!
How it works
[:OR@,do`re`mi`fa`sol`la`si E.&><
      do`re`mi`fa`sol`la`si        NB. 7 enclosed strings to search for
                                <  NB. Enclose the input
                            E.&>   NB. Find matches for each of the 7 strings
[:OR@,                             NB. Flatten and take OR

Excel, 155 bytes
=ISNUMBER(FIND(0,SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"si",0),"la",0),"sol",0),"fa",0),"mi",0),"re",0),"do",0)))

A sequence of SUBSTITUTE, and then a check to see if any of them found a match.
FIND returns error #VALUE! if no match is found, so would have to wrap each usage in error handling.

Thanks for the screenshot! Interesting work done with EXCEL here :)


text:
How far should I sum?
The harmonic series is the "infinite sum" of all the fractions of the form \$\frac1n\$ for \$n\$ positive integer. I.e. the harmonic series is
$$\frac11 + \frac12 + \frac13 + \frac14 + \cdots$$
It is well-known that this sum diverges, which means that if you define
$$ H_n = \frac11 + \frac12 + \cdots + \frac1n$$
Then the value of \$H_n\$ goes to infinity. This can also be stated in a different way: for any positive value \$x\$ you pick, there is some value \$N\$ such that, to the right of \$N\$, the \$H\$ values are bigger than \$x\$:
$$\forall\ x\ \exists\ N: n > N \implies H_n > x $$
Your task
Write a program/function that takes as input a positive number x (not necessarily an integer) and outputs the first integer n for which
$$H_n \geq x$$
In theory your program must work for arbitrary x, even if in practice you are limited by the memory and/or precision of your programming language/computer.
Test cases
1.5 -> 2
2 -> 4
3 -> 11
3.1415 -> 13
4 -> 31
5 -> 83
7.5 -> 1015
10 -> 12367

This is code-golf so shortest solution wins! Standard loopholes are forbidden by default. Happy golfing.

Related OEIS sequence.

@Arnauld included for completeness? Or do you think it might help someone in any way?

Your recent challenges have been great! Keep up the good work!

@S.S.Anne thanks :D I'll try to come up with more decent challenges.

You ask: "how far should I go". I suggest anywhere between 6 to 8 metres. :P

@Lyxal not far enough!

Congratulations, you won the Rookie of the Year - Challenges category in the Best of CGCC 2020. As bounties can be only awarded to answers, can you pick an answer of yours where the bounty will be awarded to? Please post it in the Best Of chatroom.

APL (Dyalog), 13 bytes
-1 bytes thanks to ngn
{⊃⍸⍵≤+\÷⍳⌈*⍵}

Try it online!
A dfn solution that takes a right argument.
Explanation:
{           }   ⍝ dfn
 ⊃              ⍝ Take the first of
  ⍸             ⍝ The indexes of the truthy values of
   ⍵≤           ⍝ The right argument is smaller than or equal to
     \+         ⍝ The cumulative sum
       ÷        ⍝ The reciprocal of each of
        ⍳       ⍝ The range 1 to
         ⌈      ⍝ The ceiling of
          *⍵    ⍝ e to the power of the right argument

1⍳⍨ -> ⊃⍸

What does dfn stand for? Also, be sure to upvote the challenge if you liked solving it :)

@RGS dfn stands for Direct Function

Sorry, but the first thing I saw in your answer was this face: {⊃≥⍵≤⊃}

Python 3, 35 bytes
f=lambda x,n=1:x>0and-~f(x-1/n,n+1)

Try it online!

Thanks for the submission. When X <= 0 the LHS evaluates to false. How does the lambda return n at that point? Also be sure to upvote if you liked golfing this challenge.

I don’t understand why the complement operator makes the and return the number instead of False. What happens there?

@ÉmileJetzer The -~ is basically a shorter variation of +1. Since it's a recursive function that eventually results in False, the -~/+1 will interpret this as 0 in Python and adds the 1 (False+1 = 1 in Python). Here a step-by-step explanation of what happens for f(2).

@KevinCruijssen that makes a whole lot'a sense! Thanks for explaining it and going through the effort of explaining it step by step.

@KevinCruijssen Thanks for detailed breakdown! The idea of incrementing the recursive output starting from a base case of 0, as a replacement for outputting the final value n, is a pattern that I find to come up a lot. For example, when finding the n'th number meeting a condition p, as in my tip here, we can use f=lambda n,i=1:n and-~f(n-p(i),i+1), which looks very similar to this answer.

@ÉmileJetzer As Kevin described, I'm using -~ as an idiom for +1 that's shorter in this context, applying numerically to Booleans.

JavaScript (ES6),  32  29 bytes
Saved 3 bytes thanks to @Shaggy
f=(n,k=0)=>n>0?f(n-1/++k,k):k

Try it online!

Non-recursive version, 35 bytes
n=>eval("for(k=0;(n-=1/++k)>0;);k")

Try it online!

Approximation (25 bytes, not fully working)
This gives the correct result for all but the first test case.
n=>Math.exp(n-.5772)+.5|0

Try it online!

I have to get used to those solutions with evaluating loop code... why isn't the solution the actual loop? +1 for teaching me smth

@RGW Without eval(), it would be n=>{for(k=0;(n-=1/++k)>0;);return k}, which is 1 byte longer.

ah wow, of course. Thanks for elaborating

@RGS As a side note, the version with eval() is much, much slower than without eval() because the code never gets a chance to be processed by the JIT compiler.

29 bytes

n=>Math.exp(n-.5772)+.4|0 will work with all the test cases at least. I wonder how much further it will push out?

Perl 6, 27 bytes
{+([\+](1 X/1..*)...*>=$_)}

Try it online!
Explanation:
{                         } # Anonymous code block taking one argument
 +(                      )  # Return the length of
   [\+](        )             # The cumulative sum
        1 X/                    # Of the reciprocal of all of
            1..*                  # 1 to infinity
                 ...          # Take from this until
                    *>=$_     # It is larger than or equal to the input

I should learn some Perl! +1 Thanks for including an explanation of the code.

@RGS Note that these days Perl 6 is called Raku (TIO still uses Perl 6 hence most submissions use it). It was designed originally as a non-backwards compatible successor to Perl 5, but now both still live on with different names — Perl 5 is just Perl, and Perl 6 is Raku.  I'm biased since I do a lot of (non golfing) work in it, but it's really one of the more beautiful and fun languages to write general code in, which sounds weird given the (unfair) image that Perl 5 had.

@user0721090601 thank you for your testimonial. Tbh, I heard some "mean" things about Perl but I never programmed in it! Neither Perl <= 5, nor Perl 6 :)

@RGS Perl — moreso than other languages as it regularly beats all but the golfing languages on here — can be extremely code-golfy and line-noisy. Sadly too many people used to write their $day-job code like that which gave it the bad rap, particularly when others had to read such golfy/noisy code.

Octave / MATLAB, 31 bytes
Thanks to @Giuseppe (based on @John's answer) for making a correction and saving 1 byte at the same time.
@(n)sum(cumsum(1./(1:3^n))<n)+1

Try it online!
Explanation
The code uses the fact that 1+1/2+···+1/m is lower-bounded by log(m). Therefore, given n the solution to the challenge is less than exp(n), or less than 3^n (to save bytes).
So the code computes the cumulative sum of the vector [1, 1/2, 1/3, ..., 1/(3^n)], and the solution is 1 plus the number of entries that are less than n.

+1 Clever solution, to use the lower bound so that you don't have to recurse or anything like that

@Giuseppe Thank you! Edited

R, 39 33 bytes
x=scan();sum(cumsum(1/1:x^x)<x)+1

Try it online!
For a more limited x:
29 bytes
sum(cumsum(1/1:9^8)<scan())+1

Try it online!

36 bytes -- you need the +T at the end to prevent small x from returning TRUE.

@Giuseppe I changed the core functionality in this edit. Any feedback?

I'd probably just use scan() in place of x but your edit now fails the requirement to work in theory for arbitrary x.

@Giuseppe good point. I made it arbitrary, but it won't work for all test cases due to memory limits

good R submission, +1. Unfortunately, the shorter solution doesn't meet the requirements, as Giuseppe pointed out :/

Wolfram Language (Mathematica), 29 bytes
(i=0;#//.x_/;x>0:>x-1/++i;i)&

Try it online!

Really simple solution in mathematics :D +1

While it's not as short (40 bytes), it's amusing to note that Mathematica basically has a builtin for this problem: Ceiling@*InverseFunction[HarmonicNumber]

@GregMartin I think everybody knows that by now ;-)    Unfortunately, once again the name is pretty big...

30 bytes

@Roman that was long ago hahah. I posted a different approach which is even shorter!

05AB1E, 8 bytes
∞.ΔLzOI@

Try it online!
∞.Δ        # first integer y such that:
   L       #  range [1..y]
    z      #  invert each [1, 1/2, .., 1/y]
     O     #  sum
      I@   #  >= input

Thanks for your submission +1 Do you think you could include an explanation of the code?

@RGS there you go, done

another 8 bytes: ∞z.¥ÅΔI@, or ∞z.¥I@ÅΔ

this is 7 bytes: ∞z.¥‹ÅΔ or ∞z.¥ÅΔ‹ but sadly it doesn't work when the sum is exact

C (gcc), 45 bytes
Some inspiration taken from @Noodle9; go upvote their answer!
i;g(x,s)float x,s;{for(s=i=0;s<x;s+=1./++i);}

i;g(x,s)float x,s;: Old-style function definition. Abuses the fact that old-style function definition don't require all the arguments to be passed (so old-style variadic functions would work) to declare an extra local variable. Having the i as a global variable causes the exploit below to work.
for(s=i=0;s<x;s+=1./++i);: same old stuff as before, harmonic function, yada yada. Note that s=i=0 is allowed; the i=0 is an integer that is converted to a float and assigned to s.
The i variable is stored in the %eax (return) register, so nothing is required to initialize it. (thanks @Cody Gray!)

Try it online!
C (gcc), 72 bytes
Recursive solution.
i;float h(n){return n?h(n-1)+1./n:0;}g(float x){for(i=0;h(i++)<x;);--i;}

Explanation:

i;: counter for finding the first integer n where h(n) >= x.
float h(n): recursive function taking an int parameter and returning the term of the Harmonic series for n.
return n?h(n-1)+1./n:0; - recursive function calculating the Harmonic series and stopping at 0.
g(float x): function finding the first i where h(i) >= x.
for(i=0;: start loop and initialize i to 0 (functions must be reusable).
h(i++)<x: loop while h(i) < x.
--i; returns i-1 by exploiting GCC's behavior when compiling without optimization; intermediate results are all stored in the eax/rax register.

Try it online!
C (gcc), 83 bytes
Non-recursive solution.
i;float h(n){float r=0;for(;n;)r+=1./n--;r=r++;}g(float x){for(i=0;h(i++)<x;);--i;}

Explaining the part that's different from the previous solution:

float r=0;: this is our result. Initialize it to 0.
for(;n;): Loop until n is 0.
r+=1./n--;: Add the next iteration of the Harmonic series. Also decrement n so we don't have to do that in the last part of the for loop.
r=r++; is like return n; but shorter. It's similar to the fake return in the previous solution but does it with the floating-point return register instead of the integer return register. We have to have the ++ just so GCC doesn't optimize it out as redundant (and yes, some optimizations are enabled without a flag).

Try it online!

Thanks for your submission. +1 I see you are fond of exploiting that GCC bug you mention. Be sure to upvote my challenge if you liked solving it :)

@RGS Definitely, there you go. return is a big space-killer so removing it is high on my list. I'm only sad I couldn't do it with h.

For the first solution, you don't need x=i; at all on GCC with -O0. It works because the loop counter (i) is already getting put in the eax register by the code-gen, which is where x86 expects the return value to be. Look at the disassembly. That saves you 4 more bytes. And seriously risks nasal demons. In fact, my nose is starting to itch...

@Cody This is code golf. Get over it.

37

C (gcc), 52 51 49 bytes
Saved a bytes thanks to @ceilingcat!!!
Saved 2 bytes thanks to @S.S.Anne!!!
i;f(n,s)float n,s;{for(s=i=0;s<n;s+=1./++i);n=i;}

Try it online!

Python 3, 49 40 bytes
Saved 9 bytes thanks to @JoKing!!!
lambda n,s=0,i=1:s<n and-~f(n,s+1/i,i+1)

Try it online!

Cool submission +1 it is just a shame that the recursion depth doesn't allow us to check for larger test cases. Also be sure to upvote the challenge if you liked golfing it :)

Ruby, 31 30 bytes
->x{b=0;x-=1r/b+=1while x>0;b}

Try it online!

Clean solution, +1. Can you save 1 byte if you write b=.0?

Not really, but I can achieve something similar with rational numbers (1r).

K (Kona), 21 20 bytes
{1+*&~x>+\1.%1+!3^x}

Try it online!
Inspired by Jo King's APL solution
Switched from oK to Kona, as it has power

+1 for the answer in a language I have never seen!

Haskell, 34 bytes
(#1)
x#n|x>0=(x-1/n)#(n+1)|1>0=n-1

Try it online!

+1 really cool solution with the infix operator. The cpp flag is just for the purposes of writing f=\ in the header?

Java 8, 71 43 bytes
x->{int n=0;for(;(x-=1d/++n)>0;);return n;}

-28 bytes by porting @Arnauld's non-recursive JavaScript answer.
Try it online.
Explanation:
x->{                // Method with double as both parameter and integer as return-type
  int n=0;          //  Result-integer `n`, starting at 0
  for(;(x-=1d/++n)  //  Decrease `x` by 1/(n+1), by first increasing `n` by 1 with `++n`
       >0;);        //  And continue doing this until `x` is 0
  return n;}        //  Then return `n` as result

Seeing such short solutions in "normal" programming languages fills me with joy

Pyth, 11 10 9 bytes
fgZ=-Qc1T

Try it online!
Explaination:
            # Implicit Q=eval(input())
f           # The first element T of [1,2,3,...] where
 gZ         # 0 >=
   =-Qc1T   # Q = Q - (1/T)
            # Implicit print

-1 -2 bytes thanks to @issacg

cool submission! can you explain it, please? +1 :)

@RGS I'm not great at writing explainations but here goes nothing.

If you remove the first Q, it'll be filled in implicitly. Also, g is the greater than or equal to function.

@isaacg g gets me wrong output for 1.5 for some reason, but the Q being implicitly filled is interesting, thanks!

@famous1622 g works fine for me, once I move the Z to the front: Try it online!

@isaacg forgot to flip it, I'mma go get more coffee :P

GolfScript, 21 20 [bytes]
New Solution TIO
Old Solution TIO
The new solution takes our input and recursively subtracts the inverses from it until we get the solution. Very messy stack management, could probably be done cleaner.
New Solution (20)
0{).-1?@\-.@\0>}do\;

New Solution Explanation
0{).-1?@\-.@\0>}do\; #Take in a number c as input, and output the lowest n s.t. Hn<x
0                    # The stack is now [c n=0]. We're just using n here for clarity.
 {             }do   # Until we pop a TRUE, loop the following
 {)            }do   # Increment n by 1
 {  .           }do   # Then duplicate it
 {  -1?        }do   # Raise the dupe to the power of 1 (inverse)
 {     @\      }do   # Move our c to the second element of the stack, between n and 1/n
 {       -     }do   # Subtract. Stack is now [n c-(1/n)]
 {        .    }do   # Duplicate c-(1/n)
 {         @\  }do   # Move n back to the second element of the stack
 {           0>}do   # Check if our c-(1/n) is less than zero. If so, leave the loop.
 {             }do   # If not, repeat, but with c-(1/n) as our new c.
                  \; # Remove c once it's below 0, leaving our tally. This gets outputted.

Old Solution (21)
:c;0.{\).-1?@+.c<}do;

Old Solution Explanation
:c;0.{\).-1?@+.c<}do; # Take in a number c and find the lowest n s.t. Hn>c
:c;                   # Set c to our goal number, then pop it from our stack.
   0.                 # Make our stack [0 0]. Let will be our n, right will be our running sum.
     {           }do  # At the end of each loop, if the top of the stack isn't 0, repeat.
     {\)         }do  # Move the n to the top of the stack and increment it by 1.
     {  .-1?     }do  # Duplicate it, then inverse it.
     {      @    }do  # Bring our running total to the top (now third in the stack behind 1/n and n)
     {       +   }do  # Add the top two elements (running total + 1/n)
     {        .  }do  # Duplicate the running total
     {         c<}do  # If it's less than c, print 1 (repeat do), else 0 (stop do)
                    ; # Pop our running total, leaving behind just our n.

Shouldn't be too hard to shave a char off somewhere.
Got one.

+1 for this GS submission! if you liked the challenge, consider upvoting it :)

Jelly, 9 bytes
1İ€S<¬ʋ1#

A monadic Link accepting a number which yields a list containing one integer; as a full program it prints that integer.
Try it online!
How?
1İ€S<¬ʋ1# - Link: number, x
1         - set left to one
       1# - count up (from n=left) finding the first (1) n such that:
      ʋ   -   last four links as a dyad - f(n, x)
 İ€       -     inverse each (of [1..n])
   S      -     sum
    <     -     less than (x)?
     ¬    -     logical NOT

‘!İ€Ä<⁸S‘

Is another 9 but it's much less efficient as \$x\$ gets bigger since it builds a list of the first \$(x+1)!\$ harmonic numbers.

+1 for some jelly. For some reason the code feels long D: is it just me being a jerk?

Your "Try it online!" isn't actually a link (seems to have been removed in an earlier golf). Here's one for you if you want it :)

Cheers @cairdcoinheringaahing looks like I'd just got an extra h like hhttp:....

Japt, 12 11 10 bytes
>0©ÒßUÉ/°T

Try it

Thanks for the solution! Is there any way you could include an explanation? Also, are you using such a specific version for some reason?

Red, 53 bytes
f: func[n][i: 0 until[0 >= n: n -(1.0 /(i: i + 1))]i]

Try it online!
Simple iterative solution.
Red, 78 bytes
f: func[n /a i][either a[either n > 0[f/a n -(1.0 / i)i + 1][i - 1]][f/a n 1]]

Try it online!
I know this is way longer than other recursive solutions, but I wanted to post it because of the fact that Red functions have fixed arity. In order to simulate default values for the additional parameters, we need to use a refinement - here it's /a- whenever we need the value of the i parameter.

It makes me sad that you have to use all those spaces around the operators :(

@RGS Yes, it's true. This is a deliberate design decision taken by the creator of Rebol (the precursor of Red)

J, 29 28 bytes
-1 byte thanks to RGS
Shameless translation of Jo King's APL answer.
3 :'>:1 i.~y&<:+/\%}.i.<.^y'

Probably a lot of room for improvement, but I couldn't find a shorter tacit way.
Try it online!

hey, you can save 1 byte. +1 for your J submission. Upvote the challenge if you liked it :)

bc, 52 bytes
define f(x){
scale=999
for(s=i=0;s<x;s=s+1/i)i=i+1
}

Try it online!
If you need more precision, change the 999 to 9E3 or 9E9.  Expect memory usage to skyrocket and performance to plummet.
I'm testing a variant that prints as it passes integers.  It matches OEIS A004080 so far
(23 -> 5471312310).
With scale=9, it is correct to 11 -> 33617 but is off by 4 for 12.
With scale=99, it is so far accurate to 25 -> 40427833596.
Since scale=99 can't be extended without adding another byte, I'm not going to claim it.

bc and dc solutions don't require functions AFAIK. You can put it in the header and footer. You could at least change the variable names.

@S.S.Anne   How about Posting a code snippet instead of a complete answer and it's referenced question.

Interesting solution in a language that hasn't been used in this thread :) +1

W d, 11 9 bytes
╪ª4PÄ½┌∙×

Uncompressed:
i1ak/+rb<!W

Explanation
i         W % Find the first number from 1 to positive infinity
            % That satisfies this condition
  ak        % Generate a range from 1 to the number
 1  /       % Find the reciprocal of every item (automatically vectorises)
     +r     % Reduce by addition
       b<!  % Is this number greater than or equal to the input?

What happened when you tried to compress the program?

I feel that the short code length is worth all the downvotes... (If you can't see the answer, someone downvoted my answer.)

I would say bug fixes to the language don't make the answers in said languages non competing. +1 for your W submission!

Answers in newer languages are never non-competing nowdays.

Burlesque, 27 bytes
rds1@1moiT{1j?/g1++cm0>=}fi

Try it online!
For some reason save/load seems to be working a bit funny with this one on TIO. To test the code, use the following:
Burlesque, 28 bytes
rd@1moiT{1j?/++cm0>=}x/4iafi

Try it online!
rd    # Read input as double
[s1]  # Save slot 1
@1    # 1.0
mo    # Infinite multiples of {1.0, 2.0, 3.0...}
iT    # All tails of {{}, {1.0}, {1.0,2.0}, {1.0,2.0,3.0},...}}
{
 1j?/ # Reciprocal
 ++   # Sum
 [g1] # Get slot 1 (not working)
 cm   # UFO operator (-1 on <, 0 on ==, 1 on >)
 -1.> # 0 or 1
}
x/   # Reorder stack
3ia  # Insert input at position 3 of array (before compare)
fi   # Find first index

+1 thanks for your suggestion. I made an edit suggestion to your answer and it gave me the impression that you may have used a templating tool to create the skeleton for your answer. Does what I am saying make any sense?

Sure, not sure it makes much difference though. No templating tool. Just me being lazy in typing.

W d, 8 bytes
Let's see if I can come tied with 05AB1E ...
♠wⁿ=^φ→§

Uncompressed:
kJrJb<!iX

Explanation
       iX % Foreach in [1 .. +inf],
          % find first number that satisfies:
k         % Range of 1 .. number
 Jr       % Reciprocal each
   J      % Summation of entire list
    b<!   % Is that >= the input?

Isn't this very similar to your first W submission?

Charcoal, 19 bytes
⊞υ¹Ｗ‹ΣυＩθ⊞υ∕¹⊕ＬυＩＬυ

Try it online! Link is to verbose version of code. Explanation:
⊞υ¹

Start off with n=1, pushing 1/1 to the predefined list.
Ｗ‹ΣυＩθ

Repeat while the list sums to less than the target...
⊞υ∕¹⊕Ｌυ

... push the next Egyptian fraction to the list.
ＩＬυ

Output the length of the list, i.e. n.
It might be possible to reduce the floating-point inaccuracy slightly by adding a Reverse after the Sum.

Thanks for the submission. I don't want to be rude, but at the end of the day, me not knowing charcoal means I can't say your verbose version of the code matches what you wrote here. Why do you always link the verbose version? :)

Ah, is it what the flags in the TIO link are for? They print the golfed code?

@RGS Yes, the -v flag translates the verbose code to succinct code and the -l flag prints that code and its byte length, before the succinct code then gets run as if it was the original code. (So occasionally I trip over bugs in the succinct code translator...)

you trip on your own bugs? Did you create charcoal? Or you do just in charcoal's bugs?

@RGS My only contribution to Charcoal was to fix a bug caused by a Python 3 update.

still very nice. you did more for charcoal than I did :D

Keg, -hr, 12 bytes
0&0{¿⑻>|:⑨⑱⑼

Uses the most recent Keg interpreter, so no TIO thus far.
Explained
0&

We store 0 in the register as this will be the means of storing the total sum of the series.
0

We then push 0 onto the stack, as this will be what keeps track of the term number (n)
{¿⑻>|

The condition of the while loop is that it will repeat while the input (which is automatically filled if no input is given -- the reason why this doesn't have a TIO link) is greater than the value in the register.
⑨

We then increment the top of the stack to get to the next term. This is done before the reciprocal is taken so that we avoid an "off-by-one" error.
:⑱⑼

We then take the reciprocal of the top of the stack and add it to the register (⑱ = 1/x and ⑼ = register += t.o.s). -hr will automatically print the top of the stack at end of execution as an integer.
Here is a Try it online version that uses a variable to keep track of the input. This is mainly just so that y'all can see that the algorithm works, as the variables can be replaced with the above 12 byter.

Thanks for you keg submission (+1). Were you the one creating keg? Also be sure to upvote the challenge if you liked it. It keeps me going.

@RGS yep, guilty as charged :P. Hard to upvote something I've already up voted!

+2 for you then :D did you create keg so that you can golf here?

@RGS indeed I did. Y'all can see right through me! :P ;)

Scratch 3.0, 15 blocks / 127 bytes

when gf clicked
ask()and wait
set[n v]to(0
set[t v]to(0
repeat until<(t)>(answer
change[n v]by(1
change[t v]by((1)/(n
end
say(n

Just a port of my Keg answer, so Try it online Scratch!

I find your scratch submissions amusing +1 I think you want a >= and not a > for the repeat test.

@RGS, >=? We don't do that round these parts! Really though... Scratch doesn't have a >= operator, so I'll have to make it different :P

Julia 1.0, 27 24 bytes
>(x,i=1)=1+(0<x-1/i>i+1)

Try it online!
-3 bytes thanks to H.PWiz
the same approach as xnor

24 bytes with a lesser known Julia trick: >(x,i=1)=1+(0<x-1/i>i+1)

wow, this is awesome

A similar thing can happen when redefining * (e.g * =gcd;6n). Although I've not seen it in golf yet

I'm pretty sure I have other answers where I can apply this, I will have to go through them

Python 3, 39 bytes
lambda n:sum(1/x for x in range(1,n+1))

Try it online!
Pretty simple.

Hey, thanks for chipping in! However, I am afraid you misunderstood the challenge: your function takes a value n and returns Hn, while it should take a value x and return the first n for which Hn > x. Consider rereading the challenge and the test cases :)

Perl 5 -p, 22 bytes
$i+=1/++$\while$_>$i}{

Try it online!

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Computational Parity Party!
The computational parity of an integer is defined as 1 if the integer has an odd number of set bits, and 0 otherwise. (src).
Input

You will receive one nonnegative integer that you will take the parity of. Optionally, you may take the size of the integer in bytes or bits as an argument, but you must specify this in your answer.

Output

You will output the computational parity of the input integer.

Rules

Standard loopholes apply, including but not limited to Abusing native number types to trivialize a problem.

Test cases
You may omit any input that cannot be represented with your language's built-in integer type.
0: 0
1: 1
3: 0
8: 1
13: 1
17: 0
40: 0
52: 1
100: 1
127: 1
365: 0
787: 1
2898: 0
6345: 0
9038: 1
10921: 1
16067: 1
4105748: 1
40766838: 0
1336441507: 1
4294967295: 0

Generated using this program.
The answer with the least amount of bytes in each language wins, which means that I will not be accepting an answer.
Bonus imaginary Internet points for an explanation.
Sandbox link (10k+)

I was pretty sure I already answered this before. I think it's actually a dupe of this challenge. The only difference is that it's expecting the opposite output.

@Arnauld Expecting the opposite output does make a substantial difference in some of the answers, though.

Inverting the output is not really enough to justify a new challenge.

JavaScript (ES6),  18  17 bytes
Similar to my answer to Is this number evil? except that the last iteration returns \$0\$, which saves a byte.
f=n=>n&&!f(n&~-n)

Try it online!

JavaScript (ES6), 30 bytes
Converts to binary, parses as base-3 and returns the parity.
n=>parseInt(n.toString(2),3)&1

Try it online!

I think you moved your code up above the lang mark, so it's not getting syntax highlighting.

@S.S.Anne Seems like there's nothing to highlight in there, but fixed anyway. :-)

Hmm... That base 3 solution is interesting. Any chance that it could be implemented without converting to a string?

Jelly, 3 bytes
BSḂ

Try it online! Or see the test-suite.
How?
BSḂ - Link: non-negative integer
B   - to binary
 S  - sum
  Ḃ - least-significant-bit

Interesting. +1 for the explanation.

B^/ is another 3

On mobile it looks like BS[]. Stupid font encodings...

Python, 27 bytes
f=lambda n:n and 1-f(n&~-n)

Try it online!
This is quite nice because if we just want to identify the parity we can reduce it to 25 bytes returning 0 or -1:
f=lambda n:n and~f(n&~-n)

Python 2, 27 bytes
f=lambda n:n and n&1^f(n/2)

Try it online!

Fortran (GFortran), 28 bytes
read*,i
print*,poppar(i)
end

Try it online!
Fortran has this as an in-built since F2008

05AB1E, 5 4 bytes
bSOÉ

Try it online!
Explanation
bSOÉ

b    # convert (implicit) input to base 2
  O  # the sum of...
 S   # the digits...
   É # is odd?

Oasis, 4 bytes
ES2%

Try it online!
Explanation
ES2%

 S    # the sum of...
E     # the binary digits...
  2%  # mod 2

Ruby, 19 bytes
->n{("%b"%n).sum%2}

Try it online!

C (gcc), 34 21 bytes
Saved 13 bytes thanks to Arnauld!!!
f(n){n=n&&!f(n&n-1);}

Try it online!

21 bytes by counting bits recursively.

@Arnauld Wow! That's down right diabolical - thanks! :-)

Python 3, 28 bytes
lambda n:bin(n).count('1')%2

Try it online!

Japt -h!, 3 bytes
¤ä^

Try it here

JavaScript, 18 bytes
Port of ovs' Python solution - be sure to +1 that if you're +1ing this.
f=n=>n&&n&1^f(n/2)

Try it online!

PHP, 39 bytes
for(;$n=&$argn;$n/=2)$p+=$n|0;echo$p%2;

Try it online!

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


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

Related: count the number of triangles

You ask: "is this a triangle?" Probably not, but who knows. Is anything really a triangle?

@Lyxal I say you can be anything. I believe in you. Do you?

△ △ ▽ ▽ ◁ ▷ ◁ ▷ A B ␂

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

@eagle275 while I understand what you mean, I do not wish to allow degenerate triangles into the Truthy test cases! If it doesn't have three distinct sides, it is not a triangle!

@RGS, the problem with 1, 2, 3 isn't that it doesn't have 3 distinct sides (they are mutually distinct both as lengths and as line segments), but rather that 2 of the sides are contained in the other one.

@LSpice thanks for your message :) I thought I was using rigorous language when I called a "degenerate triangle" to a triangle in the conditions you just described. Was I inaccurate? Because what you said was what I meant.

@RGS, yes, degenerate triangle is the usual phrase for that, and I didn't mean to object to it, only to the 'distinct sides' language.

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.

This is also what I had for Python! +1 for us :p

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

screenshot from jzIntv

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

Do you have to run this on your TV? Maybe an emulator is in order...

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

Oh, so that is an emulator. The homepage was unclear.

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.

@bitchaser That's a fair point. Updated!

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

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!

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

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

@KevinCruijssen the lengths you have to go to just to golf in Java!!

@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

@KevinCruijssen oh so you are saying you being around has nothing to do with your apparent obsession with puzzles? :D

@RGS Tbh, twisty puzzles and code-golfing are completely different tbh. I'm pretty good in code-golfing, but not so good in solving puzzles, despite my enormous collection. I have to resort to tutorials pretty often, although I currently have loads of unsolved puzzles for which I'm either the only or one of the only owners, so no tutorial are available. Tbh, I also don't collect twisty puzzles as much as I used to and already sold a few. I'm more focused on some of my other collections lately. Basically too many hobbies, but not enough time and/or money. XD

@KevinCruijssen I understand your pain :'( generally speaking

It looks like it's actually shorter to write out a+b>c&b+c>a&c+a>b: TIO

@xnor Ah, of course.. I actually used that approach initially in my 05AB1E answer, haha.. Thanks for the reminder!

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.

+1, I'll take it then :)

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)

+1 simple enough, right?

Another alternative 5-byter: xsO‹ß

O;‹ß is 4 bytes.

@Grimmy Ah smart, thanks!

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

@S.S.Anne Please remember to follow the Code of Conduct.

@Doorknob What did I do?

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!

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?

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

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.

@user1754322 Just remember to only use it in code golf. This is formally undefined behavior in every C standard.

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

Could you not use the short lambda syntax from PHP 7.4?

@GuillermoPhillips thanks a lot, I actually didn't know them, it doesn't appear on the manual (yet?)

Good job on this PHP answer and +1 for this lambda function!

Wolfram Language (Mathematica), 12 bytes
2Max@#<Tr@#&

Try it online!

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?

@RGS Yup! and here are some "master tips"... https://codegolf.stackexchange.com/q/12900/67961

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!

you are still using maths :D good job on this!

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?

Thanks for the submission +1 what is up with the weird character you are using in the explanations?

@RGS If you mean ⍝, it starts a line comment in APL (just like // in C and # in Python).

@Bubbler But only C99 and after. It's commonly called a "C++-style comment".

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

+1 good job on the port :)

@RGS thanks. Nice series of questions recently!

thanks for your feedback, let's keep them coming!

Alternative 4 bytes: Ḥ<SẠ for "double of all elements less than sum".

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.

These Retina solutions keep amusing me! +1

@RGS It's always nice when you can coax Retina to perform functions which seem unrelated to string manipulation.

Indeed!!! Now I want to see how Retina fares in the count regex matches challenge, which is related to string manipulation!

@RGS I can't see an obvious approach for that one sorry.

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.

Obvious +1 for having the same answer. ;)

@KevinCruijssen Likewise my good man. :-)

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.

@KevinCruijssen Ah, interesting! Ok, I'll stick with what I've got - thanks anyway! :-)

@ceilingcat Nice one - thanks! :-)

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.

f ← |1<+/∘⊏⍖. works, so adding the signature only takes 2 extra bytes. (auto formatter will insert a space after |1 but it is still valid without it)

Also, I think the answer is not valid because the code fragment can only be executed once (not assignable, not possible to push on the stack), which makes it not a function. (related meta post) So you have to include the signature into the answer and count its bytes.

Thanks @Bubbler, I've updated the answer.

J, 8 bytes
+/>2*>./

Try it online!
Uses xnor's formula

+1 simple port, right? :)

@RGS Yes, it's almost identical to Bubbler's APL solution - it's normal, J is APL's relative.

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

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?

@RGS, Yes, absolutely. I can post a solution like that in the comments. Just gimmee a bit....

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

@JoKing, I've really got do some study and wrap my head around how to use TIO's header properly.

Burlesque, 13 bytes
raJ++j>]2.*.>

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

+1 good job working on this :)

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!

I have never seen Wren around here, for the short time I've been around

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!

Good solution +1! It is a shame that the m doesn't save you anything...

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!

Good job on this one! +1 can you please explain me why you need the #import?

@RGS Because functions (like std::sort) are not implicitly declared in C++, and std::vector is not a builtin.

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

Really good job James! +1 And welcome to the site :D

Why need the  a=?

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

Cool submission! :D +1

Interestingly, SUM(A:A) is exactly the same number of bytes as A1+A2+A3

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!

Really funny solution! +1 good job!

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.

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

@RGS okay, you got me, maybe it was kinda intentional.

Vyxal, 4 bytes
∑½<A

Try it Online!

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

:)

Welcome to Code Golf, and nice answer!

MathGolf, 5 bytes
Σ\╙∞>

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

But in this case, it is shorter!

@RGS What do you mean? Both are 5 bytes, and the exact same explanation.

I meant your original O5AB1E one was 6 bytes :p

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

Good job on this answer!

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.

Impressive first answer and very well presented. welcome!

@J42161217 ditto!

I feel like there was another higher-up user named a'_' that went missing recently. Hmm...

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

Kool answer! +1 To bad you have to spend three bytes reading the integers!

@RGS whatever do you mean by spending three bytes to read the integers? :P

Nevermind me :) Can't upvote anymore today :( will try to remember to do it tomorrow!

@RGS I know that feeling :P.

one up!! Go work on those lists now!!!

Stax, 7 bytes
å·b→1.R

Run and debug it

Haven't heard of Stax before! Good work on this +1

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.

De facto! Thanks for the R submission! +1

Julia 1.0, 20 bytes
f(s)=all(sum(s).>2s)

Try it online!

Nice and simple Julia submission +1 :)

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.

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?

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!

+1 for your answer, and I had never seen people doing "imports" with flags! Amusing :D even though it feels unfair :(

iv'e added another answer without using imports

you are welcome to use "imports" in the flags! I was just thinking it is quite nice that you can "get away" with it :)

meta on imports https://codegolf.meta.stackexchange.com/questions/4776/how-do-we-count-compiler-interpreter-flags

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!

Is a/3 the third element of a? Because it looks like you are dividing by 3 :O

@RGS Haha, yes - it really is the third element (notice the lack of spaces around /) This is path notation in Red, used for indexing, navigation in hierachical structures, map keys, object fields and so on.

thanks for the clarification!

31 without the trailing newline.

@S.S. Anne Thanks!

Japt -e, 5 4 bytes
Ñ<Wx

Try it here

for a simple answer. What does "transpiled JS" mean in the Japt console? (Btw looks like the cockpit for a spaceship! +1)

No, it needs to be UNIX.

Pyth, 8 6 bytes
<yeSQs

Kinda unfortunate that pop is two bytes :'(
Saved 2 bytes thanks to @RGS
Try it online!

Good job on the Pyth answer, but then wouldn't it be better to use this formula?

@RGS Not sure how I missed that, saved 2 bytes, thanks!

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

+1 for your work, isn't there a way for you to shave one of the θ by using the input implicitly as the argument?

@RGS Maybe, but not in verbose mode, I don't think.

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 @

Interesting submission! +1 for that :)

Husk, 6 bytes
§<ΣoD▲

Try it online!

Seems fine, just @ed you in TNB

TI-Basic, 7 bytes
sum(Ans)>2max(Ans

Takes input as a list in Ans.

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

Get outgolfed (it's completely different tho, not a golf of this)

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

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

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

JavaScript (V8), 26 bytes
g=(a,b,c)=>a<b+c&&g(b,c,a)

Try it online!

Is this valid if it really only works for Truthy cases?

@RGS It crashes if true and not crash if false, and requiring a realistic stack

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

Try it online!

Knight, 32 bytes
O&<=a+0P+=b+0P=c+0P&<b+a c<c+a b

Try it online!
The obvious answer.

You can probably save a few bytes by using subtraction / negation and not adding the zeoes

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


text:
Find the most important character
Find the most important character
The challenge is to write a program that outputs the most occurrent character in the input string, excluding these bracketing characters ()[]{}.  Each submission should consist only of non-trivial* characters.  Each solution is scored using the formula in the scoring section.  Bracketing characters are allowed in the program, but may not be selected by the program as the most occurrent character.  In cases where letters occur with the same frequency, any or all of the characters may be returned.
*Non-trivial is defined in this case to be a character that contributes to the functionality of the program.  If the character can be removed without influencing how the program runs, it is a trivial character.
Scoring
Score is determined as follows:
$$(\frac{n_{char}}{n_{total}}) * 100(\%) $$
With nchar being the number of occurrences of the most frequent character in the input, and ntotal being the total number of non-trivial characters in the input.  With this scoring criteria, all scores should be within the range \$[0,100]\$
Highest scoring solution per language wins.
Input
Solutions should take in any valid string as input.  A convenient method of determining the most occurrent character in the program itself would be to use the program's source code as input to the program itself.  The program does not have to check for non-trivial characters, as they should not be included in the program source.
Output
A single character with the highest percentage occurrence.  Each solution should be capable of outputting standard ASCII, as well as the language's codepage (if applicable).
Errata
Creative solutions are encouraged.  Boring solutions with long padded strings substituted in for numbers are discouraged.  Standard loopholes are disallowed.
Examples
Program:
aabbbc
Output:
b

Program:
aabb
Output:
a or b or ab

Sandbox Link

05AB1E, 99.999999999999999957%
1111111111111111111 ... (9352835025086960662 1's total) ... 11111g₅B.V

g gets the length of the large integer literal. Obviously this is too long for TIO, so try a version using 9352835025086960662 instead of the equivalent 1111...1111g.

In theory you can get a higher score by just having worse 05ab1e code after base change?

@ExpiredData yes, getting arbitrarily close to 100% is trivial. I could also use base 9999 instead of base 255 for extra bloat. This is the highest I can get while sticking to the pseudo-rule Boring solutions with long padded strings are discouraged.

JavaScript (Node.js), 55.85% (or much more)
s=>eval(Buffer((g=n=>n?[+[n&127n],...g(n>>7n)]:[])(0b1001111010011001001100101001101110111000110111101100111110110111101111011110111011010111010011000001111111101101011110001010011011101110001110110111101111111111001011010111101101110111000111011011110111101010000111110011110111000110101100110011101011111011101101110110111001011011111110111110110101001010100010111101011011010111101111011101111011110111011010101000110010111000111100001110110011100001100101111001001011101110011n))+'')

Try it online!
This is a 'fair' version, in that only the payload binary data is included (7 bits per character). But the score could be made arbitrary large by padding each encoded character with as many zeros as desired. They would still be 'non-trivial' as per the challenge rule, as removing any of them would break the decoding.
The binary string is decoded as:
s.replace(m=o=/[^(){}[\]]/g,c=>(o[c]=-~o[c])<m?0:m=o[O=c])&&O

PHP, 75%
foreach(count_chars($argn)as$c)$o[]=$c*'1111111111111111111111111111111111111111001111111111111111111111111111111111111111111111111010111111111111111111111111111110101111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111'[$i++];arsort($o);echo chr(key($o));

Try it online!
Ungolfed:
// table of valid input chars - ASCII 0-255
// index is the ASCII number, and 1 or 0 if it is valid
$valid_chars = '1111111111111111111111111111111111111111001111111111111111111111111111111111111111111111111010111111111111111111111111111110101111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111';

// get input string and aggregate count of each letter
$counted_chars = count_chars( $argn );

// iterate through each
foreach( $counted_chars as $ascii => $count ) {
    // multiply count by either 1 if valid or 0 if not
    $out[] = $count * $valid_chars[ $ascii ];
}

// sort resulting list descending
arsort( $out );

// display the ASCII value of the "most popular" valid char
echo chr( key( $out ) );

Counts the frequency of each character and uses a lookup table to to determine if a given character is excluded (example: ()[]{}) from being counted.  Sorts by frequency and returns the "most important" remaining char.
Note: PHP's count_chars() only counts ASCII chars 0-255 which corresponds to the array of valid chars, so is not arbitrarily or unnecessarily long.  Using a lookup table of flags to test the validity of a result is, while not the most efficient in this case, a valid and commonly-used programming practice.

05AB1E, tends to 50%
'""{}[]()"'""м.M"J".V"".V"".V".V

Try it online!
You can keep appending ".V" before the final J, any part of this string can't be removed and hence none of the characters themselves are non-trivial. Hence this tends to 50% of the program being " as you add more ".V"
Note: you couldn't have a single char command to tend to 66% inside the brackets like "J" as it can likely be shortened to ""

C (gcc), 13.2% ;
float m;a[256];l;t;c;n(char*s){bzero(a,1024);l=0;for(;*s;){a[*s]++;s++;l++;};m=0;t=0;for(;t++<255;)if(a[t]>m)c=t,m=a[t];m*=100;printf("%c %f\n",c,m/l);}

This version doesn't pad the end with semicolons. It only contains a few unneeded ones to push up my score to the next percent.
Feel free to add semicolons up until you get 100%.
Try it online!