Il Dal Segno e Da Capo sono due termini musicali molto comunemente usati. Significano rispettivamente " dal segno " (𝄋) e " dall'inizio ".

C'è anche l'idea della coda (𝄌), che è la fine di un brano musicale. È ciò che si suona dopo la "sezione principale" del pezzo.

Un DS al coda ( Dal Segno al coda ), ad esempio, significa "vai al segno , gioca fino a quando ti viene detto di andare alla coda , e poi salta lì".

Descrizione

Il tuo compito in questa sfida è quello di prendere input composti da un numero qualsiasi di note che possono contenere o meno Dal Segno e Da Capo e produrre la stessa musica con i salti di cui sopra "spiegati" in modo che le ripetizioni si espandano alla lettera.

Ingresso

Il tuo codice dovrebbe prendere come input una sequenza di note o segnali (qui definita come tutt'altro che una nota), separati da spazi in una stringa.

• Le note sono una delle a, b, c, d, e, f, o g, con un optional #o ballegato (ai fini di questa sfida, non c'è ritmo).

• A C(maiuscola c) rappresenta un segno di coda . Ci saranno sempre zero o due code segni di ; la prima marcatura di coda rappresenta da dove saltare, e la seconda rappresenta da dove saltare.

• Una S(maiuscola) rappresenta un segno signo . Ci sarà sempre zero o uno segni signo .

• Una F(maiuscola f) rappresenta una marcatura fine . Questo "annulla" la fine del pezzo, più su quello qui sotto. Ci sarà sempre zero o uno marcatura fine .

• Una delle seguenti stringhe esatte di testo rappresenta:

  • D.S. al fine: vai al signo e suona fino alla fine del pezzo o alla marcatura fine (se esiste).

  • D.S. al coda: vai al signo , gioca fino alla coda , quindi salta alla seconda marcatura della coda e gioca fino alla fine del pezzo.

  • D.C. al fine: vai all'inizio, gioca fino alla fine o alla marcatura fine .

  • D.C. al coda: vai all'inizio, gioca fino alla coda , poi salta alla seconda marcatura della coda e gioca fino alla fine del pezzo.

  Ci sarà sempre un minimo di zero e un massimo di una per ogni stringa per pezzo. Non ci saranno mai più al fineS o più al codaS in un pezzo.

Produzione

Il codice dovrebbe essere generato in un formato stringa simile: un elenco di note, separate da spazi.

Si può sempre presumere che l'output finirà per essere lungo uno o più caratteri.

Casi test

In: a# bb c b a
Out:a# bb c b a

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

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

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

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

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

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

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

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

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

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

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

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

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

Regole

• I segni appariranno sempre in un ordine logico. Cioè, non ci sarà mai un Sdopo D.S.e ce ne sarà sempre uno prima, ecc.

• Questo è code-golf , quindi vincerà il codice più breve in byte.

JavaScript (ES6), 253 byte

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

Spiegazione

Potrebbe essere giocato a golf meglio, ma per ora ho finito.

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>