Einführung

Der Parsons-Code ist nur eine einfache Möglichkeit, Tonhöhenschwankungen in einem Musikstück zu beschreiben , unabhängig davon, ob eine Note höher oder niedriger als die vorherige ist.

Selbst wenn Sie sich nicht an Melodien erinnern können, können Sie sich noch gut daran erinnern, ob eine Note hoch oder runter geht. Der Parsons-Code kann Ihnen also helfen, eine Musik mithilfe einer Suchmaschine zu identifizieren.

Beschreibung

Jede Variation wird durch ein einzelnes Zeichen dargestellt. Dies ist eines der folgenden:

• Rwenn die Note mit der vorherigen identisch ist (steht für " R epeat" )
• Uwenn die Note höher ist als die vorherige (steht für " U p" )
• Dwenn die Note niedriger ist als die vorherige (steht für " D own" )

Die Anfangsnotiz ist geschrieben als *.

Beispiel

Hier ist ein Beispiel für Parsons Code (Beginn von "Ode an die Freude" ):

*RUURDDDDRUURDR

Sie können es tatsächlich so visualisieren :

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

Wir werden das von nun an eine Kontur nennen .

Die Regeln zum Zeichnen solcher Zähler werden im obigen Beispiel als selbsterklärend angesehen .

Herausforderung

Jetzt kommt die wahre Herausforderung.

Schreiben Sie ein Programm, das bei einer Kontur als Eingabe den entsprechenden Parsons-Code ausgibt.

Sie werden nicht aufgefordert, die Kontur zu zeichnen, sondern das Gegenteil.
Suchen Sie anhand der Kontur den ursprünglichen Parsons-Code.

Regeln

• Es gelten die üblichen Regeln für das Code-Golfen
• Das kürzeste Programm in Anzahl von Bytes gewinnt
• Die Eingabe ist eine Kontur und die Ausgabe muss ein gültiger Parsons-Code sein
• Details zu zusätzlichen Leerzeichen für die Eingabe sind irrelevant. Tun Sie, was für Sie am besten funktioniert
• Aufgrund der vorherigen Regel ist es Ihnen nicht gestattet, Teile der Ausgabe und / oder des Programms auf die eine oder andere Weise mit zusätzlichen Leerzeichen fest zu codieren

Anmerkungen

• Dies kann zum Testen nützlich sein
• Der entsprechende Parsons-Code für *ist*
• Eine leere Zeichenfolge ist keine gültige Kontur
• Ein Parsons-Code beginnt immer mit*

Pyth - 28 25 27 25 Bytes

2 Byes dank @Jakube gespeichert.

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

Probieren Sie es hier online aus .

CJam, 21 Bytes

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

Falten Sie die Linien ( :), indem Sie .eine maximale Zeichenoperation vektorisieren ( ) e>. Da es in jeder Spalte nur ein Nicht-Leerzeichen gibt, ist dieses das Ergebnis, da das Leerzeichen einen kleineren ASCII-Code hat als alle druckbaren Nicht-Leerzeichen.

Entfernen Sie die Umschalttaste und drucken Sie das erste Sternchen. Ordnen Sie (odann alle 2%verbleibenden Zeichen UDRmithilfe der modularen Indizierung zu.

Alte Lösung (29 Bytes)

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

qN/Ruft Eingabezeilen ab. ztransponiert diese Zeichenmatrix.2%Lässt jede ungerade Reihe fallen. '*f#Findet den Index des Sterns in jeder Zeile. 0+2ew);Ruft alle aufeinanderfolgenden Indexpaare ab. ::-berechnet ihre Unterschiede, und "RDU"f=ordnet sie Buchstaben (über modulare Indizierung: 0 → R, 2 → U, -2 ≡ 1 → D). Das führende '*steht vor dem Sternchen.

BEARBEITEN : Ich wechselte 2ewzu 0+2ew);CJam umgehen nicht ew(aufeinanderfolgende Slices) auf Listen, die zu kurz sind. Dadurch funktioniert der Code für die Eingabezeichenfolge *.

Probieren Sie es hier aus oder sehen Sie es sich in Aktion an:

Python 3, 129 108 98 86 Bytes

Es gibt wahrscheinlich mehrere Möglichkeiten, Golf zu spielen, aber ich finde es ziemlich gut, dass ich alles auf eine Linie gebracht habe.

Bearbeiten: Jetzt mit''.translate()

Edit: Mit vielen Dank an wnnmaw .

Bearbeiten: Ich habe das Eingabeformat in ein Array von Zeichenfolgen geändert, anstatt in eine durch Zeilenumbrüche getrennte Zeichenfolge, um Bytes zu speichern. Auch in der letzten Bearbeitung habe ich verwechselt Uund das Rbehoben.

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

Die Eingabe muss ein Array von Zeichenfolgen sein. Für das obige Beispiel sieht das ungefähr so ​​aus:

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

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

Ruby, 87 Bytes

Benötigt nachgestellte Leerzeichen in der Eingabe, damit alle Zeilen gleich lang sind.

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

Japt, 38 Bytes 40 41 45 46 48

2 Bytes gespart dank @ETHproductions

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

Wenn es einen Befehl zum Trimmen gäbe, wären dies nur 38 Bytes; -; Ich werde eine Erklärung hinzufügen, wenn ich mit dem Golfen fertig bin. Das :Pist nicht das Programm, das versucht lustig zu sein, sondern das Programm, das Zeichen ignoriert, die nicht wichtig sind.

Probieren Sie es online aus

Haskell, 89 Bytes

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

Anwendungsbeispiel:

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

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

Transponieren die Eingabe und ersetzen Sie die Zeichen // -/\ mit Singletons Strings "U"/ "R"/ "D". Alle anderen Zeichen werden durch leere Zeichenfolgen ersetzt "", die später durch Verketten von allem verschwinden. Zum Schluss das Sternchen voranstellen *.

Mathematica, 103 Bytes

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

Ganz kurz, wenn man bedenkt, dass dies eine Herausforderung bei der Verarbeitung von Zeichenfolgen ist.

JavaScript (ES6) 90

Eine anonyme Funktion. Dabei wird die Eingabezeichenfolge nach Zeichen durchsucht, wobei die Position in der aktuellen Zeile berücksichtigt wird. Dadurch baut er einen Ausgang Array subsituting U D Rfür / \ -an der richtigen Stelle

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

Hierfür muss die Eingabe rechteckig sein (gleiche Anzahl von Zeichen in jeder Zeile). Z.B

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

Erläuterung

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