introduzione

Il codice Parsons è solo un modo semplice per descrivere le variazioni di intonazione in un brano musicale, indipendentemente dal fatto che una nota sia più alta o più bassa della precedente.

Anche se fai schifo nel ricordare i brani, puoi ancora ricordare se una nota sale o scende, quindi il codice Parsons può aiutarti a identificare una musica usando un motore di ricerca.

Descrizione

Ogni variazione è rappresentata da un singolo carattere, che è uno dei seguenti:

• Rse la nota è la stessa della precedente (sta per " R epeat" )
• Use la nota è superiore alla precedente (sta per " U p" )
• Dse la nota è inferiore alla precedente (sta per " D own" )

La nota iniziale è scritta come *.

Esempio

Ecco un esempio del codice Parsons (inizio di "Ode to Joy" ):

*RUURDDDDRUURDR

Puoi effettivamente visualizzarlo , in questo modo:

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

Lo chiameremo un contorno da ora in poi.

Le regole per disegnare tali consiglieri sono considerate autoesplicate dall'esempio sopra.

Sfida

Ora arriva la vera sfida.

Scrivi un programma che, dato un contorno come input, emetta il suo corrispondente codice Parsons.

Non ti viene chiesto di disegnare il contorno, ma in realtà il contrario.
Dal contorno, trova il codice Parsons originale.

Regole

• Si applicano le solite regole per il golf del codice
• Vince il programma più breve in numero di byte
• L'input è un contorno e l'output deve essere un codice Parsons valido
• I dettagli sugli spazi bianchi extra per l'input sono irrilevanti, fai tutto ciò che funziona meglio per te
• Non è consentito codificare, in un modo o nell'altro, parti dell'output e / o del programma utilizzando spazi bianchi extra a causa della regola precedente

Gli appunti

• Questo potrebbe essere utile per i test
• Il codice Parsons corrispondente per *è*
• Una stringa vuota non è un contorno valido
• Un codice Parsons inizia sempre con*

Pyth - 28 25 27 25 byte

2 ciao salvati grazie a @Jakube.

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

Provalo online qui .

CJam, 21 byte

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

Piega le linee ( :) vettorializzando ( .) un'operazione massima in termini di caratteri e>. Poiché esiste un solo carattere non spaziale in ogni colonna, questo sarà il risultato, poiché lo spazio ha un codice ASCII più piccolo di tutti i caratteri non spaziali stampabili.

Deseleziona e stampa il primo asterisco (o, quindi mappa ogni altro 2%carattere rimanente ( ) UDRusando l'indicizzazione modulare.

Vecchia soluzione (29 byte)

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

qN/ottiene linee di input. ztraspone questa matrice di caratteri. 2%lascia cadere ogni riga dispari. '*f#trova l'indice dell'asterisco in ogni riga. 0+2ew);ottiene tutte le coppie successive di indici. ::-calcola le differenze e "RDU"f=le mappe di lettere (via indicizzazione modulare: 0 → R, 2 → U, -2 ≡ 1 → D). Il leader '*antepone l'asterisco.

EDIT : ho cambiato 2ewper 0+2ew);aggirare CJam non gestendo ew(sezioni successive) su elenchi troppo corti. Questo fa funzionare il codice per la stringa di input *.

Provalo qui o guardalo in azione:

Python 3, 129 108 98 86 86 byte

Probabilmente ci sono diversi modi per giocare a golf, ma mi piace piuttosto che ho ottenuto tutto in una riga.

Modifica: ora utilizzando''.translate()

Modifica: grazie mille a wnnmaw .

Modifica: ho cambiato il formato di input in un array di stringhe anziché in una stringa separata da nuova riga per salvare byte. Inoltre, nell'ultima modifica, ho confuso Ue R, quindi, l'ho risolto.

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

L'input deve essere una matrice di stringhe. Per l'esempio sopra, questo assomiglia a:

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

Ungolfed:

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

Rubino, 87 byte

Richiede spazi finali nell'input in modo che tutte le linee abbiano la stessa lunghezza.

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

Japt, 38 byte 40 41 45 46 48

Salvato 2 byte grazie a @ETHproductions

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

Se ci fosse un comando trim questo sarebbe solo 38 byte; -; aggiungerò una spiegazione quando avrò finito di giocare a golf. Non :Pè il programma che cerca di essere divertente, in realtà è il programma che ignora i personaggi che non sono importanti.

Provalo online

Haskell, 89 byte

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

Esempio di utilizzo:

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

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

Trasporre l'input e sostituire i caratteri // -/ \con stringhe singleton "U"/ "R"/ "D". Tutti gli altri caratteri vengono sostituiti da stringhe vuote "", che in seguito scompaiono concatenando tutto. Infine, anteporre l'asterisco *.

Mathematica, 103 byte

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

Abbastanza breve, considerando che si tratta di una sfida di elaborazione delle stringhe.

JavaScript (ES6) 90

Una funzione anonima. Analizza la stringa di input char con char, prendendo in considerazione la posizione nella riga corrente. Facendo questo, si costruisce una matrice di uscita subsituting U D Rper / \ -al posto giusto

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

Matlab, 62 byte

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

Ciò richiede che l'input sia rettangolare (stesso numero di caratteri in ogni riga). Per esempio

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

Spiegazione

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