[Question]
  [
# 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
```
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~15~~ 14 bytes
```
‚Äô√Ø√™o‚Ä°√Öefa‚Äô7√§√•√†
```
[Try it online!](https://tio.run/##yy9OTMpM/f//UcPMw@sPr8p/1LDwcGtqWiKQb354yeGlhxf8/19cmlScmZKZWFQJAA "05AB1E ‚Äì 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
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~¬†18¬†~~ 14 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
-4 thanks to Nick Kennedy & [Grimmy's 05AB1E answer](https://codegolf.stackexchange.com/a/199161/53748)
```
7‚Äú·∫à|n≈ªU·∏ã}¬ª≈ìsf·∫Ü
```
A monadic Link accepting a list of characters which yields a, possibly empty, list of lists.
**[Try it online!](https://tio.run/##y0rNyan8//9Rw5yHuzpq8o7uDn24o7v20O6jk4vNVdIe7mr7f3TPo4a5IUDsdrjd/lHTGvf//6PV0xKL1HUU1IvzcxKTU0GspPzEErBIRlFmbgGIlZZZBJYpLs3NzQTLJWUWJ5dCmaU5OalgVkp@ckk@2LCknMRisFByPlAyHao5qTgzJTOxqBLEy08CWphakqoeCwA "Jelly ‚Äì 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](https://en.wikipedia.org/wiki/Tonic_sol-fa) is a name of a [solf√®ge](https://en.wikipedia.org/wiki/Solf%C3%A8ge) method, where tones are given single syllable names, and was when `si` first became `ti`.
[Answer]
# [Python](https://docs.python.org/2/), 52 bytes
```
import re
re.compile('do|re|mi|fa|sol|la|si').search
```
[Try it online!](https://tio.run/##FY1BCsQgDEX3OUV3bTeFmeXAnGWIVseANhIjpeDdrV09@LzPy5cGPt69U8osOokD/xW3WU6ZolvmnZu4lqh5bIVjiwM0r1txKDb0Mwxren2y0KGTXwTPHx256rKu3aPA@KB1YBgVSpCRAU@jUmpKpGCo2PqwxugUdrbKAiZiUbA8tv@jmkI7oVw3 "Python 2 ‚Äì 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!](https://tio.run/##FYvLCsMgEADv@xXemkAptMdA/6RQ1ldd0CjrigT8d5ucBoaZckjI@2v692dGTNqi6hu7R3XIJiw3mwe7kWh4HDXHEU/Q7d5XoFQyi2I3e6Do1HMrTLsovzD2L@2lybKu0yPDOaJxoDMK1MDnCZ7YQW0pkYCmatrFFqMTsNlIZtARq4DJp/tdqa5kCfn4Aw "Python 2 ‚Äì 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!](https://tio.run/##FYtLCsMwDAX3OoV3caAE2mWgNykU@dcI/EOWMTm9m6wG3ryppxwlv2Z4f2bEZByqsWM@dcKqx2ZLz/JYXFHsVSIVULUSVbxAy9ZqJNHrus5xUPTquVemLCpoxvGlXPttZ0CGq0LrwRQUaAdTqhCIPbSeEgkYarbf7DF6AVesFAYTsQnYcm2/@2oaOUI@/w "Python 2 ‚Äì 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.
[Answer]
# [CP-1610](https://en.wikipedia.org/wiki/General_Instrument_CP1600) assembly ([Intellivision](https://en.wikipedia.org/wiki/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
[![output](https://i.stack.imgur.com/8s3At.gif)](https://i.stack.imgur.com/8s3At.gif)
*screenshot from [jzIntv](http://spatula-city.org/~im14u2c/intv/)*
---
*1. A CP-1610 opcode is encoded with a 10-bit value (0x000 to 0x3FF), known as a 'DECLE'.*
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 26 bytes
```
{?/do|re|mi|fa|sol|la|si/}
```
[Try it online!](https://tio.run/##TY49EsIgEIX7nGIro0USKztj5wnsHAsgYHZmkQwLBRM8e8QqVDvfvp95i/Z02WyCg4Hrtt6GyWWvs8VsRGZHmcrB4bsZ54Hwo3kce14Iw7HtxvYEawPAIkH/PL/6g2mKU3joRnj4GObUlA6hdPWQToQ/3gVxkWePdtnZoK/NHK3FUKeRVcSqQEYiXfHkVHD1AEmC6wblSuCtqwlRMk4ofNpdPw "Perl 6 ‚Äì Try It Online")
Boring regex solution that checks for any of the strings.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 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](https://codegolf.stackexchange.com/users/58563/arnauld)!*  
*-8 bytes thanks to [gastropner](https://codegolf.stackexchange.com/users/75886/gastropner)!*  
*-2 bytes and -12 characters thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!*
[Try it online!](https://tio.run/##XVExTsMwFN1zio9RUdwmUAmplUhbNiZGtraD4ySNpSSu/B1EqTr2CNyAMsECM9fJNYKTFEhqWbbf03vfz9/cXXFeltyLbJHpPtJtJJXNp2OPX1ycoVZm2ujck@L7tXj5LA4fxf6t2L8Xh6/F04iPovE1Gbgupx71duW5yHiSByFMUAdCXsYzyzJlIWUisx@lCKi1tcCMitQhaq9GPGYK@hXG@RKmNdfoqkEipojzD1EmjIdtxpdMdxSxEum6zURCdRyYp6noeHyBPD@h8iQJO0wguZadMH7CsCPh0phWJ5f5KALB1KbNSt88JNQdJUtQHvHOs@q9@o66VTCFodecJoDiOZSRXbeMXrXRfLikjWwwAPpXeq1MyyOb9BDcGfRwkREHGkO1Lh349deQwi2QB5XreEPgBsidSbYh9JhJhTpXmYlj7cof "C (gcc) ‚Äì Try It Online")
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), ~~47~~ \$\cdots\$ ~~31~~ 30 bytes
```
{print/do|re|mi|fa|sol|la|si/}
```
[Try it online!](https://tio.run/##FYxBCgMxCADvfmbfpInZSpO6qKGU2ren2dPAMAy@n2t9L5NXHFXTOIdkw3Tt2Tfk@K3V0GALLAykGOAPk3FBE2PwOYYEkHiZN2fvHFC1hBpQRw8out15p@RSBe0DSvvHwX8 "AWK ‚Äì Try It Online")
`awk` automatically compares any regex with `$0` (current line).
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 21 bytes
```
do|re|mi|fa|sol|la|si
```
[Try it online!](https://tio.run/##K0otycxLNPz/PyW/pii1JjezJi2xpjg/pyYHSGX@/5@fBOSklqQCAA "Retina ‚Äì Try It Online")
Very obvious and boring solution. `0` for false, nonzero for true.
[Answer]
# Java 8, 43 bytes
```
s->s.matches(".*(do|re|mi|fa|sol|la|si).*")
```
[Try it online.](https://tio.run/##bZExb8MgEIX3/IoTk0kUog5dErVjt2ZJt6rDGeOYFIMF50hRnd/uEuJWMu0C4juO9x53wjOuT9XnKA2GAK@o7dcCQFtSvkapYH87ApTOGYUWZHEgr@0RAt/FwnURl0BIWsIeLDzBGNbPQbRIslGhYGJZVG7wamj1UOMQnBlM3DQXS8bH3a2960sT26dXzk5X0EYbk9D7ByC/e9hs4M331Fy26UgqUMFq9CxZ@QFRIvqes1r7jIS@bTXNWeUkuey1Mn4L5a1l0JVGf5lzV0ZpRb9Ch0sg1QrXk@hiEjK24ClwSvKCJqhZktJhrtR43XaZIR1knzsvexOV50y6yI5Z7Cjq5oT9mWOaQCpOo9a262mawT@hUnnFtmzFgAmvOoVUPDyuExdG2SM1BecrK@T9Lp8kr@M3)
**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
```
[Answer]
# [Python 3](https://docs.python.org/3/), 60 bytes
```
lambda w:any(i in w for i in'do re mi fa sol la si'.split())
```
[Try it online!](https://tio.run/##JY2xDsMwCER3voKtzpKlW6X@SRcc2y2SbSIgqvL1qa2yHDq4d/vpH@n3q@ATX1elFhPh90H9DIzc8YtFFOd6S4KasTEWQpOKdQjfVtsre1iWi9su6minAcxQ5Z4nYhireeK@aqYUln9iXi0sD8Axu3L3UMI0B6mQwmigLUMUcrCPDjgU1gx2tMYOkW07ph61Zockm4tCrGQOmwzvPV@jcWLS8wc "Python 3 ‚Äì Try It Online")
[Answer]
# [Red](http://www.red-lang.org), 63 bytes
```
func[s][parse s[to["do"|"re"|"mi"|"fa"|"sol"|"la"|"si"]to end]]
```
[Try it online!](https://tio.run/##VU85DgMhDOx5BaLPB1LkEWkRBYfJWoL1yoYiUv6@gShSiIuRPZ6RPQzpvEOyTuXrmfserTh7eBbQYhtZk8i8DMOAigOyHyBUBpZPi8Y10rAn585MDD5uWhprq/S3hofNbxpmH2EhAvm27jfGeixERl7l0mvF1RBQYv9neimwEolio/WJULysgkjD8fg/EwQTen4arZzVc3Mw7k3bGc9cbibPoE65qT/f "Red ‚Äì Try It Online")
[Answer]
# 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.*
[![Scratch Blocks!](https://i.stack.imgur.com/RKga4.png)](https://i.stack.imgur.com/RKga4.png)
*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 on~~line~~ Scratch!](https://scratch.mit.edu/projects/366486822)
[Answer]
# [R](https://www.r-project.org/), ~~44~~ 40 bytes
Another simple regex implementation. Fixed stupid mistake, thanks @Giuseppe.
```
grepl("do|re|mi|fa|sol|la|si",scan(,''))
```
[Try it online!](https://tio.run/##FYwxCsQwDAR7PSNNEsinZFvOCeRTkOTiwH/3OdXAzjI25230yLEVHUaj8ag4XGXIAm@XZ/we176f56xosAxmgqQY4B/j9kBlI/DeGgck9txfdhEKKJpDDZKgB2Rd2/1ek3NhtB9oWj0KAhTX@Qc "R ‚Äì 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.
[Answer]
# [Zsh](https://www.zsh.org/), ~~36~~ 35 bytes
```
[[ $1 =~ 'do|re|mi|fa|sol|la|si' ]]
```
~~[Try it online!](https://tio.run/##bYyxjsIwEET7@YoVCiKhgvp0zfVwzXVAYSfry0pOjLyOIu7MtwenRxpppHlP86f94uqmXi4Xqo70Sfu6CzlyHiQ7kzX47EtJs6fbbWkAFyLNVMOZiEJNy7DBJGgfZbjDSWToNAySYEXbae3Je07oQptChPVGE9pQtt9VtSqdmPhAsOWPE6Ohf0AcOarmD0o9jyC6RxmTo932eFCSknEldDp9Xccdbap5A/bKb8zz98872wnwXF4 "Zsh ‚Äì Try It Online")~~
[Try it online!](https://tio.run/##bYwxa8MwFIT3@xWP4GJ7a@aSpXvapVuaQbL14geyFfRkTBKlf92V98DBwX0fd9dh5aZt1tOJqj0d/qjuQ44uj5LZZA0@@1JS0/m8tgCHSAs1YBNRoOkcbDAJOkQZr2CJDjqPoyRY0W7eevbeJfShSyHCeqMJXSjbZVOtSi8m3hBs@XPJoaUHIExM1fJBaXATiK5RpsRUv@3flaRk2ggdj5@/U027atnBeXUvzK/vn1c2C/Bc/wE "Zsh ‚Äì 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!](https://tio.run/##bYyxTsNAEAX79xWrYBQ7FWmhow80dIHizt7FK5190e1ZVsjl243dpxrpzej9Wb9I3dTLmarb8fXpUHexJC6DFnHFYihhhTaHO/0sDSAx0Uw1xCWs1rUMH12G9UmHC0QTw6Zh0Ayv1k4bpxA4o4ttjgk@OMto47r9bqk37dSlK6Jf/zgzGroBKiRUzW@Uex5BdEk6ZqH98/HFSI0@Pr9Ix83S6fT@Pe5pV807cDB@UD8oRYH78g8 "Zsh ‚Äì 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)`.
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), `-rR` 53 bytes
```
@h2|/√∑!1‚â†:[‚ëπ]√∏∆í0&·†Ä¬Æs`do,re,mi,fa,sol,la,si`\,/√∑(¬©s@h∆í
```
[Try it online!](https://tio.run/##y05N///fIcOoRv/wdkXDR50LrKIfTdwZe3jHsUkGag8XNBxaV5yQkq9TlKqTm6mTlqhTnJ@jkwOkMhNidIBaNA6tLHbIODbp///EnOL8/7pFQQA "Keg ‚Äì 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
```
[Answer]
# [Python 3](https://docs.python.org/3/), 59 bytes
```
lambda w:any('sdrmflsooeiaail'[i::7]in w for i in range(7))
```
[Try it online!](https://tio.run/##JYqxTsUwDAB3f4W3l8wMT6rE@FhZ2IDBSZNXiySuHEelX19aMd3pdOtui7SXI@Mrfh2FapgJt4na7m591ppLF0lMxOX2ydN0/@aGG2ZRZDxVqT2Tu3t/bAuXhB860gSIpvsFxFW5mcuO2zrMee/Pmn5jWg0f728PVdH/MWiinyOTQpdCMUEQMuiLcl0hsyboo1Y2CNzjuDhKSQazRBOFUKgbRDnb81pD55lJ9z8 "Python 3 ‚Äì Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~20~~ 19 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
`√éol√å¬∑n√®^`q√ç√∏U√£
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=YM4Ob2zMEbdu6JheG2BxzfhV4w&input=WyJmYXIiLCJzb2xhY2UiLCJib2F0Iiwic2hyaW1wIiwiZmlyZSIsInN1bW1pdCIsImJpc2N1aXQiLCJidWxsZXQiLCJkb2N0b3IiLCJibGFzdCIsImNvbGxlZ2UiLCJzdWJzaWRpYXJ5Iiwib2Jzb2xldGUiXQotbVI)
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 34 bytes
```
:a;7,{a"sdrmflsooeiaail"@>7%/,2=},
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/3yrR2lynOlGpOKUoNy2nOD8/NTMxMTNHycHOXFVfx8i2Vud/wv/i0qTizJTMxKJKAA "GolfScript ‚Äì 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?
```
[Answer]
# [Pyth](https://github.com/isaacg1/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¬∑>√îMùv¬¥#¬∞"
```
[Try it online!](https://tio.run/##pVK9TsMwEB7Y/BTXstiSxQMwICFVFUjt0vQFrs2FhDpxlbhEQTwGKy/AxIDEnj5YOTswNQkDUhTH@X58d5/3jUtPp@vnqym@XBzf1V37dXN8XbZvT@3nZfsxPZ1mFmRsFZQEsiQFeQYyz5SYI8gEFVSMV4wb3hveO8ZdpiDudGJmNWs16zQkqJmvmauZp5kzEbFlECEmKv2aUI6GwlbIFU34YGwCobR7sAk8WBNTAdWhEHKZMZ4HfYE5wT1s0RjIm4pMIuQcGU4w@BpbPOjwhhobcBZK7xBZplRUBwuimI/eH4zJmObSkjAWcuFdfMXMsI68NLHG2JpbEXLtS3CEXYlZsYM6cyk8Yg5YxLAJHusUHf/n0jaltz5UsMHtzlvxmGzaPTyqCcjeUSjBowjY2RSU4Cl46HwCPqQA9TavRNSd19u3EotOe9azEtyzHO5WjbcrbnuzXg2mvBzKdz6WbDSW6WIgzfV/cvzzpnvcf5sfzHM812t@8TF9ZMP6DQ "Pyth ‚Äì Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 17 bytes
```
}#zc7."as√ê@¬ª„¬∏√è
```
[Try it online!](https://tio.run/##K6gsyfj/v1a5KtlcTymx@PAEaQfhQ7sPtRzacbj////i/JzE5FQA "Pyth ‚Äì 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.
[Answer]
# [J](http://jsoftware.com/), 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!](https://tio.run/##FYyxCsIwFEV3v@KiYKxoqWu0UhCcnFwtSpImNpLwJEkHvz6mw@XA5XA@eVkzg5aDYYcGvGxf43K/XfODbw@r@slfmyNnAyFoeAsjEMnBFVhWrdvu1Pd1rhZajQTTnZcNim5EmDWhNCSJhDgG678wtkTi5L1NkDaqaebknE4YSCUKkE7EBEXle8@qjHawIvxAsvR00hAuEst/ "J ‚Äì Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](https://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc) with `/u:System.Text.RegularExpressions.Regex`-flag, 37 bytes
```
s=>IsMatch(s,"do|re|mi|fa|sol|la|si")
```
[Try it online.](https://tio.run/##TZDBasMwEETv/gqhk00ahx56SZrcGiikUNpAz7K8thdky2hXJaHur9eVnVLrtHrD7OwgTWtNOB59px@JHXb1nSisNQdRif1I@8MzvSjWTUp3srSDg6HFoVIDWTOYMFBm4y7ZbMTZeW6u2@QMxKmslJPZ7g@CV2lYuEIXEfm2RV64tJpttF0YRRzbC8ISlbsumi3CCeA59MMhwwk7SANMxY7KEPwXK6yKwxqHbR/dQtI@LlN4E4IX1jZwHbUP4Xah6ZV8WizFzLcPFdj1nrOvRIil3Kyt5FaupMxfVXmCitP7h/Ws5yfoam6yVXXzZSH2e/yxPaPtaNz47fuVGNr8DBfO36D2RrmnS@@AaHJMElx@AQ)
**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
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 33 bytes
```
s=>s.match`do|re|mi|fa|sol|la|si`
```
[Try it online!](https://tio.run/##bY8xDsMwCEX3HiNTMjQ3SM8SjO2ECofIOJUq@e6Ou1ZM8P@DL3jDBxQzneV5iA8tLk2Xl84JCu6rl5pDTVQjVBWu3AutDeXoKsws2xjHIUIepunx5/YeMBjACRRrfs@UTgNEylaMXimRFeRI8bLJxRws4AWLWE84BrUWUHrSZp/llDxB/hpQ3E8Vaw9YpdvtBg "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
## [W](https://github.com/A-ee/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)
```
[Answer]
# [J](http://jsoftware.com/), 33 bytes
```
[:OR@,do`re`mi`fa`sol`la`si E.&><
```
[Try it online!](https://tio.run/##fYw9C8IwGIT3/orDwSBq7Rw/EEQnQejaJR9NNJLwSpIO/vqaDjo6HMfd@7z3HGc1s9hzMKzQgBeta5za62Xs@K09rnoS0YjghJUikRe@mMO5nh9246Lq@LLe/IUqox8EC2ZlZL@gSOZvOh5mDbZ8AlCepTaYzkiP6MIL1kWDNITgMpRLeph88N5k9KQzRSgvU4am0t0nVCXXOxnfIFX2TDaQPhEbPw "J ‚Äì 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
```
[Answer]
# 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.
[![Test samples](https://i.stack.imgur.com/IAMXZ.png)](https://i.stack.imgur.com/IAMXZ.png)
]