Esolang-Comment-Template-Generator


42

Mucha gente en este sitio usa idiomas esotéricos , y dado que estos idiomas son inusuales y difíciles de entender, con frecuencia escriben una explicación en un formato determinado. Por ejemplo, si el código era

abcdefghijklmnop

Y este lenguaje usa #para comentarios, escribirían una explicación como esta:

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

Con frecuencia también hago esto, pero cada vez que hago esto, siento que crear el diseño del texto es realmente desagradable y requiere mucho tiempo. Así que quiero que crees un "Esolang-Comment-Template-Generator" para mí. Por ejemplo, si ignoramos los comentarios, el código anterior tiene esta plantilla:

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

El reto:

Debe escribir un programa o función que tome dos cadenas como entrada, y genere este "Esolang-Comment-Template". La primera entrada será el código, pero con barras ( |) insertadas donde van las nuevas líneas. La segunda entrada es la que usaremos para los comentarios. Entonces nuestro último ejemplo tendría esto como entrada:

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

Desafortunadamente, esto excluye a las barras de ser parte de la entrada del código, pero está bien. Puede suponer que la entrada de comentarios será un solo carácter. Por simplicidad, el comentario char no será un bar. La entrada de código solo contendrá ASCII imprimible y no contendrá ninguna línea nueva.

Espero que pueda inferir qué hacer con los casos de prueba, pero intentaré aclarar algunas cosas.

Debe dividir la entrada de código en "secciones de código" en cada barra. Luego, cada sección de código se genera en su propia línea y se rellena a la izquierda con la longitud de todo el código anterior (sin incluir las barras). Luego, cada línea se rellena a la derecha con suficientes espacios para que los dos últimos caracteres de cada línea sean "Un espacio adicional" + "El carácter de comentario".

Se permite una nueva línea final.

Aquí hay otro ejemplo. Para la entrada

"Hello|World", "/"

La primera sección del código es "Hola" y la segunda es "Mundo". Entonces debería dar el resultado:

Hello      /
     World /

Aquí hay algunas muestras más:

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 @

Reglas:

Puede tomar estas entradas y salidas en cualquier formato razonable. Por ejemplo, leer / escribir un archivo, STDIN / STOUT, argumentos de función / valor de retorno, etc. Como de costumbre, esto es , así que trate de hacer su código lo más corto posible y ganará si puede obtener la solución más corta ¡en tu idioma! También seleccionaré la solución más corta como el ganador general. Las lagunas estándar están prohibidas.



¿Se permiten espacios en blanco finales?
Tito

30
Siguiente paso: una representación 3D para lenguajes 2D
Aaron

3
Un bono si logra hacerlo sin utilizar el |carácter sería bueno, por lo que puede explicarse
WorldSEnder

¿Puede el carácter de comentario ser una barra ( |)?
Ton Hospel

Respuestas:



9

Retina , 35 34 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

Las dos cadenas de entrada están separadas por un espacio (que no es ambiguo ya que sabemos que el delimitador de comentarios es siempre un solo carácter).

Pruébalo en línea!


1
¿Por qué necesitas un espacio para delimitar las cuerdas? Como es un solo personaje, podría ser el último.
Adám

1
@ Adám Lo estoy reutilizando como separador de espacio en la salida final.
Martin Ender

9

Java 10, 189159 bytes

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 bytes convirtiendo Java 7 a Java 10 y optimizando los bucles.

Pruébalo en línea.

Explicación:

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 bytes

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 para -r) 86

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

Las entradas son cadenas separadas por un espacio.

Pruebas:
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 @

Salida:

$ 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 @

La etiqueta sin nombre :es una característica / error de GNU sed y \Screo que es una extensión, por lo que tal vez el título debería ser GNU sed. Aparte de eso, gran código.
seshoumara

@seshoumara ¡Gracias!
Riley

3

Haskell, 139 135 bytes

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

Se guardaron 4 bytes al incluir una definición.

Sin golf:

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

Maravilloso, 120 113 111 Bytes

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

sin golf *

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

(Primer borrador con 120 bytes)

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

sin 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')
}

Pruebas

%> 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 @

¿Qué tal.padRight(s.replace('|','').size()+1)+c)
AmazingDreams

¡buena idea! ¡gracias! salvó otros 2 caracteres!
norganos

3

Python 2, 125 124 132 bytes

-1 byte gracias a @TuukkaX (se perdió el golf desde el espacio 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)

Todos los casos de prueba en ideona


1
Se supone que debes usarlo ccomo comentario char, no #.
Oliver Ni

@OliverNi: eso fue un éxito para el código en su forma actual.
Jonathan Allan

3

Python 2, 107 105 102 99 bytes

Probado con todos los casos de prueba anteriores

EDITAR Golfed 2 bytes cambiando d = a.split ("|"); i = 0 to d, i = a.split ("|"), 0 No estoy seguro de cómo me perdí ese. Gracias @ Oliver Ni

Se han ido otros 3 bytes. Gracias de nuevo.

La sugerencia de @Jonathan en realidad ahorra 3 bytes y la lleva al 99 mágico. Gracias.

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
Golfed otro byte
Oliver Ni

3
Hola @OliverNi, se agradecen los consejos para jugar al golf, pero editar el código no es realmente apropiado en este sitio ( fuente ), así que he revertido tu edición. ¡Siéntete libre de publicar esos consejos como comentario! Estoy seguro de que el OP lo agradecería, pero debería depender de ellos probarlo y elegir si quieren usarlo.
DJMcMayhem

1
Gracias a los dos. En primer lugar, a @Oliver por tomar el interés y el tiempo para mejorar mi humilde esfuerzo y, en segundo lugar, a DJMcMayhem por aclarar lo que creía que era el caso pero que no había tenido la oportunidad de comentar. Oliver: gracias de nuevo y no dudes en publicar los cambios como comentarios para que pueda aprender de tu experiencia de golf.
ElPedro

1
Puede quitar el paréntesis " "*ipara tener 2 bytes
Oliver Ni

1
También puede configurar una variable para que le len(e)guste for e in d:z=len(e)....guardar un byte porque se usa dos veces
Oliver Ni

3

05AB1E , 29 38 31 29 bytes

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

Definitivamente se puede jugar golf, pero al menos funciona ahora ...
+9 bytes porque ¡(dividir) elimina los elementos vacíos automáticamente, así que tuve que agregar '|„ǝʒ:'ǝ¡'ʒм...
-2 bytes gracias a @MagicOctopusUrn al cambiar '|„ǝʒ:'ǝ¡'ʒмa '|¶:.BεðÜ}(la solución actual no funciona en elementos con espacios finales, pero supongo que está permitido según los casos de prueba).

Pruébalo en línea.

Explicación:

'|¶:           # 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

Esto no es válido si el código fuera a contener ǝʒ. '|¶:.Bpodría funcionar aunque
Magic Octopus Urn

@MagicOctopusUrn La descripción del desafío dice " La entrada del código solo contendrá ASCII imprimible y no contendrá ninguna línea nueva " . Además, ¿con qué parte del código debe reemplazarse '|¶:.B?
Kevin Cruijssen

Estaba pensando que sería una división más corta, pero no funcionaría con tu código actual simplemente golpeándolo, tendrías que recortar el exceso. O simplemente ignore el exceso y .Buna segunda vez después de agregar los espacios anteriores.
Magic Octopus Urn

@MagicOctopusUrn De hecho, podría ahorrar algunos bytes, ya que mi solución actual es bastante larga, pero será más difícil calcular la cantidad de espacios anteriores con los espacios después del .Bpresente.
Kevin Cruijssen

1
'|¶:.BεðÜ}εD®>úsg®+©s}.BεðIJ,? 29 bytes. Volver a la iteración 1 :). .Bse divide en líneas nuevas, que es una característica que mucha gente no conoce. Es la única forma que conozco para mantener elementos vacíos. Solicitaría esto como una característica. debería significar dividir, pero mantener elementos vacíos ..
Magic Octopus Urn

2

PowerShell v2 +, 103 99 bytes

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

Toma la entrada como dos cadenas, -splites la primera en la tubería literal (ya que la división usa la sintaxis de expresiones regulares) y alimenta los elementos en un bucle |%{...}.

Cada iteración, construimos una cadena como un número de espacios definidos por $lconcatenados con el elemento actual. Para el primer bucle, se $linicializa en $null, que se evalúa aquí como 0.

Esa cadena se concatena aún más con otro número de espacios (definido por cuánto tiempo $asería si damos -replacecada tubería sin nada, más 1el relleno adicional entre código y comentarios, menos el .lengthdel elemento actual, menos $lcuál es cuántos espacios rellenamos dejado en esta iteración), concatenado con nuestro carácter de comentario $b. Eso queda en la tubería.

Luego actualizamos $lpara la próxima iteración.

Todas las cadenas resultantes se dejan en la tubería, y la salida por vía implícita Write-Outputocurre en la ejecución del programa, con una nueva línea entre ellas por defecto.

Ejemplos

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 pulsaciones de teclas

-1 byte gracias a DJMcMayhem

Espera como entrada un búfer (por ejemplo, un archivo) cuyo primer carácter es el delimitador de comentarios, seguido del código, por ejemplo #foo|bar|baz.

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

Explicación

(" _" denota un espacio literal).

"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
: DI siempre votó vim! Creo que se podría tomar un byte fuera si cambia mma m`y luego cambiar `ma<C-o>
DJMcMayhem

@DJMcMayhem Gracias! Me encanta el golf en Vim porque siempre aprendo algo sobre una herramienta que uso todos los días.
Jordania

2

Floroid - 94 bytes

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

Utiliza un enfoque similar a la solución Python de @ JonathanAllan .

Casos de prueba

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 bytes

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;}

Sin 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;
}

Una solución LINQ habría sido 146 pero necesitaba using System.Linq;volver a ponerla en 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");}

Viejas soluciones:

167 bytes:

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 bytes usando interpolación de cadenas

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 bytes

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

o

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

1

MATL , 33 31 bytes

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

Pruébalo en línea!

Explicación

La función incorporada Yd( blkdiag), que construye una matriz de bloques en diagonal a partir de sus entradas, realiza la mayor parte del trabajo. Los valores de relleno en la matriz son 0, y char 0 se trata como un espacio para fines de visualización. El código simplemente se dividiría |, crearía una matriz a partir de los bloques resultantes, se convertiría en char y agregaría dos columnas con espacio y símbolo de comentario.

Sin embargo, la posibilidad de secciones vacías en la cadena de entrada complica el problema más interesante: el bloque resultante estaría vacío y, por lo tanto, no se mostraría en la matriz resultante.

Para resolver esto, introducimos un char 0 antes de cada uno |, por lo que ningún bloque estará vacío; y luego, en la matriz char resultante, eliminamos las columnas que están formadas por char 0 solamente. Una sección de código no vacía tendrá algunos caracteres ASCII imprimibles y, por lo tanto, las columnas que abarca sobrevivirán. Una sección vacía contribuirá con una fila, pero no introducirá una columna adicional.

'\|'    % 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
Estoy vagamente decepcionado de que no hayas puesto tu explicación en el formato que mencionó el OP
Random832

1
@ Random832 No uso ese formato a menudo. Utiliza mucho espacio, dejando poco espacio para las explicaciones
Luis Mendo

¿Por qué se necesita el escape en la primera cadena?
Conor O'Brien

@ ConorO'Brien Buena pregunta. Nunca sé qué / cuándo los símbolos especiales necesitan escapar y qué / cuándo no. En este caso, |( subexpresión de coincidencias antes o después del| ) sí lo necesita, al menos en el motor de expresión regular Matlab / Octave
Luis Mendo

1

Pyth, 30 bytes

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

o

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

Ambos son programas completos que reciben información en STDIN de la cadena de comentarios, y luego la cadena del programa, separada por una nueva línea.

Prueba la primera versión en línea

Prueba la segunda versión en línea

Cómo trabajan ellos

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 (no competidor), 43 37 bytes

Solicita el carácter de comentario, luego el código.

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

No compite porque la versión 16.0 es más nueva que este desafío.


¿Cómo sigue sin competir dyalog APL? ¿Todavía está en desarrollo?
DJMcMayhem

@DJMcMayhem Sí. Trabajo para Dyalog y he tenido acceso a 16.0 incluso antes de que se lanzara 15.0. El lanzamiento de 16.0 está programado para 2017Q1.
Adám

¿Como funciona esto?
Conor O'Brien

1

Perl, 63 bytes

Incluye +5 para -Xpi

Ejecute con entrada en STDIN y comente el carácter después de -i:

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

esolang.pl:

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

Solución directa totalmente aburrida


1

Turtlèd , 35 bytes (sin competencia)

Toma una entrada, el último carácter es el comentario. No funciona con el carácter de comentario como espacio, pero supongo que no es necesario.

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

Explicación:

!                                  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 bytes

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

Código de prueba + Salida:

?("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 bytes

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

Véalo en eval.in: https://eval.in/639012

Realmente debería aprender Retina.


0

Jalea , 41 bytes

Parece que tiene muchos incrementos, y probablemente demasiados enlaces ...

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

Pruébelo en TryItOnline

¿Cómo?

ṫø⁹‘‘µ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 bytes

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

Explicación

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

Pruébalo en línea


0

GolfScript, 85 bytes

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

Pruébalo en línea

Actualización 2017 - GolfScript - 71 bytes

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

Explicación

', '/~~: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

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.