Votre but dans ce golf de code est de prendre deux chaînes, languageet code (si le code golfed que vous avez écrit pour cela est multiligne, alors cette variable multiligne soit.) , Et un entier, bytes. Ils représentent les variables d'un langage de programmation, le nombre d'octets qu'il prend et le code lui-même.

Après cela, vous allez le formater comme le fait un golfeur de code.

La variable de sortie est une chaîne multiligne appelée answer.

Vous pouvez utiliser des chaînes multilignes sur:

• C ++
• Python
• Perl
• Javascript

Si vous recherchez Stack Overflow , vous devriez pouvoir trouver plus de langages de programmation qui le prennent en charge.

Voici un modèle de démarque de sortie. La codevariable est dans un bloc de code et il y a un en-tête de deuxième niveau.

## {language}, {bytes} bytes

     {code}

Voici à quoi ressemblerait la sortie une fois collée dans un analyseur Markdown.

{langue}, {octets} octets

    {code}

Les variables sont supposées être déjà remplies comme la langue dans laquelle vous avez codé votre entrée de golf de code, le nombre d'octets qu'il prend et le code réel pour celui-ci.

Voici un autre exemple de sortie sous forme de code, cette fois avec des variables remplies:

## JavaScript, 1337 bytes

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

Voici la version en bloc:

JavaScript, 1337 octets

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

Les octets peuvent être retirés de votre code si vous utilisez un moyen de définir le texte d'un <p>élément en HTML par l'id result, comme le code JavaScript suivant:

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

Assurez-vous d'inclure également le <p id="result"></p>dans la section HTML de JSFiddle pour que cela fonctionne.

Notation

Comme toutes les questions de code-golf , le code qui utilise le moins d'octets est le meilleur.

05AB1E , 21 octets

Code:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

Java, 70 octets

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

Suppose que b[0]c'est le nom de la langue, b[1]le nombre d'octets et b[2]le code.

La rendre compilable coûte 9 octets, ce qui donne un programme non autonome de 79 octets:

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

Le programme monolithique équivalent fait 103 octets de long:

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

Le monolithique fonctionne avec des arguments de ligne de commande, en supposant ceux-ci tout comme le programme non autonome:

• Le premier argument est le nom de la langue
• Le deuxième argument est le nombre d'octets
• Le troisième argument est le code

Java (expression lambda), 56 48 octets

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

Ceci est un java.util.function.Function<String[], String>.

Aucun de ces programmes / fonctions ne gère les chaînes multilignes. Pour ce faire, il suffit de remplacer b[2]et A[2]avec b[2].replace("\n","\n ")et A[2].replace("\n","\n ")- cela ajoute 23 octets.

V , 24 octets

Notez qu'il y a un espace de fin à la fin.

Ce programme fait l'hypothèse qui {code}ne sera pas sur plusieurs lignes.

Op a clarifié, "code" peut être une chaîne multiligne. Cette version de 24 octets fonctionne:

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

Puisqu'il contient un caractère non imprimable, voici la version lisible:

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

Où <esc>est le caractère d'échappement littéral, par exemple 0x1B.

Python 3.5, 40 33 octets:

( -7 octets grâce à une clarification de Mego )

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

Une fonction lambda anonyme qui prend les entrées comme arguments positionnels dans le format <function name>(String, Number, String)et génère une chaîne multiligne.

Essayez-le en ligne! (Ideone)

JavaScript (ES6), 56 octets

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

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

Aussi, pour rire, voici une réponse qui se formate pour moi:

JavaScript (ES6), 68 octets

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

Imprimer le résultat de f().

C #, 40 38 octets

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

C # lambda où les entrées et les sorties sont des chaînes.

C #, 59 octets

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

Avec traitement d'une réponse multiligne.

C #, 71 octets

La solution de 38 octets qui s'imprime

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

\t""+c;";

Essayez-les en ligne

Mathematica, 40 octets

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

    ",#3]&

Fonction anonyme. Prend la langue, le nombre d'octets et le programme en entrée et imprime le corps dans STDOUT.

Jolf, 24 ans 22 octets

"## ¦i, ¦j Ξ/u3

    ¦

Pas grand chose à expliquer ici. ¦signifie entrée interpolée.

Essayez-le ici!La sortie pour l'entrée dans le lien est:

## Jolf, 24 bytes

    some filler code I think

L'entrée est la suivante:

name

number

"code"

MATL , 28 27 octets

1 octet enregistré grâce à la suggestion de @ NinjaBearMoneky

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

Essayez-le en ligne!

Le bloc de code doit être sur une seule ligne.

Explication

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 commun, 57 octets

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

Aussi, pour le plaisir, voici un extrait de code qui imprime un en-tête pour lui-même.

Lisp commun, 146 octets

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

Rubis, 63 octets

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

Essayez-le en ligne: http://codepad.org/EIn0Gw9M

hashmap , 29 octets.

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

(J'ai écrit ce message avec le programme, mais j'ai dû m'échapper \ n dans \\ n)
Explication:

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

CJam , 26 23 octets

Merci à @NinjaBearMonkey d'avoir supprimé 3 octets!

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

Le bloc de code doit être sur une seule ligne.

Essayez-le en ligne!

Explication

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

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

Essayez-le ici!

Ou

Pyke, 0 octets

Essayez-le ici! - cliquez sur le bouton copier réponse;)

EDIT - C'est juste une fonctionnalité du site Web, il triche (ou du moins je le considérerais) parce qu'il n'analyse jamais un AST et le programme Web n'est probablement pas considéré comme faisant partie de la langue car il n'interagit pas beaucoup avec la langue (même s'il exécute l'interpréteur Pyke)

Perl 5, 35 octets

Un programme complet, cela prend l'entrée comme arguments de ligne de commande dans l'ordre inverse. Il faut -M5.01, ce qui est gratuit.

say pop.', '.pop.' bytes

    '.pop

Emacs Lisp, 97 octets

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

De plus, comme il peut parfois être difficile d'échapper aux guillemets et autres, un exemple d'utilisation qui copie la chaîne dans le presse-papiers. (Marquez la région et utilisezM-: )

Emacs Lisp, 184 octets

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