Despliega saltos musicales

11

El Dal Segno y Da Capo son dos términos musicales utilizados muy comúnmente. Significan " desde el signo " (𝄋) y " desde el principio " respectivamente.

También existe la idea de la coda (𝄌), que es el final de una pieza musical. Es lo que se reproduce después de la "sección principal" de la pieza.

Un DS al coda ( Dal Segno al coda ), por ejemplo, significa "ve al segno , juega hasta que te digan que vayas a la coda y luego salta allí".

Descripción

Su trabajo en este desafío es tomar entradas compuestas de cualquier número de notas que pueden contener o no Dal Segno y Da Capo y emitir la misma música con los saltos mencionados "desplegados" para que las repeticiones se expandan textualmente.

Entrada

Su código debe tomar como entrada una secuencia de notas o señales (aquí definidas como cualquier cosa menos una nota), separadas por espacios en una cadena.

  • Las notas son cualquiera de a, b, c, d, e, f, o g, con una opcional #o banexa (para los fines de este reto, no hay ritmo).

  • A C(capital c) representa una marca de coda . Siempre habrá cero o dos marcas de coda ; la primera marca de coda representa desde dónde saltar, y la segunda representa hacia dónde saltar.

  • Una S(mayúscula) representa una marca de signo . Siempre habrá marcas de cero o un signo .

  • Una F(mayúscula f) representa una marca fina . Esto "anula" el final de la pieza, más sobre eso a continuación. Siempre habrá cero o una marca fina (s).

  • Cualquiera de las siguientes cadenas de texto exactas representan:

    • D.S. al fine: ve al signo y juega hasta el final de la pieza o la marca fina (si existe).

    • D.S. al coda: ve al signo , juega hasta la coda , luego salta a la segunda marca de coda y juega hasta el final de la pieza.

    • D.C. al fine: ir al principio, jugar hasta el final o la marca fina .

    • D.C. al coda: ve al principio, juega hasta la coda , luego salta a la segunda marca de coda y juega hasta el final de la pieza.

    Siempre habrá un mínimo de cero y un máximo de una de cada cadena por pieza. Nunca habrá múltiples al fineso múltiples al codas en una pieza.

Salida

Su código debe aparecer en un formato de cadena similar: una lista de notas, separadas por espacios.

Siempre puede suponer que la salida terminará con uno o más caracteres de longitud.

Casos de prueba

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

Reglas

  • Las marcas siempre aparecerán en un orden lógico. Es decir, nunca habrá un Safter a D.S.y siempre habrá uno antes, etc.

  • Este es el código de golf , por lo que ganará el código más corto en bytes.

code-golf music Pomo de la puerta
fuente

Respuestas:

1

JavaScript (ES6), 253 bytes

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

Explicación

Se podría jugar mejor al golf, pero ya he terminado.

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

Prueba

Mostrar fragmento de código

usuario81655
fuente