10
\$\begingroup\$

Your goal in this code golf is to take two strings, language and code (if the golfed code you wrote for this is multiline, then this variable would be multiline.), and one integer, bytes. They represent the variables for a programming language, number of bytes it takes, and the code itself.

After that, you are going to format it like a code golfer does it.

The output variable is a multiline string called answer.

You can use multiline strings on:

If you search Stack Overflow, you should be able to find more programming languages that support it.

Here is a template of the output markdown. The code variable is in a code block, and there is a second-level header.

## {language}, {bytes} bytes

     {code}

Here is what the output would look like when pasted into a Markdown parser.

{language}, {bytes} bytes

    {code}

Variables are assumed to be filled out already as the language you coded your code golf entry in, the number of bytes it takes, and the actual code for it.

Here is another example of the output as code, this time with variables filled out:

## JavaScript, 1337 bytes

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

Here is the version as a blockquote:

JavaScript, 1337 bytes

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

Bytes can be taken off from your code if you use a way to set the text of a <p> element in HTML by the id result, like the following JavaScript code:

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

Make sure to also include the <p id="result"></p> in the HTML section of JSFiddle for this to work.

Scoring

Like all questions, the code that uses the least amount of bytes is the best.

\$\endgroup\$
  • 3
    \$\begingroup\$ Will {code} ever be a multiline code? \$\endgroup\$ – Adnan Jul 9 '16 at 23:54
  • 8
    \$\begingroup\$ "Variables will be filled out as the language you coded your code golf entry in, the number of bytes it takes, and the actual code for it." Am I the only one interpreting this as a quine variation? \$\endgroup\$ – primo Jul 10 '16 at 7:34
  • 2
    \$\begingroup\$ Since the answers are solving two completely different problems, I'm putting this on hold this as unclear. Please clarify whether language, bytes and code are input or whether this is a quine variant where those things should match the solving code itself. (And if so, whether directly or indirectly reading that source code is allowed, and whether quine built-ins are allowed.) \$\endgroup\$ – Martin Ender Jul 10 '16 at 10:36
  • 2
    \$\begingroup\$ Could you also clarify Adnan's question whether the input code can itself contain linefeeds? \$\endgroup\$ – Martin Ender Jul 10 '16 at 13:13
  • 2
    \$\begingroup\$ @Peanut I'm confused. Can we assume code will not be multiline, or can't we? Please indicate that in the challenge text \$\endgroup\$ – Luis Mendo Jul 11 '16 at 16:40

16 Answers 16

2
\$\begingroup\$

05AB1E, 21 bytes

Code:

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

Uses the CP-1252 encoding. Try it online!.

\$\endgroup\$
  • \$\begingroup\$ This doesn't handle multiline strings \$\endgroup\$ – DJMcMayhem Jul 10 '16 at 16:59
  • \$\begingroup\$ @DrGreenEggsandIronMan Fixed. \$\endgroup\$ – Adnan Jul 10 '16 at 20:02
  • \$\begingroup\$ And so the V vs O5AB1E battle continues... Nice job! \$\endgroup\$ – DJMcMayhem Jul 10 '16 at 20:04
  • \$\begingroup\$ @DrGreenEggsandIronMan I'll be waiting for the next ASCII art challenge to take revenge :). \$\endgroup\$ – Adnan Jul 10 '16 at 20:05
8
\$\begingroup\$

Java, 70 bytes

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

Assumes b[0] is the language name, b[1] is the byte count, and b[2] is the code.

Making it compilable costs 9 bytes, resulting in a 79-byte non-standalone program:

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

The equivalent monolithic program is 103 bytes long:

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

The monolithic one works with command line arguments, assuming these just like the non-standalone program:

  • First argument is the language name
  • Second argument is the byte count
  • Third argument is the code

Java (lambda expression), 56 48 bytes

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

This is a java.util.function.Function<String[], String>.


None of these programs/functions handle multiline strings. To do so, simply replace b[2] and A[2] with b[2].replace("\n","\n ") and A[2].replace("\n","\n ") - doing so adds 23 bytes.

\$\endgroup\$
  • \$\begingroup\$ I'm not near a computer right now to confirm it, but can't you use \t or something to replace the 4 spaces after the two newlines? \$\endgroup\$ – R. Kap Jul 10 '16 at 0:00
  • \$\begingroup\$ @R.Kap Sometimes using tabs instead of spaces creates a mess on SE. \$\endgroup\$ – dorukayhan wants Monica back Jul 10 '16 at 0:04
  • \$\begingroup\$ Ah, I see. So does the byte count take into consideration \t and not 4 spaces? \$\endgroup\$ – R. Kap Jul 10 '16 at 0:28
  • 3
    \$\begingroup\$ Lose the parens on the lambda; you can save two bytes with just b->. \$\endgroup\$ – Brian McCutchon Jul 10 '16 at 1:58
  • 2
    \$\begingroup\$ What happens if there's more than one line of code? \$\endgroup\$ – Neil Jul 10 '16 at 8:55
5
\$\begingroup\$

V, 24 bytes

Note that there is a trailing space at the end.

This program makes the assumption that {code} will not be on multiple lines.

Op has clarified, "code" may be a multiline string. This 24 byte version works:

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

Since this contains an unprintable character, here is the readable version:

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

Where <esc> is the literal escape character, e.g. 0x1B.

\$\endgroup\$
  • 1
    \$\begingroup\$ It always seems like a constant struggle between Jolf and V... :3 \$\endgroup\$ – Conor O'Brien Jul 10 '16 at 2:52
4
\$\begingroup\$

Python 3.5, 40 33 bytes:

(-7 bytes thanks to some clarification from Mego)

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

An anonymous lambda function that takes inputs as positional arguments in the format <function name>(String, Number, String) and outputs a multiline string.

Try It Online! (Ideone)

\$\endgroup\$
  • 2
    \$\begingroup\$ You can shave off several bytes if you make the parameter list *f and drop the tuple call. \$\endgroup\$ – Mego Jul 10 '16 at 3:23
  • \$\begingroup\$ @Mego Unfortunately, that does not work, as I get TypeError: not enough arguments for format string whenever I run it like that. \$\endgroup\$ – R. Kap Jul 10 '16 at 4:08
  • \$\begingroup\$ Works fine when I try it - you have to take positional arguments instead of a list argument. Additionally, you can drop the space between the # and the %. \$\endgroup\$ – Mego Jul 10 '16 at 4:10
  • \$\begingroup\$ @Mego Wow, that is so weird, because when I try it in PyCharm with Python 3.5.1, I get an error. That confused me so much. Also, the space between the # and the lambda is needed, or so I think. \$\endgroup\$ – R. Kap Jul 10 '16 at 4:12
  • \$\begingroup\$ @Mego It's updated. \$\endgroup\$ – R. Kap Jul 10 '16 at 4:16
4
\$\begingroup\$

JavaScript (ES6), 56 bytes

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

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

Also, for laughs, here is an answer that formats itself for me:

JavaScript (ES6), 68 bytes

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

Print the result of f().

\$\endgroup\$
  • \$\begingroup\$ @PatrickRoberts Oops, I didn't actually check the length, I just copied and pasted it, then later added 6 bytes for the (ES6). (Why did Cᴏɴᴏʀ O'Bʀɪᴇɴ only bother to change the length?) \$\endgroup\$ – Neil Jul 10 '16 at 8:54
4
\$\begingroup\$

C#, 40 38 bytes

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

C# lambda where inputs and output are strings.


C#, 59 bytes

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

With handling of a multiline answer.


C#, 71 bytes

The 38 bytes solution which print itself

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

\t""+c;";

Try them online

\$\endgroup\$
3
\$\begingroup\$

Mathematica, 40 bytes

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

    ",#3]&

Anonymous function. Takes the language, byte count, and program as input and prints the body to STDOUT.

\$\endgroup\$
2
\$\begingroup\$

Jolf, 24 22 bytes

"## ¦i, ¦j Ξ/u3

    ¦

Not much to explain here. ¦ means interpolated input.

Try it here! Output for the input in the link is:

## Jolf, 24 bytes

    some filler code I think

Input is as:

name

number

"code"
\$\endgroup\$
1
\$\begingroup\$

MATL, 28 27 bytes

1 byte saved thanks to @NinjaBearMoneky's suggestion

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

Try it online!

The code block must be on a single line.

Explanation

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
\$\endgroup\$
0
\$\begingroup\$

Common Lisp, 57 bytes

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

Also, for fun, here below is a snippet of code which prints a header for itself.

Common Lisp, 146 bytes

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

Ruby, 63 bytes

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

Try it online: http://codepad.org/EIn0Gw9M

\$\endgroup\$
0
\$\begingroup\$

hashmap, 29 bytes.

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

(I wrote that post with the program, but I had to escape \n into \\n)
Explanation:

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

CJam, 26 23 bytes

Thanks to @NinjaBearMonkey for removing 3 bytes!

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

The code block must be on a single line.

Try it online!

Explanation

'#_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 
\$\endgroup\$
  • \$\begingroup\$ 23 bytes: '#_Sl',Sl" bytes"N_S4*l \$\endgroup\$ – NinjaBearMonkey Jul 10 '16 at 14:14
  • \$\begingroup\$ @NinjaBearMonkey Thanks! Edited. This idea saved a byte also for my other answer \$\endgroup\$ – Luis Mendo Jul 10 '16 at 15:15
0
\$\begingroup\$

Pyke, 25 bytes

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

Try it here!

Or

Pyke, 0 bytes

Try it here! - click the copy answer button ;)

EDIT - It's just a feature of the website, it's cheating (or at least I would consider it so) because it never parses an AST and the web program probably isn't considered part of the language due to it not interacting with the language much (even though it is running the Pyke interpreter)

\$\endgroup\$
  • \$\begingroup\$ What makes the 0 bytes version work? \$\endgroup\$ – haykam Jul 11 '16 at 13:19
  • \$\begingroup\$ Can you add that to the answer? I'm not counting that but you can still keep it up there. \$\endgroup\$ – haykam Jul 11 '16 at 13:37
  • \$\begingroup\$ Hey @muddyfish, can you separate these into two answers? \$\endgroup\$ – haykam Mar 1 '17 at 3:04
  • \$\begingroup\$ @haykam if this is for the purposes of accepting an answer, I'd rather not as I don't think the 0 byte solution counts as actually using Pyke and feels too chesty \$\endgroup\$ – Blue Mar 1 '17 at 12:01
  • \$\begingroup\$ I won't accept that answer. \$\endgroup\$ – haykam Mar 1 '17 at 19:48
0
\$\begingroup\$

Perl 5, 35 bytes

A full program, this takes input as command-line arguments in reverse order. It requires -M5.01, which is free.

say pop.', '.pop.' bytes

    '.pop
\$\endgroup\$
0
\$\begingroup\$

Emacs Lisp, 97 bytes

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

Also, since it can sometimes be tough to escape quotes and what not, a usage example that copies the string to the clipboard. (Mark region and use 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))))
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.