Su objetivo en este campo de código es tomar dos cadenas, languagey code (si el código golfed que escribió para este consta de varias líneas, a continuación, esta variable sería de varias líneas.) , Y un entero, bytes. Representan las variables para un lenguaje de programación, la cantidad de bytes que necesita y el código en sí.

Después de eso, lo formateará como lo hace un golfista de código.

La variable de salida es una cadena multilínea llamada answer.

Puede usar cadenas multilínea en:

• C ++
• Pitón
• Perl
• JavaScript

Si busca Stack Overflow , debería poder encontrar más lenguajes de programación que lo admitan.

Aquí hay una plantilla de la rebaja de salida. La codevariable está en un bloque de código y hay un encabezado de segundo nivel.

## {language}, {bytes} bytes

     {code}

Así es como se vería el resultado al pegarlo en un analizador Markdown.

{idioma}, {bytes} bytes

    {code}

Se supone que las variables ya se completarán como el idioma en el que codificó su entrada de golf de código, el número de bytes que toma y el código real para ello.

Aquí hay otro ejemplo de la salida como código, esta vez con variables completadas:

## JavaScript, 1337 bytes

document.getElementById("foo").innerHTML = bar;

Aquí está la versión como una cita en bloque:

JavaScript, 1337 bytes

    document.getElementById("foo").innerHTML = bar;

Los bytes se pueden quitar de su código si usa una forma de establecer el texto de un <p>elemento en HTML mediante la identificación result, como el siguiente código JavaScript:

document.getElementById("result").innerHTML = answer;

Asegúrese de incluir también <p id="result"></p>en la sección HTML de JSFiddle para que esto funcione.

Puntuación

Como todas las preguntas de código de golf , el código que usa la menor cantidad de bytes es el mejor.

05AB1E , 21 bytes

Código:

“## ÿ, ÿ¡Ï
“,|v4ð×y«,

Utiliza la codificación CP-1252 . Pruébalo en línea! .

Java, 70 bytes

String A(String[]b){return"## "+b[0]+", "+b[1]+" bytes\n\n    "+b[2];}

Asume que b[0]es el nombre del idioma, b[1]es el recuento de bytes y b[2]es el código.

Hacerlo compilable cuesta 9 bytes, lo que resulta en un programa no independiente de 79 bytes:

class a{String A(String[]b){return"## "+b[0]+", "+b[1]+" bytes\n\n    "+b[2];}}

El programa monolítico equivalente tiene 103 bytes de longitud:

interface a{static void main(String[]A){System.out.print("## "+A[0]+", "+A[1]+" bytes\n\n    "+A[2]);}}

El monolítico funciona con argumentos de línea de comando, asumiendo estos al igual que el programa no independiente:

• El primer argumento es el nombre del idioma.
• El segundo argumento es el recuento de bytes
• El tercer argumento es el código

Java (expresión lambda), 56 48 bytes

(b)->"## "+b[0]+", "+b[1]+" bytes\n\n    "+b[2];

Se trata de una java.util.function.Function<String[], String>.

Ninguno de estos programas / funciones maneja cadenas multilínea. Para hacerlo, simplemente reemplace b[2]y A[2]con b[2].replace("\n","\n ")y A[2].replace("\n","\n "), al hacerlo, agrega 23 bytes.

V , 24 bytes

Tenga en cuenta que hay un espacio final al final.

Este programa supone que {code}no estará en varias líneas.

Op ha aclarado, "código" puede ser una cadena multilínea. Esta versión de 24 bytes funciona:

2é#á $á,JA bytes
vGî4é 

Como esto contiene un carácter no imprimible, aquí está la versión legible:

2é#á $á,JA bytes
<esc>vGî4é<space>

¿Dónde <esc>está el carácter de escape literal, por ejemplo 0x1B.

Python 3.5, 40 33 bytes:

( -7 bytes gracias a alguna aclaración de Mego )

lambda*f:'## %s, %s bytes\n\n\t%s'%f

Una función lambda anónima que toma entradas como argumentos posicionales en el formato <function name>(String, Number, String)y genera una cadena multilínea.

¡Pruébelo en línea! (Ideona)

JavaScript (ES6), 56 bytes

(l,b,c)=>`## ${l}, ${b} bytes

`+c.replace(/^/gm,`    `)

Además, para reír, aquí hay una respuesta que se formatea para mí:

JavaScript (ES6), 68 bytes

f=_=>`## JavaScript (ES6), ${`${f}`.length+3} bytes\n\n    f=${f};`;

Imprime el resultado de f().

C #, 40 38 bytes

(a,b,c)=>$"## {a}, {b} bytes\n\n\t"+c;

C # lambda donde las entradas y salidas son cadenas.

C #, 59 bytes

(a,b,c)=>$"## {a}, {b} bytes\n\n\t"+c.Replace("\n","\n\t");

Con manejo de una respuesta multilínea.

C #, 71 bytes

La solución de 38 bytes que se imprime

()=>$"## C#, 38 bytes\n\n\t"+@"(a,b,c)=>$""## {a}, {b} bytes

\t""+c;";

Pruébalos en línea

Mathematica, 40 bytes

Print["## ",#,", ",#2,"bytes

    ",#3]&

Función anónima. Toma el idioma, el recuento de bytes y el programa como entrada e imprime el cuerpo en STDOUT.

Jolf, 24 22 bytes

"## ¦i, ¦j Ξ/u3

    ¦

No hay mucho que explicar aquí. ¦significa entrada interpolada.

Pruébalo aquí! La salida para la entrada en el enlace es:

## Jolf, 24 bytes

    some filler code I think

La entrada es como:

name

number

"code"

MATL , 28 27 bytes

1 byte guardado gracias a la sugerencia de @ NinjaBearMoneky

35tOj', 'j' bytes'10t4Z"j&h

Pruébalo en línea!

El bloque de código debe estar en una sola línea.

Explicación

35t           % Push 35 (ASCII for '#') twice
0             % Push 0. When converted to char, it will be displayed as a space
j             % Input string (language name)
', '          % Push this string
j             % Input string (byte count)
' bytes'      % Push this string
10t           % Push 10 (ASCII for linefeed) twice
4Z"           % Push string containing four spaces
j             % Input string (code)
&h            % Concatenate everything into a string. Implicitly display

Lisp común, 57 bytes

(lambda(L b c)(format()"## ~A, ~A bytes~%~%    ~A"L b c))

Además, por diversión, aquí debajo hay un fragmento de código que imprime un encabezado por sí mismo.

Lisp común, 146 bytes

#1=(PROGN
(SETF *PRINT-CIRCLE* T)
(LET ((S (FORMAT NIL "~S" '#1#)))
  (FORMAT NIL "## Common Lisp, ~A bytes~%~%    ~A" (LENGTH S) S)))

Ruby, 63 bytes

def f(l,b,c) s="\#\# #{l}, #{b} bytes\n\n    #{c}";return s;end

Pruébelo en línea: http://codepad.org/EIn0Gw9M

hashmap , 29 bytes.

"## "i", "h" bytes.\n\n    "i

(Escribí esa publicación con el programa, pero tuve que escapar \ n a \\ n)
Explicación:

"## "                         Push string
     i", "                    Push input and string
          h" bytes.\n\n    "i Push input as number and string, then the input.

CJam , 26 23 bytes

¡Gracias a @NinjaBearMonkey por eliminar 3 bytes!

'#_Sl',Sl" bytes"N_S4*l

El bloque de código debe estar en una sola línea.

Pruébalo en línea!

Explicación

'#_S       e# Push character "#" twice, then a space
l          e# Read line from input
',S        e# Push a comma, then a space
l          e# Read line from input
" bytes"   e# Push this string
N_S4*      e# Push newline twice, then four spaces
l          e# Read line from input. Implicitly display 

Pyke, 25 bytes

"##"Q", "z" bytes"skd4*z+

Pruébalo aquí!

O

Pyke, 0 bytes

Pruébalo aquí! - Haga clic en el botón Copiar respuesta;)

EDITAR : es solo una característica del sitio web, es una trampa (o al menos lo consideraría así) porque nunca analiza un AST y el programa web probablemente no se considera parte del idioma debido a que no interactúa mucho con el idioma (aunque ejecuta el intérprete de Pyke)

Perl 5, 35 bytes

Un programa completo, toma la entrada como argumentos de línea de comandos en orden inverso. Requiere -M5.01, que es gratis.

say pop.', '.pop.' bytes

    '.pop

Emacs Lisp, 97 bytes

(lambda(l c)(format"## %s, %s bytes\n\n%s"l(string-bytes c)(replace-regexp-in-string"^""    "c)))

Además, dado que a veces puede ser difícil escapar de las comillas y otras cosas, un ejemplo de uso que copia la cadena en el portapapeles. (Marcar región y usar M-:)

Emacs Lisp, 184 bytes

(kill-new ((lambda(l c)(format"## %s, %s bytes\n\n%s"l(string-bytes c)(replace-regexp-in-string"^""    "c)))"Emacs Lisp"(buffer-substring-no-properties(region-beginning)(region-end))))