Introducción

El código Parsons es solo una manera simple de describir las variaciones de tono en una pieza musical, ya sea que una nota sea más alta o más baja que la anterior.

Incluso si apestas al recordar melodías, aún puedes recordar si una nota sube o baja, por lo que el código Parsons puede ayudarte a identificar una música usando un motor de búsqueda.

Descripción

Cada variación está representada por un solo carácter, que es uno de los siguientes:

• Rsi la nota es la misma que la anterior (significa " R epeat" )
• Usi la nota es más alta que la anterior (significa " U p" )
• Dsi la nota es más baja que la anterior (significa " D propio" )

La nota inicial se escribe como *.

Ejemplo

Aquí hay un ejemplo de código Parsons (comienzo de "Oda a la Alegría" ):

*RUURDDDDRUURDR

Realmente puedes visualizarlo , así:

      *-*                    
     /   \                   
    *     *                  
   /       \                 
*-*         *         *-*    
             \       /   \   
              *     *     *-*
               \   /         
                *-*          

A partir de ahora lo llamaremos contorno .

Las reglas para dibujar dichos contornos se consideran explicadas por el ejemplo anterior.

Reto

Ahora viene el verdadero desafío.

Escriba un programa que, dado un contorno como entrada, emite su código Parsons correspondiente.

No se le pide que dibuje el contorno, sino todo lo contrario.
Desde el contorno, encuentre el código original de Parsons.

Reglas

• Se aplican las reglas habituales para el golf de código.
• El programa más corto en número de bytes gana
• La entrada es un contorno y la salida debe ser un código Parsons válido.
• Los detalles sobre espacios en blanco adicionales para la entrada son irrelevantes, haga lo que sea mejor para usted
• No está permitido codificar, de una forma u otra, partes de la salida y / o el programa utilizando espacios en blanco adicionales debido a la regla anterior

Notas

• Esto puede ser útil para probar
• El código de Parsons correspondiente para *es*
• Una cadena vacía no es un contorno válido
• Un código de Parsons siempre comienza con*

Pyth - 28 25 27 25 bytes

2 byes guardados gracias a @Jakube.

s+\*@L"RDU"-VFtBxR\*%2C.z

Pruébelo en línea aquí .

CJam, 21 bytes

qN/:.e>(o2%:i"DRXU"f=

Dobla las líneas ( :) vectorizando ( .) una operación máxima de carácter e>. Como solo hay un carácter sin espacio en cada columna, este será el resultado, ya que el espacio tiene un código ASCII más pequeño que todos los caracteres sin espacio imprimibles.

Desmarque e imprima el primer asterisco (o, luego asigne cada otro ( 2%) carácter restante para UDRusar la indexación modular.

Solución anterior (29 bytes)

'*qN/z2%'*f#0+2ew);::-"RDU"f=

qN/obtiene líneas de entrada. ztranspone esta matriz de caracteres. 2%cae cada fila impar. '*f#encuentra el índice del asterisco en cada fila. 0+2ew);obtiene todos los pares de índices sucesivos. ::-calcula sus diferencias, y "RDU"f=los asigna a las letras (a través de la indexación modular: 0 → R, 2 → U, -2 ≡ 1 → D). El encabezado '*antepone el asterisco.

EDITAR : cambié 2ewa 0+2ew);trabajar para evitar que CJam maneje ew(cortes sucesivos) en listas que son demasiado cortas. Esto hace que el código funcione para la cadena de entrada *.

Pruébalo aquí o míralo en acción:

Python 3, 129 108 98 86 bytes

Probablemente hay varias formas de jugar al golf, pero me gusta bastante que lo tengo todo en una sola línea.

Editar: ahora usando''.translate()

Editar: Muchas gracias a wnnmaw .

Editar: cambié el formato de entrada a una matriz de cadenas en lugar de una cadena separada por una nueva línea para guardar bytes. Además, en la última edición, me confundí Uy Rlo arreglé.

lambda a:'*'+"".join(('UR'[j<'/']+'D')[j>'/']for l in zip(*a)for j in l if j in'-/\\')

La entrada debe ser una matriz de cadenas. Para el ejemplo anterior, esto se parece a:

["      *-*                    ","     /   \                   ","    *     *                  ","   /       \                 ","*-*         *         *-*    ","             \       /   \   ","              *     *     *-*","               \   /         ","                *-*          "]

Sin golf:

def f(a):
    s = ''
    for c in zip(*a):           # transpose
        for d in c:             # for each letter in column c
            if e in "-/\\":     # if that letter is either -,/,\
                if e < '/':     # if < '/' (same as if == '-')
                    s += "R"
                elif e > '/':   # if > '/' (same as if == '\')
                    s += "D"
                else:           # if == '/'
                    s += "U"
        return "*" + s          # in the code we ''.join() it all together
                                # in this ungolfing, we add to an empty string

Rubí, 87 bytes

Requiere espacios finales en la entrada para que todas las líneas tengan la misma longitud.

$><<?*+$<.readlines.map(&:chars).transpose.join.gsub(/./,{?-=>:R,?/=>:U,?\\=>:D}).strip

Japt, 38 bytes 40 41 45 46 48

Guardado 2 bytes gracias a @ETHproductions

'*+U·y £Yu ?"RUD"g1+(XrS c -47 g):P} q

Si hubiera un comando de recorte, esto sería solo 38 bytes; -; agregaré una explicación cuando termine de jugar al golf. El :Pprograma no intenta ser divertido, en realidad es el programa que ignora los personajes que no son importantes.

Pruébalo en línea

Haskell, 89 bytes

import Data.List
m '/'="U"
m '-'="R"
m '\\'="D"
m _=""
('*':).(>>=(>>=m)).transpose.lines

Ejemplo de uso:

*Main> ('*':).(>>=(>>=m)).transpose.lines $ "      *-*                    \n     /   \\                   \n    *     *                  \n   /       \\                 \n*-*         *         *-*    \n             \\       /   \\   \n              *     *     *-*\n               \\   /         \n                *-*          "
"*RUURDDDDRUURDR"

*Main> ('*':).(>>=(>>=m)).transpose.lines $ "*"
"*"

Transponga la entrada y reemplace los caracteres // -/ \con cadenas simples "U"/ "R"/ "D". Todos los demás caracteres se reemplazan por cadenas vacías "", que luego desaparecen al concatenar todo. Finalmente, anteponga el asterisco *.

Mathematica, 103 bytes

"*"<>(Differences@Position[Thread@Characters@StringSplit[#,"
"],"*"][[;;,2]]/.{-2->"U",0->"R",2->"D"})&

En resumen, considerando que este es un desafío de procesamiento de cadenas.

JavaScript (ES6) 90

Una función anónima. Escanea la cadena de entrada char por char, teniendo en cuenta la posición en la línea actual. Al hacer esto, se construye una matriz de salida subsituting U D Rpara / \ -en el lugar correcto

c=>[...c].map(c=>c>'*'?t[i++]=c>'/'?'D':c<'/'?'R':'U':c<' '?i=0:++i,t=['*'],i=0)&&t.join``

Matlab, 62 bytes

r=@(s)[85-(s<14)*3-(s>59)*17,''];@(p)r(sum(p(:,2:2:end)-32))

Esto requiere que la entrada sea rectangular (el mismo número de caracteres en cada fila). P.ej

    ['      *-*                    ';    '     /   \                   ';    '    *     *                  ';    '   /       \                 ';    '*-*         *         *-*    ';    '             \       /   \   ';    '              *     *     *-*';    '               \   /         ';    '                *-*          '];

Explicación

sum(p(:,2:2:end)-32)        % exctract every second column, substract 32 (spaces->zeros) 
                            % and sum column wise (results in a vector of 3 different values)
[85-(s<14)*3-(s>59)*17,'']  % map each of the values to the corresponding value of the letter and convert back to characters