Can I join the music box?

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 1

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

Answer 2

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.

Answer 3

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.

Answer 4

CP-1610 assembly (Intellivision), 41 DECLEs¹ ≈ 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'.}

Answer 5

Perl 6, 26 bytes

{?/do|re|mi|fa|sol|la|si/}

Try it online!

Boring regex solution that checks for any of the strings.

Answer 6

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!

Answer 7

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

Answer 8

Retina, 21 bytes

do|re|mi|fa|sol|la|si

Try it online!

Very obvious and boring solution. 0 for false, nonzero for true.

Answer 9

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

Answer 10

Python 3, 60 bytes

lambda w:any(i in w for i in'do re mi fa sol la si'.split())

Try it online!

Answer 11

Red, 63 bytes

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

Try it online!

Answer 12

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!

Answer 13

Japt, 20 19 bytes

`ÎolÌ·nè^`qÍøUã

Try it

Answer 14

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

Answer 15

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?

Answer 16

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

Answer 17

Python 3, 59 bytes

lambda w:any('sdrmflsooeiaail'[i::7]in w for i in range(7))

Try it online!

Answer 18

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.

Answer 19

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!

Answer 20

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.

Answer 21

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

Answer 22

JavaScript (Node.js), 33 bytes

s=>s.match`do|re|mi|fa|sol|la|si`

Try it online!

Answer 23

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 24

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!