Dal Segno i Da Capo to dwa bardzo powszechnie używane terminy muzyczne. Oznaczają odpowiednio „ od znaku ” (𝄋) i „ od początku ”.

Istnieje również pomysł na kod (𝄌), który jest końcem utworu muzycznego. To, co gra się po „głównej części” utworu.

Na przykład DS al coda ( Dal Segno al coda ) oznacza „idź do segno , graj, dopóki nie zostaniesz poproszony, aby przejść do cody , a następnie wskocz tam”.

Opis

Twoim zadaniem w tym wyzwaniu jest uzyskanie wkładu złożonego z dowolnej liczby nut, które mogą, ale nie muszą zawierać Dal Segno i Da Capo, i wygenerować tę samą muzykę ze wspomnianymi wyżej skokami „rozwiniętymi”, aby powtórzenia były rozszerzone dosłownie.

Wejście

Twój kod powinien przyjmować jako dane wejściowe sekwencję nut lub sygnałów (tutaj zdefiniowanych jako wszystko oprócz nuty), oddzielonych spacjami w jednym ciągu.

• Notatki są któregokolwiek z a, b, c, d, e, f, lub g, z opcjonalnym #lub bdołączane (dla celów tego wyzwania, nie ma rytm).

• A C(duża litera c) oznacza oznaczenie kodu . Zawsze będzie zero lub dwa oznaczenia kodów ; pierwsze oznaczenie kodowe wskazuje, gdzie skoczyć, a drugie oznacza miejsce, do którego należy skoczyć.

• Symbol S(s) reprezentuje oznakowanie signo . Zawsze będzie zero lub jedno oznakowanie (-a) signo .

• F( Wielka litera f) oznacza dokładne znakowanie. To „przesłania” koniec utworu - więcej na ten temat poniżej. Zawsze będzie zero lub jeden drobny znak (y).

• Dowolne z poniższych dokładnych ciągów tekstu reprezentują:

  • D.S. al fine: przejdź do signo i graj aż do końca utworu lub dokładnego oznaczenia (jeśli istnieje).

  • D.S. al coda: idź do signo , graj do kody , a następnie przeskocz do drugiego znaku kody i graj do końca utworu.

  • D.C. al fine: przejdź do początku, graj do końca lub dokładnego oznaczenia.

  • D.C. al coda: przejdź do początku, graj do kody , następnie przeskocz do drugiego znaku kody i graj do końca utworu.

  Zawsze będzie minimum zero i maksymalnie jeden z każdego łańcucha na sztukę. Nigdy nie będzie wielu al fines lub wielu al codas w jednym kawałku.

Wynik

Kod powinien być generowany w podobnym formacie łańcuchowym: lista notatek oddzielonych spacjami.

Zawsze możesz założyć, że wynikiem będzie jeden lub więcej znaków.

Przypadki testowe

W: a# bb c b a
Out:a# bb c b a

W: a S b D.S. al fine c
Out:a b b c

W: a S b C c D.S. al coda d C e
Out:a b c b e

W: a b F c d D.C. al fine e f
Out:a b c d a b

W: a b D.C. al fine c d F e f
Out:a b a b c d

W: a b C c d D.C. al coda e f C g g#
Out:a b c d a b g g#

W: a b D.C. al coda c d C e f C g g#
Out:a b a b c d g g#

W: a b S c d C D.C. al coda C D.S. al fine e f F g
Out:a b c d a b c d c d e f

W: a S b C c D.S. al coda C d D.S. al fine e F f
Out:a b c b d b c d e

W: a b C c d D.C. al coda e f F g g# C gb a# D.C. al fine
Out:a b c d a b gb a# a b c d e f

W: a F b C D.C. al coda C D.C. al fine
Out:a b a b a

W: C a S b D.C. al coda C c D.S. al fine d
Out:a b c b c d

W: a S b D.S. al coda C C c D.C. al fine
Out:a b b c a b c

W: a F C b C D.C. al coda D.C. al fine
Out:a b a a

Zasady

• Oznaczenia będą zawsze wyświetlane w logicznej kolejności. Oznacza to, że nigdy nie będzie Spo D.S.i zawsze będzie przed nim itd.

• To jest code-golf , więc wygra najkrótszy kod w bajtach.

JavaScript (ES6), 253 bajtów

x=>eval('n=(" "+x).replace(/D.{11}|[CSF]/g,d=>({C:4,S:5,F:6}[d]|(d[2]<"S")*2+(d[8]<"f"))).split` `;for(i=c=f=o="";v=n[++i];v<9?v<4?(n[i]=7,i=0,s=n.indexOf`5`,v==0?f=i=s:v==1?c=i=s:v==2?f=1:c=1):v==4&c?c=!(i=n.indexOf("4",i+1)):v==6&f?i=n:0:o+=v+" ");o')

Wyjaśnienie

Można by lepiej grać w golfa, ale na razie skończone.

x=>
  eval(`                                  // use eval to enable for loop without return
    n=(" "+x)                             // n = array of [ "", ...notes/commands ]
                                          // empty first element means f and c can be set
                                          //     to i (always true) in the cases below
      // DS fine => 0, DS coda => 1, DC fine => 2, DC coda => 3, C => 4, S => 5, F => 6
      .replace(/D.{11}|[CSF]/g,d=>({C:4,S:5,F:6}[d]|(d[2]<"S")*2+(d[8]<"f")))
      .split\` \`;
    for(
      i=                                  // i = position in note array
      c=                                  // c = look out for coda if true
      f=                                  // f = look out for fine if true
      o="";                               // o = output string
      v=n[++i];                           // v = note/command
      v<9?                                // if not a note
        v<4?(                             // if DS/DC
          n[i]=7,                         // change it to NOP
          i=0,                            // reset i here to save doing it in DC cases
          s=n.indexOf\`5\`,
          v==0?f=i=s:                     // case: D.S. al fine
          v==1?c=i=s:                     // case: D.S. al coda
          v==2?f=1:                       // case: D.C. al fine
          c=1                             // case: D.C. al coda
        ):
        v==4&c?c=!(i=n.indexOf("4",i+1)): // case: C
        v==6&f?i=n:                       // case: F
        0                                 // case: S
      :o+=v+" "                           // add the note
    );o                                   // return the output
  `)

Test

var solution = x=>eval('n=(" "+x).replace(/D.{11}|[CSF]/g,d=>({C:4,S:5,F:6}[d]|(d[2]<"S")*2+(d[8]<"f"))).split` `;for(i=c=f=o="";v=n[++i];v<9?v<4?(n[i]=7,i=0,s=n.indexOf`5`,v==0?f=i=s:v==1?c=i=s:v==2?f=1:c=1):v==4&c?c=!(i=n.indexOf("4",i+1)):v==6&f?i=n:0:o+=v+" ");o')

<input type="text" id="input" value="a b C c d D.C. al coda e f F g g# C gb a# D.C. al fine" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>