introduction

Le code Parsons n'est qu'un moyen simple de décrire les variations de hauteur d'un morceau de musique, qu'une note soit plus élevée ou plus basse que la précédente.

Même si vous craignez de vous souvenir de morceaux, vous pouvez toujours vous rappeler à peu près si une note monte ou descend, ainsi le code Parsons peut vous aider à identifier une musique à l'aide d'un moteur de recherche.

La description

Chaque variation est représentée par un seul caractère, qui est l'un des suivants:

• Rsi la note est la même que la précédente (signifie " R epeat" )
• Usi la note est plus élevée que la précédente (signifie " U p" )
• Dsi la note est plus basse que la précédente (signifie " D own" )

La note initiale est écrite comme *.

Exemple

Voici un exemple de code Parsons (début de "Ode to Joy" ):

*RUURDDDDRUURDR

Vous pouvez réellement le visualiser , comme ceci:

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

Nous appellerons cela un contour à partir de maintenant.

Les règles de dessin de tels contours sont considérées comme explicites par l'exemple ci-dessus.

Défi

Maintenant vient le vrai défi.

Écrivez un programme qui, étant donné un contour en entrée, sort son code Parsons correspondant.

On ne vous demande pas de dessiner le contour, mais l'inverse en fait.
À partir du contour, trouvez le code Parsons d'origine.

Règles

• Les règles habituelles pour le golf à code s'appliquent
• Le programme le plus court en nombre d'octets gagne
• L'entrée est un contour et la sortie doit être un code Parsons valide
• Les détails sur les espaces supplémentaires pour l'entrée ne sont pas pertinents, faites ce qui vous convient le mieux
• Vous n'êtes pas autorisé à coder en dur, d'une manière ou d'une autre, des parties de la sortie et / ou du programme en utilisant des espaces supplémentaires en raison de la règle précédente

Remarques

• Cela pourrait être utile pour tester
• Le code Parsons correspondant pour *est*
• Une chaîne vide n'est pas un contour valide
• Un code Parsons commence toujours par*

Pyth - 28 25 27 25 octets

2 byes sauvés grâce à @Jakube.

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

Essayez-le en ligne ici .

CJam, 21 octets

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

Pliez les lignes ( :) en vectorisant ( .) une opération maximale par caractère e>. Puisqu'il n'y a qu'un seul caractère non-espace dans chaque colonne, celui-ci sera le résultat, car l'espace a un code ASCII plus petit que tous les caractères non-espace imprimables.

Décochez et imprimez le premier astérisque (o, puis mappez tous les autres caractères ( 2%) à l' UDRutilisation de l'indexation modulaire.

Ancienne solution (29 octets)

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

qN/obtient les lignes d'entrée. ztranspose cette matrice de caractères. 2%laisse tomber chaque rangée impaire. '*f#trouve l'index de l'astérisque dans chaque ligne. 0+2ew);obtient toutes les paires d'indices successives. ::-calcule leurs différences, et "RDU"f=les cartes aux lettres (via l' indexation modulaire: 0 → R, 2 → U, -2 ≡ 1 → D). Le premier '*ajoute l'astérisque.

EDIT : J'ai changé 2ewpour 0+2ew);contourner CJam ne traitant pas ew(tranches successives) sur des listes trop courtes. Cela fait fonctionner le code pour la chaîne d'entrée *.

Essayez-le ici ou regardez-le en action:

Python 3, 129 108 98 86 octets

Il y a probablement plusieurs façons de jouer au golf, mais j'aime plutôt le fait que tout soit sur une seule ligne.

Modifier: maintenant en utilisant''.translate()

Edit: Merci beaucoup à wnnmaw .

Modifier: j'ai changé le format d'entrée en un tableau de chaînes au lieu d'une chaîne séparée par des sauts de ligne pour enregistrer les octets. De plus, dans le dernier montage, j'ai mélangé Uet R, donc j'ai corrigé cela.

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

L'entrée doit être un tableau de chaînes. Pour l'exemple ci-dessus, cela ressemble à ceci:

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

Non 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

Rubis, 87 octets

Nécessite des espaces de fin dans l'entrée afin que toutes les lignes aient la même longueur.

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

Japt, 38 octets 40 41 45 46 48

Enregistré 2 octets grâce à @ETHproductions

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

S'il y avait une commande de trim, cela ne serait que de 38 octets; -; ajoutera une explication lorsque j'aurai fini de jouer au golf. Ce :Pn'est pas le programme qui essaie d'être drôle, c'est en fait le programme qui ignore les caractères qui ne sont pas importants.

Essayez-le en ligne

Haskell, 89 octets

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

Exemple d'utilisation:

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

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

Transposez l'entrée et remplacez les caractères // -/ \par des chaînes singleton "U"/ "R"/ "D". Tous les autres caractères sont remplacés par des chaînes vides "", qui disparaissent plus tard en concaténant tout. Enfin, ajoutez l'astérisque *.

Mathematica, 103 octets

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

Assez court, étant donné qu'il s'agit d'un défi de traitement de chaîne.

JavaScript (ES6) 90

Une fonction anonyme. Il scanne la chaîne d'entrée char par char, en prenant en compte la position dans la ligne courante. Faire cela, il construit un tableau de sortie subsituting U D Rpour / \ -au bon endroit

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

Matlab, 62 octets

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

Cela nécessite que l'entrée soit rectangulaire (même nombre de caractères dans chaque ligne). Par exemple

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

Explication

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