Le Dal Segno et Da Capo sont deux termes musicaux très couramment utilisés. Ils signifient respectivement " du signe " (𝄋) et " du début ".

Il y a aussi l'idée de la coda (𝄌), qui est la toute fin d'un morceau de musique. C'est ce qui se joue après la "section principale" de la pièce.

Une DS al coda ( Dal Segno al coda ), par exemple, signifie "allez au segno , jouez jusqu'à ce qu'on vous dise d'aller à la coda , puis sautez là".

La description

Votre tâche dans ce défi consiste à prendre une entrée composée d'un nombre quelconque de notes qui peuvent contenir ou non des Dal Segno et des Da Capo et à produire la même musique avec les sauts susmentionnés "dépliés" afin que les répétitions soient développées textuellement.

Contribution

Votre code doit prendre en entrée une séquence de notes ou de signaux (ici définie comme autre chose qu'une note), séparés par des espaces dans une chaîne.

• Les notes sont l' un des a, b, c, d, e, fou g, avec une option #ou en bannexe (aux fins de ce défi, il n'y a pas de rythme).

• Un C(majuscule c) représente un marquage coda . Il y aura toujours zéro ou deux marquages coda ; le premier marquage coda représente où sauter, et le second représente où sauter.

• Un S(majuscule) représente un marquage signo . Il y aura toujours zéro ou un marquage signo .

• Un F(majuscule f) représente un marquage fin . Cela "remplace" la fin de la pièce - plus de détails ci-dessous. Il y aura toujours zéro ou un marquage fin .

• L'une des chaînes de texte exactes suivantes représente:

  • D.S. al fine: aller au signo et jouer jusqu'à la fin de la pièce ou jusqu'au marquage fin (s'il existe).

  • D.S. al coda: aller au signo , jouer jusqu'à la coda , puis passer au deuxième marquage coda et jouer jusqu'à la fin de la pièce.

  • D.C. al fine: aller au début, jouer jusqu'à la fin ou le marquage fin .

  • D.C. al coda: allez au début, jouez jusqu'à la coda , puis passez au deuxième marquage coda et jouez jusqu'à la fin de la pièce.

  Il y aura toujours un minimum de zéro et un maximum d'une de chaque chaîne par pièce. Il n'y aura jamais plusieurs al fines ou plusieurs al codas dans un morceau.

Production

Votre code doit sortir dans un format de chaîne similaire: une liste de notes, séparées par des espaces.

Vous pouvez toujours supposer que la sortie finira par contenir un ou plusieurs caractères.

Cas de test

Entrée: a# bb c b a
Sortie:a# bb c b a

Entrée: a S b D.S. al fine c
Sortie:a b b c

Entrée: a S b C c D.S. al coda d C e
Sortie:a b c b e

Entrée: a b F c d D.C. al fine e f
Sortie:a b c d a b

Entrée: a b D.C. al fine c d F e f
Sortie:a b a b c d

Entrée: a b C c d D.C. al coda e f C g g#
Sortie:a b c d a b g g#

Entrée: a b D.C. al coda c d C e f C g g#
Sortie:a b a b c d g g#

Entrée: a b S c d C D.C. al coda C D.S. al fine e f F g
Sortie:a b c d a b c d c d e f

Entrée: a S b C c D.S. al coda C d D.S. al fine e F f
Sortie:a b c b d b c d e

Entrée: a b C c d D.C. al coda e f F g g# C gb a# D.C. al fine
Sortie:a b c d a b gb a# a b c d e f

Entrée: a F b C D.C. al coda C D.C. al fine
Sortie:a b a b a

Entrée: C a S b D.C. al coda C c D.S. al fine d
Sortie:a b c b c d

Entrée: a S b D.S. al coda C C c D.C. al fine
Sortie:a b b c a b c

Entrée: a F C b C D.C. al coda D.C. al fine
Sortie:a b a a

Règles

• Les marquages ​​apparaîtront toujours dans un ordre logique. Autrement dit, il n'y aura jamais un Saprès D.S.et il y en aura toujours un avant, etc.

• C'est le code-golf , donc le code le plus court en octets gagnera.

JavaScript (ES6), 253 octets

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

Explication

Pourrait être mieux joué au golf mais j'ai fini pour l'instant.

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

Tester

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>