Seu objetivo neste código golf é usar duas cadeias languagee code (se o código que você escreveu para isso for multiline, essa variável seria multiline.) E um número inteiro bytes,. Eles representam as variáveis ​​para uma linguagem de programação, número de bytes necessários e o próprio código.

Depois disso, você irá formatá-lo como um jogador de código faz.

A variável de saída é uma sequência multilinha chamada answer.

Você pode usar cadeias de linhas múltiplas em:

• C ++
• Pitão
• Perl
• Javascript

Se você pesquisar Stack Overflow , poderá encontrar mais linguagens de programação que o suportem.

Aqui está um modelo da margem de saída. A codevariável está em um bloco de código e há um cabeçalho de segundo nível.

## {language}, {bytes} bytes

     {code}

Aqui está a aparência da saída quando colada em um analisador Markdown.

{language}, {bytes} bytes

    {code}

Presume-se que as variáveis ​​já estejam preenchidas conforme o idioma em que você codificou sua entrada de código de golfe, o número de bytes necessários e o código real.

Aqui está outro exemplo da saída como código, desta vez com variáveis ​​preenchidas:

## JavaScript, 1337 bytes

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

Aqui está a versão como uma citação:

JavaScript, 1337 bytes

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

Os bytes podem ser retirados do seu código se você usar uma maneira de definir o texto de um <p>elemento em HTML pelo ID result, como o seguinte código JavaScript:

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

Certifique-se de incluir também <p id="result"></p>na seção HTML do JSFiddle para que isso funcione.

Pontuação

Como todas as perguntas sobre código-golfe , o código que usa a menor quantidade de bytes é o melhor.

05AB1E , 21 bytes

Código:

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

Usa a codificação CP-1252 . Experimente online! .

Java, 70 bytes

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

Assume que b[0]é o nome do idioma, b[1]é a contagem de bytes e b[2]é o código.

Tornar compilável custa 9 bytes, resultando em um programa não autônomo de 79 bytes:

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

O programa monolítico equivalente tem 103 bytes de comprimento:

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

O monolítico trabalha com argumentos de linha de comando, assumindo-os como o programa não independente:

• Primeiro argumento é o nome do idioma
• O segundo argumento é a contagem de bytes
• Terceiro argumento é o código

Java (expressão lambda), 56 48 bytes

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

Isto é um java.util.function.Function<String[], String>.

Nenhum desses programas / funções manipula seqüências de linhas múltiplas. Para fazer isso, basta substituir b[2]e A[2]por b[2].replace("\n","\n ")e A[2].replace("\n","\n ")- adicionando 23 bytes.

V , 24 bytes

Observe que há um espaço à direita no final.

Este programa assume que {code}não estará em várias linhas.

Op esclareceu, "código" pode ser uma sequência de múltiplas linhas. Esta versão de 24 bytes funciona:

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

Como contém um caractere não imprimível, aqui está a versão legível:

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

Onde <esc>está o caractere de escape literal, por exemplo 0x1B.

Python 3.5, 40 33 bytes:

( -7 bytes graças a alguns esclarecimentos do Mego )

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

Uma função lambda anônima que recebe entradas como argumentos posicionais no formato <function name>(String, Number, String)e gera uma sequência de linhas múltiplas.

Experimente Online! (Ideona)

JavaScript (ES6), 56 bytes

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

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

Além disso, para rir, aqui está uma resposta que se formata para mim:

JavaScript (ES6), 68 bytes

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

Imprima o resultado de f().

C #, 40 38 bytes

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

C # lambda onde entradas e saídas são cadeias de caracteres.

C #, 59 bytes

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

Com o manuseio de uma resposta multilinha.

C #, 71 bytes

A solução de 38 bytes que se imprime

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

\t""+c;";

Experimente online

Mathematica, 40 bytes

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

    ",#3]&

Função anônima. Pega o idioma, a contagem de bytes e o programa como entrada e imprime o corpo em STDOUT.

Jolf, 24 22 bytes

"## ¦i, ¦j Ξ/u3

    ¦

Não há muito a explicar aqui. ¦significa entrada interpolada.

Experimente aqui! A saída para a entrada no link é:

## Jolf, 24 bytes

    some filler code I think

A entrada é como:

name

number

"code"

MATL , 28 27 bytes

1 byte salvo graças à sugestão de @ NinjaBearMoneky

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

Experimente online!

O bloco de código deve estar em uma única linha.

Explicação

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 comum, 57 bytes

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

Além disso, por diversão, aqui está um trecho de código que imprime um cabeçalho para si.

Lisp comum, 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

Experimente online: http://codepad.org/EIn0Gw9M

hashmap , 29 bytes.

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

(Escrevi essa postagem com o programa, mas tive que escapar \ n para \\ n)
Explicação:

"## "                         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

Obrigado a @NinjaBearMonkey por remover 3 bytes!

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

O bloco de código deve estar em uma única linha.

Experimente online!

Explicação

'#_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+

Experimente aqui!

Ou

Pyke, 0 bytes

Experimente aqui! - clique no botão copiar resposta;)

EDIT - É apenas um recurso do site, é trapaceiro (ou pelo menos eu o consideraria) porque nunca analisa um AST e o programa da web provavelmente não é considerado parte do idioma, pois não interage muito com o idioma (mesmo que esteja executando o interpretador Pyke)

Perl 5, 35 bytes

Um programa completo, recebe entradas como argumentos de linha de comando na ordem inversa. Requer -M5.01, que é gratuito.

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

Além disso, como às vezes pode ser difícil escapar de aspas e outras coisas, um exemplo de uso que copia a string para a área de transferência. (Marque região e uso 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))))