Esolang-Comment-Template-Generator


42

Beaucoup de personnes sur ce site utilisent des langages ésotériques , et comme ces langages sont inhabituels et difficiles à comprendre, ils écriront souvent une explication dans un certain format. Par exemple, si le code était

abcdefghijklmnop

Et cette langue utilise #pour les commentaires, ils écriraient une explication comme celle-ci:

a                #Explanation of what 'a' does
 bc              #Bc
   d             #d
    e            #Explanation of e
     fgh         #foobar
        ij       #hello world
          k      #etc.
           l     #so on
            mn   #and
              op #so forth

Je le fais souvent aussi, mais chaque fois que je le fais, j'ai l'impression que créer une mise en page de texte est vraiment désagréable et prend du temps. Je souhaite donc que vous créiez un "Générateur de modèles de commentaires" pour moi. Par exemple, si nous ignorons les commentaires, le code précédent contient ce modèle:

a                #
 bc              #
   d             #
    e            #
     fgh         #
        ij       #
          k      #
           l     #
            mn   #
              op #

Le défi:

Vous devez écrire un programme ou une fonction prenant deux chaînes en entrée et générer ce "Esolang-Comment-Template". La première entrée sera le code, mais avec des barres ( |) insérées à l'emplacement des nouvelles lignes. La deuxième entrée est ce que nous allons utiliser pour les commentaires. Donc, notre dernier exemple aurait ceci pour entrée:

"a|bc|d|e|fgh|ij|k|l|mn|op", "#"

Malheureusement, cela exclut les barres de la saisie de code, mais ce n'est pas grave. Vous pouvez supposer que le commentaire sera un seul caractère. Par souci de simplicité, le caractère de commentaire ne sera pas un obstacle. Le code saisi ne contiendra que du code ASCII imprimable et ne contiendra aucune nouvelle ligne.

J'espère que vous pourrez déduire quoi faire à partir des cas de test, mais je vais essayer de clarifier certaines choses.

Vous devez diviser le code saisi en "sections de code" sur chaque barre. Ensuite, chaque section de code est sortie sur sa propre ligne et complétée à gauche avec la longueur de tout le code précédent (sans les barres). Ensuite, chaque ligne est complétée à droite avec suffisamment d'espaces pour que les deux derniers caractères de chaque ligne soient "Un espace supplémentaire" + "Le caractère de commentaire".

Une nouvelle ligne est autorisée.

Voici un autre exemple. Pour l'entrée

"Hello|World", "/"

La première section de code est "Hello" et la seconde est "World". Donc, il devrait donner la sortie:

Hello      /
     World /

Voici quelques exemples supplémentaires:

Input:
"a|b|c|d|e|f|g", ","

Output:
a       ,
 b      ,
  c     ,
   d    ,
    e   ,
     f  ,
      g ,

Input:
"abcdefg", ":"

Output:
abcdefg :

Input:
"4|8|15|16|23|42", "%"

Output:
4          %
 8         %
  15       %
    16     %
      23   %
        42 %

Input:
"E|ac|h s|ecti|on is| one c|haracte|r longer| than the| last!", "!"

Output:
E                                                   !
 ac                                                 !
   h s                                              !
      ecti                                          !
          on is                                     !
                one c                               !
                     haracte                        !
                            r longer                !
                                     than the       !
                                              last! !

Input:
"This|Code|has||empty||sections", "@"

Output:
This                     @
    Code                 @
        has              @
                         @
           empty         @
                         @
                sections @

Règles:

Vous pouvez prendre ces entrées et sorties dans n’importe quel format raisonnable. Par exemple, lire / écrire un fichier, STDIN / STOUT, arguments de fonction / renvoyer, etc. Comme d’habitude, il s’agit de , essayez donc de rendre votre code le plus court possible et vous gagnerez si vous pouvez obtenir la solution la plus courte. dans ta langue! Je choisirai également la solution la plus courte en tant que gagnant. Les échappatoires standard sont interdites.



Les espaces en fin de liste sont-ils autorisés?
Titus

30
Prochaine étape: une représentation 3D pour les langages 2D
Aaron

3
Un bonus si vous parvenez à le faire sans utiliser le |personnage serait bien, alors vous pouvez vous expliquer
WorldSEnder

Le caractère de commentaire peut-il être un bar ( |)?
Ton Hospel

Réponses:



9

Retina , 35 à 34 octets

Le nombre d'octets suppose un codage ISO 8859-1.

\|
·$'¶$`±
T0-2`·±|p`___ `.+±.|·.+

Les deux chaînes d'entrée sont séparées par un espace (ce qui est sans ambiguïté puisque nous savons que le délimiteur de commentaire est toujours un caractère unique).

Essayez-le en ligne!


1
Pourquoi avez-vous besoin d'un espace pour délimiter les chaînes? Puisqu'il s'agit d'un seul personnage, il pourrait s'agir du dernier.
Adám

1
@ Adám je le réutilise comme séparateur d'espace dans la sortie finale.
Martin Ender

9

Java 10, 189 159 octets

s->c->{var r="";int p=0,i;for(var a:s.split("\\|")){for(i=p;i-->0;r+=" ");r+=a;for(p+=a.length();i++<s.replace("|","").length()-p;r+=" ");r+=c+"\n";}return r;}

-30 octets convertissant Java 7 en Java 10 et optimisant les boucles.

Essayez-le en ligne.

Explication:

s->c->{                     // Method with String & char parameters and String return-type
  var r="";                 //  Result-String, starting empty
  int p=0,                  //  Position-integer, starting at 0
      i;                    //  Index integer
  for(var a:s.split("\\|")){//  Loop over the parts split by "|"
    for(i=p;i-->0;r+=" ");  //   Add `p` amount of spaces to the result-String
    r+=a;                   //   Add the current part to the result-String
    for(p+=a.length();      //   Add the length of the current part to the position-integer
        i++<s.replace("|","").length()-p;r+=" ");
                            //   Add the row's trailing spaces to the result-String
    r+=c+"\n";}             //   Add the character and a new-line to the result-String
  return r;}                //  Return the result-String


4

JavaScript (ES6), 92 octets

f=
(s,c)=>s.split`|`.map((_,i,a)=>a.map((e,j)=>i-j?e.replace(/./g,` `):e).join``+` `+c).join`
`
;
<div oninput=o.textContent=f(s.value,c.value)><input id=s placeholder=Code><input id=c size=1 maxlength=1 value=#><pre id=o>


4

GNU sed (85 + 1 pour -r) 86

:s;h;:;s,\|( *)[^ \|](.),|\1 \2,;t;s,\|,,g
p;g;:l;s,^( *)[^ \|],\1 ,;tl;s,\|,,;/\S/bs

Les entrées sont des chaînes séparées par un espace.

Tests:
input.txt:

a|b|c|d|e|f|g ,
abcdefg :
4|8|15|16|23|42 %
E|ac|h s|ecti|on is| one c|haracte|r longer| than the| last! !
This|Code|has||empty||sections @

Sortie:

$ cat input.txt | sed -rf template
a       ,
 b      ,
  c     ,
   d    ,
    e   ,
     f  ,
      g ,

abcdefg :

4          %
 8         %
  15       %
    16     %
      23   %
        42 %

E                                                   !
 ac                                                 !
   h s                                              !
      ecti                                          !
          on is                                     !
                one c                               !
                     haracte                        !
                            r longer                !
                                     than the       !
                                              last! !

This                     @
    Code                 @
        has              @
                         @
           empty         @
                         @
                sections @

L’étiquette sans nom :est une fonctionnalité / bogue GNU sed et \Sj’estime être une extension, alors peut-être que le titre devrait l'être GNU sed. Autre que cela, excellent code.
Seshoumara

@seshoumara Merci!
Riley

3

Haskell, 139 135 octets

s#p=j$foldl g("",0)s where g(a,n)c|c=='|'=(j(a,n)++"\n"++q n,n)|1>0=(a++[c],n+1);q m=' '<$[1..m];j(a,n)=a++q(sum[1|c<-s,c/='|']-n+1)++p

Sauvegardé 4 octets en insérant une définition.

Ungolfed:

template :: String -> String -> String
template code comment = format $ foldl g ("", 0) code
    where g (acc, n) c
            | c == '|' = (format (acc, n) ++ "\n" ++ spaces n, n)
            | otherwise = (acc ++ [c], n+1)
          l = length $ filter (/= '|') code
          spaces n = replicate n ' '
          format (acc, n) = acc ++ spaces (l-n+1) ++ comment

3

Groovy, 120 113 111 octets

def m(s,c){s.split(/\|/).inject(0,{e,t->println((' '*e+t).padRight(s.replace('|','').size()+1)+c);e+t.size()})}

non golfé *

def m(s,c){
  s.split(/\|/).inject(0, { e, t ->
    println((' '*e+t).padRight(s.replace('|','').size())+' '+c)
    e+t.size()
  })
}

(Premier brouillon avec 120 octets)

def m(s,c){def l=0;s.split(/\|/).collect{l+=it.size();it.padLeft(l).padRight(s.replace('|','').size())+' '+c}.join('\n')}

non golfé *

def m(s,c){
  def l=0 // minimized version needs a semicolon here
  s.split(/\|/).collect{
    l+=it.size() // minimized version needs a semicolon here
    it.padLeft(l).padRight(s.replace('|','').size())+' '+c
  }.join('\n')
}

Des tests

%> m('a|bc|d|e|fgh|ij|k|l|mn|op', '#')
a                #
 bc              #
   d             #
    e            #
     fgh         #
        ij       #
          k      #
           l     #
            mn   #
              op #

%> m('Hello|World', '/')
Hello      /
     World /

%> m('a|b|c|d|e|f|g', ',')
a       ,
 b      ,
  c     ,
   d    ,
    e   ,
     f  ,
      g ,

%> m('abcdefg', ':')
abcdefg :

%> m('4|8|15|16|23|42', '%')
4          %
 8         %
  15       %
    16     %
      23   %
        42 %

%> m('E|ac|h s|ecti|on is| one c|haracte|r longer| than the| last!', '!')
E                                                   !
 ac                                                 !
   h s                                              !
      ecti                                          !
          on is                                     !
                one c                               !
                     haracte                        !
                            r longer                !
                                     than the       !
                                              last! !

%> m('This|Code|has||empty||sections', '@')
This                     @
    Code                 @
        has              @
                         @
           empty         @
                         @
                sections @

Que diriez-vous.padRight(s.replace('|','').size()+1)+c)
AmazingDreams

bonne idée! Je vous remercie! sauvé encore 2 caractères!
Norganos

3

Python 2, 125 124 132 octets

-1 octet grâce à @TuukkaX (manque de jouer au golf dans l'espace i, v)

def g(s,c):x=s.split('|');print((' '+c+'\n').join(' '*len(''.join(x[:i]))+v+' '*len(''.join(x[i+1:]))for i,v in enumerate(x))+' '+c)

Tous les cas de test sur ideone


1
Vous êtes censé utiliser ccomme caractère de commentaire, pas #.
Oliver Ni

@OliverNi - euh, c'était un succès pour le code dans sa forme actuelle.
Jonathan Allan

3

Python 2, 107 105 102 99 octets

Testé avec tous les cas de test ci-dessus

EDIT Golfed off 2 octets en changeant d = a.split ("|"); i = 0 à d, i = a.split ("|"), 0 Je ne sais pas comment j'ai raté celui-ci. Merci @ Oliver Ni

Encore 3 octets partis. Merci encore.

La suggestion de @ Jonathan économise en réalité 3 octets et la ramène à la magie 99. Merci.

def c(a,b):
 d,i=a.split("|"),0
 for e in d:j=i+len(e);print" "*i+e+" "*(len("".join(d))-j+1)+b;i=j

1
Il a joué un autre octet au golf
Oliver Ni

3
Hey @OliverNi, il est apprécié de fournir des astuces pour jouer au golf, mais le code d’édition n’est pas vraiment approprié sur ce site ( source ), aussi j’ai annulé votre édition. N'hésitez pas à poster ces astuces sous forme de commentaire! Je suis sûr que le PO l'apprécierait, mais ce devrait être à eux de le tester et de choisir s'ils veulent l'utiliser.
DJMcMayhem

1
Merci à vous deux. Tout d'abord, @Oliver pour avoir pris l'intérêt et le temps nécessaire pour améliorer mon humble effort et, deuxièmement, DJMcMayhem pour avoir clarifié ce que je croyais être le cas, mais je n'avais pas eu l'occasion de commenter. Oliver - merci encore et n'hésitez pas à poster les modifications sous forme de commentaires afin que je puisse tirer des leçons de votre expérience du golf.
ElPedro

1
Vous pouvez supprimer les parenthèses autour " "*ide ave 2 octets
Oliver Ni

1
Vous pouvez également définir une variable pour len(e)aimer for e in d:z=len(e)....enregistrer un octet, car il est utilisé deux fois
Oliver Ni

3

05AB1E , 29 38 31 29 octets

'|„ǝʒ:'ǝ¡'ʒмεD®>úsg®+©s}.Bεð²J,

Peut certainement être golfed, mais au moins son travail maintenant ..
+9 octets car ¡(split) supprime les éléments vides automatiquement, donc je devais ajouter '|„ǝʒ:'ǝ¡'ʒм..
-2 octets grâce à @MagicOctopusUrn en changeant '|„ǝʒ:'ǝ¡'ʒмà '|¶:.BεðÜ}(solution actuelle ne fonctionne pas éléments avec des espaces de fin, mais je suppose que cela est autorisé selon les cas de test).

Essayez-le en ligne.

Explication:

'|¶:           # Take the first input, and replace every "|" with "¶"
               #  i.e. "abc|d|e||fg" → "abc¶d¶e¶¶fg" (¶ are new-lines in 05AB1E)
    .B         # Box all the items (appending trailing whitespace to make it a rectangle)
               #  i.e. "abc¶d¶e¶¶fg" → ['abc','d  ','e  ','   ','fg ']
      εðÜ}     # Remove all trailing spaces from each item
               #  i.e. ['abc','d  ','e  ','   ','fg '] → ['abc','d,'e','','fg']
               #  NOTE: `'|¡` would have resulted in ['abc','d','e','fd'], hence the use of
               #        Box which implicitly splits on new-lines to keep empty items
ε              # For-each:
 D             #  Duplicate the current item
  ®>ú          #  Prepend global_variable + 1 amount of spaces
               #  (+1 because the global_variable is -1 by default)
               #   i.e. "e" and 3+1 → "    e"
 sg            #  Swap so the duplicated item is at the top, and take its length
   ®+          #  Sum it with the global_variable
               #   i.e. "e" (→ 1) and 4 → 5
     ©         #  And store it as new global_variable
      s        #  Then swap so the space appended item is at the end again
       }       # And end the for-each loop
.B             # Box all the items (appending the appropriate amount of spaces)
               #  i.e. ['abc','   d','    e','     ','     fg']
               #   → ['abc    ','   d   ','    e  ','       ','     fg']
ε              # For-each again:
 ð             #  A space character
  I            #  The second input-character
   J           #  Join both together with the current item
    ,          #  And print the current row with trailing new-line

Ceci est invalide si le code devait contenir ǝʒ. '|¶:.Bpourrait travailler tho.
Urne magique Octopus

@MagicOctopusUrn La description du défi indique " L'entrée de code ne contiendra que de l'ASCII imprimable et ne contiendra pas de saut de ligne. " De plus, quelle partie du code doit être remplacée par '|¶:.B?
Kevin Cruijssen

Je pensais que ce serait une scission plus courte, mais cela ne fonctionnerait pas avec votre code actuel, il vous suffirait de réduire l'excès. OU simplement ignorer l'excès et .Bune seconde fois après avoir ajouté les espaces précédents.
Urne magique Octopus

@MagicOctopusUrn Cela permettra peut-être de sauver quelques octets, car mon travail actuel est assez long, mais il sera plus difficile de calculer la quantité d'espaces précédents avec les espaces après le .Bprésent.
Kevin Cruijssen

1
'|¶:.BεðÜ}εD®>úsg®+©s}.BεðIJ,? 29 octets. Retour à l'itération 1 :). .Bse scinde en nouvelles lignes, une caractéristique que peu de gens connaissent. C'est le seul moyen que je connaisse de garder des éléments vides. Je demanderais cela comme une fonctionnalité. devrait signifier scinder, mais garder les éléments vides ..
Urne Octopus Magique

2

PowerShell v2 +, 103 à 99 octets

param($a,$b)$a-split'\|'|%{" "*$l+$_+" "*(($a-replace'\|').length+1-$_.length-$l)+$b;$l+=$_.Length}

Prend les entrées sous forme de deux chaînes, -splits la première sur un tube littéral (puisque split utilise la syntaxe regex) et insère les éléments dans une boucle |%{...}.

À chaque itération, nous construisons une chaîne comme étant un nombre d'espaces définis par $lconcaténation avec l'élément en cours. Pour la première boucle, $linitialise à $null, qui est évalué ici comme 0.

Cette chaîne est encore concaténé avec un autre nombre d'espaces (définis par combien de temps $aserait si nous -replaced tous les tuyaux avec rien, plus 1pour le rembourrage supplémentaire entre le code et les commentaires, moins le .lengthde l'élément courant, moins ce $lqui est combien de places nous rembourrés laissé sur cette itération), concaténé avec notre caractère de commentaire $b. Cela reste sur le pipeline.

Nous mettons ensuite à jour $lpour la prochaine itération.

Les chaînes résultantes sont toutes laissées sur le pipeline et la sortie via implicite Write-Outputse produit lors de l'exécution du programme, avec une nouvelle ligne entre elles par défaut.

Exemples

PS C:\Tools\Scripts\golfing> .\esolang-comment-template-generator.ps1 "This|Code|has||empty||sections" "@"
This                     @
    Code                 @
        has              @
                         @
           empty         @
                         @
                sections @

PS C:\Tools\Scripts\golfing> .\esolang-comment-template-generator.ps1 "a|bc|def|ghi|h" "|"
a          |
 bc        |
   def     |
      ghi  |
         h |

2

Vim, 39 38 frappes

-1 octet grâce à DJMcMayhem

Attend en entrée un tampon (par exemple, un fichier) dont le premier caractère est le délimiteur de commentaire, suivi du code, par exemple #foo|bar|baz.

"cxqaf|m`Yp<Ctrl+o>v$r jv0r x@aq@a$p<Ctrl+v>gg$C <Ctrl+r>c<Esc>

Explication

(" _" désigne un espace littéral.)

"cx          " Delete the first character (the comment delimiter) and store in register 'c'
qa           " Start recording macro 'a'
f|m`         " Advance to the first '|' on the line and set mark
Yp<Ctrl+o>   " Duplicate this line and return to mark
v$r_         " Replace everything after the cursor on this line (inclusive) with spaces
jv0r_x       " Go down a line and replace everything before the cursor on this line (inclusive) with
             "   spaces, then delete one space
@a           " Call macro recursively
q@a          " Stop recording and immediately call the macro
$p           " Paste the deleted space at the end of the last line
<Ctrl+v>gg$       " Highlight the column where the comment delimiters will go and all trailing spaces
C_<Ctrl+r>c<Esc>  " Replace the highlighted text on each line with a space and the contents of
                  "   register 'c' (the comment delimiter)

1
: D vote toujours positif vim! Je pense que vous pourriez prendre un octet hors tension si vous changez mmde m`puis changer `mà<C-o>
DJMcMayhem

@DJMcMayhem Merci! J'aime jouer au golf à Vim parce que j'apprends toujours quelque chose sur un outil que j'utilise tous les jours.
Jordanie

2

Floroïde - 94 octets

Ah(a,b):c=a.fn("|");z(" "+b+"\n".y(' '*Z("".y(c[:j]))+l+" "*Z("".y(c[j+1:]))Kj,lIai(c))+' '+b)

Utilise une approche similaire à la solution @ JonathanAllan s Python.

Testcases

Call: h("a|bc|d|e|fgh|ij|k|l|mn|op", "#")
Output: 
a                #
 bc              #
   d             #
    e            #
     fgh         #
        ij       #
          k      #
           l     #
            mn   #
              op #

2

C # 176 167 154 octets

string f(string s,char x){var c=s.Split('|');var d="";int i=0;foreach(var b in c)d+=b.PadLeft(i+=b.Length).PadRight(s.Length+2-c.Length)+x+"\n";return d;}

Non Golfé

string f(string s, char x)
{
    var c = s.Split('|');
    var d = "";
    int i = 0;
    foreach (var b in c)
        d += b.PadLeft(i += b.Length).PadRight(s.Length + 2 - c.Length) + x + "\n";
    return d;
}

Une solution LINQ aurait été de 146 mais il fallait la using System.Linq;ramener à 164:

string f(string s,char x){var c=s.Split('|');int i=0;return c.Aggregate("",(g,b)=>g+b.PadLeft(i+=b.Length).PadRight(s.Length+2-c.Length)+x+"\n");}

Anciennes solutions:

167 octets:

string f(string s,char x){var c=s.Split('|');var d="";int i=0;foreach(var b in c){d+=b.PadLeft(i+b.Length).PadRight(s.Length+2-c.Length)+x+"\n";i+=b.Length;}return d;}

176 octets en interpolation de chaîne

string f(string s,char x){var c=s.Split('|');var d="";int i=0;foreach(var b in c){d+=string.Format($"{{1,{i}}}{{0,-{s.Length+2-c.Length-i}}}{x}\n",b,"");i+=b.Length;}return d;}

1

PHP, 120 117 116 110 109 octets

foreach($a=split('\|',$argv[1])as$i=>$t){$c=preg_replace('#.#',' ',$a);$c[$i]=$t;echo join($c)," $argv[2]
";}

ou

foreach($a=split('\|',$argv[1])as$t){$c=preg_replace('#.#',' ',$a);$c[$i++|0]=$t;echo join($c)," $argv[2]
";}

1

MATL , 33 31 octets

'\|'0'|'hYXo8M&YbY:&YdtaZ)0ihYc

Essayez-le en ligne!

Explication

La fonction intégrée Yd( blkdiag), qui construit une matrice bloc-diagonale à partir de ses entrées, effectue la majeure partie du travail. Les valeurs de remplissage dans la matrice sont 0 et le caractère 0 est traité comme un espace pour l'affichage. Le code serait simplement scindé |, construit une matrice à partir des blocs résultants, converti en caractères et ajouté deux colonnes avec un espace et un symbole de commentaire.

Cependant, la possibilité de sections vides dans la chaîne d'entrée complique le problème: le bloc résultant serait vide et ne s'afficherait donc pas dans la matrice résultante.

Pour résoudre ce problème, nous introduisons un caractère 0 avant chaque caractère |, ainsi aucun bloc ne sera vide; puis, dans la matrice de caractères obtenue, nous supprimons les colonnes formées par le caractère 0 uniquement. Une section de code non vide aura un caractère imprimable ASCII et les colonnes qu'elle contient survivront. Une section vide contribuera à une ligne, mais n'introduira pas de colonne supplémentaire.

'\|'    % Push this string: source for regexp matching. It's just | escaped
0'|'h   % Push a string formed by char 0 followed by | (no escaping needed)
YX      % Input string implicitly. Replace first of the above string by the second
o       % Convert from chars to code points. Gives a numeric vector
8M      % Push '|' again
&Yb     % Split numeric vector at occurences of | (the latter is automatically
        % converted  to its code point). This gives a cell array of numeric vectors
Y:      % Unbox cell array: pushes the numeric vectors it contains
&Yd     % Form a block-diagonal matrix from those vectors
ta      % Duplicate. Compute vector that equals true for columns that have some
        % nonzero value
Z)      % Used that as a logical index (mask) for the columns of the matrix.
        % This removes columns that contain only zeros
0ih     % Input comment symbol and prepend char 0 (which will be displayed as space)
Yc      % Append that to each row of the matrix. The matrix is automatically 
        % converted from code points to chars
        % Display implicitly

1
Je suis vaguement déçu que vous n'ayez pas mis votre explication dans le format mentionné dans le PO
Aléatoire832 9/09/16

1
@ Random832 Je n'utilise pas souvent ce format. Il occupe beaucoup d'espace et laisse peu de place aux explications.
Luis Mendo

Pourquoi l'évasion est-elle nécessaire dans la première chaîne?
Conor O'Brien

@ ConorO'Brien Bonne question. Je ne sais jamais lequel / quand des symboles spéciaux doivent s'échapper et lesquels / quand non. Dans ce cas, |( correspond à la sous-expression avant ou après le| ) en a besoin, du moins dans le moteur d'expressions rationnelles Matlab / Octave
Luis Mendo le

1

Pyth, 30 octets

VJcE\|s[*ZdN*h--lsJZlNdQ)=+ZlN

ou

jm+dQ.t.t+MC,.u*l+NYdJc+Ed\|kJ

Les deux sont des programmes complets qui prennent une entrée sur STDIN de la chaîne de commentaire, puis la chaîne de programme, séparée par une nouvelle ligne.

Essayez la première version en ligne

Essayez la deuxième version en ligne

Comment ils travaillent

VJcE\|s[*ZdN*h--lsJZlNdQ)=+ZlN  Program. Inputs: E, Q
  cE\|                          Split E on "|"
 J                              Assign to J
                                Implicit Z=0
V                               For N in that:
       [                )        Create a list with elements:
        *Zd                       Z spaces
           N                      N
               -lsJZ              len(concatenate(J))-Z
              -     lN             -len(N)
             h                     +1
            *         d            spaces
                       Q          Q
      s                          Concatenate the list
                                 Implicitly print
                        =+ZlN    Z=Z+len(N)

jm+dQ.t.t+MC,.u*l+NYdJc+Ed\|kJ  Program. Inputs: E, Q
                       +Ed      Add a trailing space to E
                      c   \|    Split that on "|"
                     J          Assign to J
             .u                 Cumulatively reduce J with:
                            k    starting value empty string and
                                 function N, Y ->
                l+NY              len(N+Y)
               *    d             spaces
            ,                J  Two-element list of that and J
           C                    Transpose
         +M                     Map concatenation over that
       .t                       Transpose, padding with spaces
     .t                         Transpose again
 m+dQ                           Map concatenation with Q over that
j                               Join on newlines
                                Implicitly print

1

Dyalog APL 16.0 (non compétitif), 43 37 octets

Invite le caractère de commentaire, puis le code.

↑(↓↑((-(⍸'|'∘=),≢)↑¨'|'∘≠⊆⊢)⍞),¨⊂¯2↑⍞

Non compétitif car la version 16.0 est plus récente que ce défi.


Comment le dyalog APL est-il toujours en concurrence? Est-il toujours en développement?
DJMcMayhem

@DJMcMayhem Oui. Je travaille pour Dyalog et j'ai déjà eu accès à 16.0 avant même que 15.0 ne soit disponible. La sortie de la version 16.0 est prévue pour le premier trimestre 2017.
Adám

Comment cela marche-t-il?
Conor O'Brien

1

Perl, 63 octets

Comprend +5 pour -Xpi

Exécuter avec une entrée sur STDIN et un caractère de commentaire après -i:

perl -Xpi% esolang.pl <<< "Ab|Cd||ef"

esolang.pl:

s/
/|/;s%(.*?)\|%$"x$`=~y/|//c.$1.$"x$'=~y/|//c." $^I
"%eg

Solution simple et totalement ennuyeuse


1

Turtlèd , 35 bytes (non compétitif)

Prend une entrée, le dernier caractère est le caractère de commentaire. Ne fonctionne pas avec le caractère de commentaire comme espace, mais je suppose que ce n'est pas nécessaire.

!' [*.+(|' dl)r_]' r[*+.(|u)_][ .d]

Explication:

!                                  take input into string variable
 '                                 write space over current cell
   [*           ]                  while cell is not *
     .+                            write pointed char of string, stringpointer+1 (starts 0)
       (|    )                     if current cell is |
         ' dl                      write space (over |), move down, left
              r_                   move right, write * if pointed char is
                                   last char, else space

                 ' r               write space, move right
                    [*       ]     while cell is not *
                      +.           increment pointer and write pointed char
                        (|u)       if cell is |, move up
                            _      write * if the pointed char is the last char

                              [   ] while cell is not space
                                .d  write the pointed char from string, move down 


0

Scala, 123 octets

def?(i:String,c:String)={var b=0
i.split('|').map{s=>println(" "*b+s+" "*(i.replace("|","").size-b-s.size+1)+c)
b+=s.size}}

Code de test + sortie:

?("a|b|c|d|e|f|g", ",")
a       ,
 b      ,
  c     ,
   d    ,
    e   ,
     f  ,
      g ,

?("abcdefg", ":")
abcdefg :

?("4|8|15|16|23|42", "%")
4          %
 8         %
  15       %
    16     %
      23   %
        42 %

?("E|ac|h s|ecti|on is| one c|haracte|r longer| than the| last!", "!")
E                                                   !
 ac                                                 !
   h s                                              !
      ecti                                          !
          on is                                     !
                one c                               !
                     haracte                        !
                            r longer                !
                                     than the       !
                                              last! !

?("This|Code|has||empty||sections", "@")
This                     @
    Code                 @
        has              @
                         @
           empty         @
                         @
                sections @

0

Ruby, 96 à 80 octets

->s,c{s.gsub(/(^|\|)([^|]*)/){" "*$`.count(t="^|")+$2+" "*(1+$'.count(t))+c+$/}}

Voir sur eval.in: https://eval.in/639012

Je devrais vraiment apprendre la rétine.


0

Gelée , 41 octets

Cela semble avoir beaucoup trop progressé, et probablement trop de liens ...

ṫø⁹‘‘µFL‘⁶ẋ
‘ị
ḣFL⁶ẋ$;ç@;1ŀ
J’ç@€
ṣ”|Ç;€Y

Testez-le sur TryItOnline

Comment?

ṫø⁹‘‘µFL‘⁶ẋ  - link 1: get the spaces for after the code, dyadic(split string, index)
 ø           - next chain as a nilad
  ⁹‘‘        - right argument incremented twice (the index we actually want)
ṫ            - tail (get the rest of the split string)
     µ       - next chain as a monad
      FL‘    - flatten, get its length and increment
         ⁶   - a space character " "
          ẋ  - repeat the space character that many times

‘ị           - Link 2: get the code for a line dyadic(index, split string)
‘            - increment the index
 ị           - retrieve the string at that index

ḣFL⁶ẋ$;ç@;1ŀ - Link 3: get the code and join with spaces, dyadic (index, split string)
ḣ            - head: split string[index:]
 FL          - flatten and get its length
     $       - previous two atoms as a monad
   ⁶         - a space character, " "
    ẋ        - repeat the space that many times
      ;      - concatenate with
       ç@    - the result of the previous link (the code) - reverse inputs
         ;   - concatenate with
          1ŀ - the result of Link 1 (the spaces after the code)

J’ç@€        - Link 3: a for loop, monadic(split string)
J’           - [0,...,Len(split string)-1]
  ç@€        - the result of the previous link, with revered inputs, for each

ṣ”|Ç;€Y      - Main Link: dyadic(code string, comment character)
ṣ”|          - split on "|"
   Ç         - the result of the previous link
    ;€       - concatenate each with the comment character
      Y      - join with line feeds
             - implicit print

0

CJam, 32 octets

l'|/_s,)L@{1$,S*\+}%@f{Se]}lN+f+

Explication

l                                  get code string
 '|/                               split into code parts
    _s,)                           length of all the parts +1
        L@{1$,S*\+}%               left pad spaces to every part for the length of the previous parts
                    @f{Se]}        right pad spaces
                           lN+f+   add comment character and newline

Essayez-le en ligne


0

GolfScript, 85 octets

{(;);}:r;", "%(r\(r n+:c;;.,\'|'%.,@\-)):l;0:m;{.,0>}{" "m*\(.,m+:m l\-" "\*+c@}while

Essayez-le en ligne

Mise à jour 2017 - GolfScript - 71 octets

', '/~~:c;~1/.,\.{'|'=},,@\-):l;['|']/0:i;{.,i+:i l i-' '*c+\' '*"
"\}/

Explication

', '/~~:c;~1/        # Parses input
.,\.{'|'=},,@\-):l;  # Computes string length without '|'
['|']/               # Splits the array
0:i;                 # Counter
{.,                  # Length of the substring
i+:i                 # Counter update
l i-' '*c+\          # Adds spaces after the substring 
' '*"\n"\            # Adds spaces before the next substring
}/                   # ...For each substring

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.