192
\$\begingroup\$

I think the question as above is clear, but just in case:

  • Write a full program (not just a function) which prints a positive base 10 integer, optionally followed by a single newline.

  • Qualifying programs will be those whose output is longer (in bytes) than the source code of the program, measured in bytes (assuming ASCII or UTF-8 encoding for the program source code).

    I.e. the code must be shorter than the number of digits in the resulting number.

  • Leading zeros are disallowed under all circumstances. Counting leading zeroes trivialises the problem; ignoring leading zeros unnecessarily complicates the question.

  • The winning program will be the qualifying program which prints the integer with the smallest magnitude.

Leaderboard snippet

var QUESTION_ID = 67921;
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;
function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; }
function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; }
function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); }
getAnswers();
var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*)(?:,|[-\u2013] ).*?([\d,^!e+]+)(?=\:?[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var OVERRIDE_REG = /^Override\s*header:\s*/i;
function getAuthorName(a) { return a.owner.display_name; }
function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.replace(/<sup>([^\n<]*)<\/sup>/g, "^$1").replace(/\(\d+(?:\^\d+,)? [\w\s]+\)/g, "").replace(/floor\(10\^(\d+)\/9\)/g, "$1 ones").replace(/(\d+) ones/g, function (_, x) { return Array(+x + 1).join(1); }).match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2].replace(/,/g, "").replace(/(\d+)\s*\^\s*(\d+)/, function (_, a, b) { return Math.pow(a, b); }).replace(/(\d+)!/, function (_, n) { for (var i = 1, j = 1; i <= n; i++) j *= i; return j; }), language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> 
<div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table>

\$\endgroup\$
24
  • 67
    \$\begingroup\$ Number 1 on the Hot Network Questions. Not bad for a first question... \$\endgroup\$ Commented Dec 28, 2015 at 15:15
  • 7
    \$\begingroup\$ @Kslkgh Strictly less than, otherwise the question is trivial for programs which implicitly print their last value. \$\endgroup\$
    – Arandur
    Commented Dec 28, 2015 at 15:57
  • 9
    \$\begingroup\$ Is 1.0 an integer? \$\endgroup\$
    – histocrat
    Commented Dec 28, 2015 at 20:05
  • 33
    \$\begingroup\$ The restriction to UTF-8 is ridiculous and detrimental. Bytes are bytes, no matter the encoding. I strongly recommend that you change the rules, as as they currently are they disallow languages that are not character-based (e.g. Minecraft, Piet, Folders) or have longer UTF-8 byte counts than their "real" (valid according to this question) byte counts (e.g. APL, TI-BASIC, Seriously, Jelly). \$\endgroup\$
    – lirtosiast
    Commented Dec 29, 2015 at 3:35
  • 8
    \$\begingroup\$ @ZachGates that's not how the HNQ list works. ;) \$\endgroup\$ Commented Dec 29, 2015 at 8:38

180 Answers 180

2
\$\begingroup\$

gs2, 10

A single byte of CP437. Prints 10. Try it here!

\$\endgroup\$
4
  • 3
    \$\begingroup\$ OP said UTF-8 (I disagree with the rules, but OP might not change them.) \$\endgroup\$
    – lirtosiast
    Commented Dec 29, 2015 at 3:39
  • \$\begingroup\$ This answer is invalid because this is 2 bytes in UTF-8, which is the encoding specified in the challenge. \$\endgroup\$
    – user45941
    Commented Apr 6, 2016 at 18:57
  • \$\begingroup\$ @Mego CP437 and UTF-8 are compatible in the first 128 bytes. This is just a dingbat that represents the actual control character. \$\endgroup\$
    – Dennis
    Commented Apr 6, 2016 at 20:31
  • \$\begingroup\$ Oh, whoops, I missed the fact that it was in the lower half. I should know better, considering how much I've worked with CP437 for Seriously... \$\endgroup\$
    – user45941
    Commented Apr 6, 2016 at 20:38
2
\$\begingroup\$

Mouse-2002, 10101010

k is 10, but ! printing costs a byte, so this is the only way.

kkkk(!)

Exits with an error, if run interactively.

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

Befunge-93, 101010101010

6<_@#:-1.+4

I can't immediately think of anything shorter, but I think this is pretty good.

EDIT: got it from 161616161616 to 101010101010.

\$\endgroup\$
3
  • \$\begingroup\$ 100000000 \$\endgroup\$ Commented Jan 16, 2018 at 18:34
  • \$\begingroup\$ @JamesHolderness, why not just one d? \$\endgroup\$
    – Jo King
    Commented Jan 17, 2018 at 4:06
  • 1
    \$\begingroup\$ @JoKing I'm an idiot! No idea how I missed that. Can also do one c for a smaller number. \$\endgroup\$ Commented Jan 17, 2018 at 10:52
2
\$\begingroup\$

Commodore Basic, 1000000

1?1E6
\$\endgroup\$
2
\$\begingroup\$

F#, 10000000000000000000

Here's a pretty clever trick:

printf"%o"(1L<<<57)
\$\endgroup\$
2
\$\begingroup\$

Pure bash, 1125899906842624 (250, 16 digits).

echo $((1<<50))

This is the best pure bash I've come up with, not depending on any special conditions or using external commands.

Bash + POSIX, 100000000: (108, 9 digits)

bc<<<A^8   # bc with a here-string script that evaluates 10^8

Thanks to Digital Trauma's answer for bringing up bc and the fact that it accepts hex digits even with the default ibase=10. Glenn beat me to actually posting the bc-based answer, but I'll leave it in my answer as well for completeness.


I'm an infrequent golfer, so IDK if there are standard assumptions that rule this out, to avoid needing overly pedantic rules in every question:

Bash + rule-bending: 10737418240 (5 * 231, 11 digits)

The question doesn't appear to rule out the the long number being be part of a longer string (e.g. part of an error message):

$((5<<31))          # prints "bash: 10737418240: command not found"

Bash assuming a 5-digit PID: a 10-digit number (PID repeated twice)

echo $$$$       # depends on the shell's current PID being a 5-digit number

Or repeating 3 times to still work with a 4-digit PID: a 12 or 15 digit number. (e.g. 573057305730: The shell's PID repeated 3 times).

echo $$$$$$     # depends on the shell's current PID being a 4-digit number

test framework for the number-generating expression:

e='$((5<<31))'; eval decimal=$e;  echo "$decimal: srclen=${#e}  digits=${#decimal}"

test framework for whole commands (works with methods other than the error-message hack.)

e='bc<<<A^8'; eval decimal=\"\$\($e\)\";  echo "$decimal: srclen=${#e}  digits=${#decimal}"

up-arrow and edit e to try different numbers.


Ideas that didn't work: (for readability, not fully golfed and in a (subshell) to avoid breaking your interactive shell when testing.)

(set {1..9}; IFS=; echo "$*" )   # $* in double quotes joins with no separator if IFS is null.  Too much setup overhead

You could play silly tricks to get $0 to contain a long number, but then you'd have to count the whole bash -c 'echo $0' $((10**7)) as part of the program.

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

Self-modifying Brainf***, 111,000,000,000,000 (1.11e14)

_ represents a null byte \x00. Prints each digit 3 times. I'm also fairly certain this is minimal. Interleaving digits with code is longer. There are several shorter solutions where the number is of equal length, but not longer.

<[...<]_00001
\$\endgroup\$
2
\$\begingroup\$

PowerShell, 111111

"1"*6

If the newline counts, then "1"*5 prints 11111\n.

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

AppleScript, 10^3

1e3

Implicit output? :o

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

><> (fish), 1000010000

a:*:*:nn;

explaination:

duplicates and multiplies 10 to get to two 10000's then prints both, being ten total characters long, one more than the program character length

\$\endgroup\$
2
  • \$\begingroup\$ First reaction : meh, there must be something better, let's try using a loop, using ascii values as integer or even exiting with an error ! 1 hour later : <strike>damn you</strike> well done torcado ! \$\endgroup\$
    – Aaron
    Commented Mar 8, 2016 at 16:07
  • \$\begingroup\$ @Aaron haha yeah I also thought there was for sure a shorter way to do this but this is the best I could get. Thanks! \$\endgroup\$
    – torcado
    Commented Mar 16, 2016 at 17:00
2
\$\begingroup\$

marioLANG, 700666666005555550044444400333333002222220011111100 (51 digits for 49 bytes)

still no marioLANG anwser? well here's one,

Try it online

+
+
+
+
+
+!::::::<
+#======"
:>)::(-[!
="======#
\$\endgroup\$
2
\$\begingroup\$

Google Sheets, 15625

=5^6

equals 15625

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

Python 2, 1000000000

A simple program in a simple language. I have two answers depending on wether the python shell is permitted or not.

If it isn't, then:

print 1e9

Which is 9 bytes and outputs 1000000000, 10 bytes.

If it is, then:

1e3

Which is 3 bytes and outputs 1000, 4 bytes.

These ignore the .0 printed on the end of these numbers since the method returns a float and the question asks for an int.

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

Mathematica, score 120

5!

Contrary to the assertion in this answer, you don't need Print to print something in Mathematica. Mathematical operations like exponentiation and factorials are supported by default.

\$\endgroup\$
5
  • \$\begingroup\$ why did you change your score from 120 to 1024? \$\endgroup\$
    – Sparr
    Commented Dec 28, 2015 at 22:27
  • \$\begingroup\$ @Sparr It was a mistake, thanks for pointing it out. \$\endgroup\$
    – March Ho
    Commented Dec 28, 2015 at 22:28
  • \$\begingroup\$ @glenn I was under the impression the length of the number must be longer than the program itself. \$\endgroup\$
    – March Ho
    Commented Dec 28, 2015 at 22:33
  • 1
    \$\begingroup\$ "Write a full program (not just a function)"; this isn't a full program, it's a REPL snippet. \$\endgroup\$ Commented Dec 28, 2015 at 23:57
  • \$\begingroup\$ I think this would be a valid TI-BASIC answer too. \$\endgroup\$
    – kamoroso94
    Commented Dec 4, 2017 at 2:58
2
\$\begingroup\$

C, 1844674407370955161518446744073709551615 (40 digits)

main(){printf("%lu%1$lu",-1ul);}

Certainly not winning, but it's a fun challenge and this is a fun answer.

How it works:

  • The printf format specifier %lu prints a long unsigned integer.
  • The printf format specifier %1$lu prints the first long unsigned integer in printf's argument list.
  • -1ul in printf's argument list is -1 cast to an unsigned long. Since the value is negative and the integer is unsigned, it turns into the maximum value an unsigned long can hold.
\$\endgroup\$
1
  • 2
    \$\begingroup\$ Actually, -1ul is an unsigned long value 1, negated. (unsigned long)-1 would be -1 cast to an unsigned long. BTW, you could reduce the score a little by using -9ul. \$\endgroup\$ Commented Mar 12, 2018 at 10:59
2
\$\begingroup\$

Whitespace, 11111111111111111111111111111111111111 (38 ones)

Visible representation:

SSTTSSTTSNNSSNSSSTNSNSTNSTTSSSSNSNTTN

What it does:

     push -38
loop:
     push 1
      dup
       pnum
      add
     dup
      jn loop

Surprisingly short for a whitespace program. Other considered approaches were pushing a big integer followed by a sequence of duplicate-multiply but this proved to be less efficient.

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

Cubically, score 836,308,545 328,426,785 45,454,545 1,818

Knocked the score down by utilizing existing face values instead of wasting space messing with the notepad. Too bad I golfed it before the revision history kicked in :(

%22

Try it online! Explanation:

  • Functions are called strangely in Cubically. When the interpreter hits a function, it sets the internal "default function" to that function. Then, when it hits any integer, it calls the internal default function with that integer. So R1 will call R with 1, R11 will call R with 1 twice, etc.
  • %22 prints the value of the front face (18) two times.

Outdated:

Fun fact! Due to how functions are called in Cubically, for each extra byte (6 at the end) we add, we can multiply the output length. Example:

:5*6666%66

Prints 836308545836308545. :5*6666%666 prints 836308545836308545836308545. Etc.

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

Z80Golf, 123334567 (8 bytes)

00000000: 3cf6 30fe 3820 0176                      <.0.8 .v

Try it online!

Disassembly:

  inc a
  or '0'
  cmp '8'
  jr nz, ok
  halt
ok:

Runs as follows:

  • A is incremented, then or'd by '0', giving '1'.
  • This is not '8', so we jump past the halt.
  • Code runs through many NOPs into putchar ($8000). We print '1'. Then we effectively return: The PC is set to (SP) which is $f63c, the first word in memory (i.e. the first word of our code) – we never pushed anything, so we're stack-underflowing into our own code, interpreting it as 16-bit addresses. SP is incremented by 2, now $0002.
  • PC runs through NOPs from $f63c to $0000, the start of our code. A is incremented to '2'.
  • We jump past the halt again and run into $8000. We print '2', then jump to $fe30 and SP is now $0004. We run from there into $0000, the start of our code again.
  • We similarly print '3', but the next return address we pop is $2038, which means the PC reaches $8000 again before it reaches our code; so we print '3' again, then returning to $7601 and thus printing '3' a third time; before finally returning to $0000 where execution continues as normal. Now SP is $000a.
  • Nothing is weird past here: the return address will always be $0000 since SP is now pointing after our code. We count up printing '4', '5', '6', '7' until finally A = '8' and we halt.
\$\endgroup\$
2
\$\begingroup\$

Z80Golf, 111111111 (8 bytes) 11111111 (7 bytes)

00000000: 3676 6636 3b3e 31                        6vf6;>1

Try it online!

Disassembly

start:
  ld (hl), $76 ; 36 76 ; overwrite the 1st byte of program to `halt`
  ld h, (hl)   ; 66    ; h = $76; hl = $7600
  ld (hl), $3b ; 36 3b ; write `dec sp` to memory $7600
  ld a, $31    ; 3e 31 ; a = '1'

The main point is what happens after the program runs through the code. Every time before reaching putchar, the PC hits dec sp at $7600. This means each run of putchar increases SP by 1 instead of 2. So the return addresses become the following:

$7600 -> $7676 -> $3666 -> $3b36 -> $3e3b -> $313e -> $0031 -> $0000

Note that, when the return address is $7676, dec sp is skipped. So the ASCII 1 is printed 8 times in total.


Previous solution, 111111111 (8 bytes)

00000000: 3e31 0609 ff10 fd76                      >1.....v

Try it online!

Disassembly

start:
  ld a,$31  ; 3e 31 ; a = '1'
  ld b,9    ; 06 09 ; b = 9
loop:
  rst $38   ; ff    ; equivalent to "call $8000" or "call putchar"
  djnz loop ; 10 fd ; b -= 1; if (b) goto loop
  halt      ; 76

Arguably less clever than Lynn's solution but still an improvement. This uses the instruction djnz which is similar to dec b then jr nz, label, but one byte shorter. If b is not touched before the loop, b starts with zero and the loop runs exactly 256 times.

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

Alchemist, 11109876543210

a->Out_a!12a

Try it online!

Down from ~1e18 to ~1e14 thanks to @Jo King

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

Vyxal, 1 byte

Try it Online!

literal 10.

\$\endgroup\$
3
  • \$\begingroup\$ Score 0, 0 bytes \$\endgroup\$
    – lyxal
    Commented Jun 14, 2021 at 0:10
  • \$\begingroup\$ @lyxal I asked in TNB, and apparently 0 isn't positive. \$\endgroup\$
    – emanresu A
    Commented Jun 14, 2021 at 3:59
  • 1
    \$\begingroup\$ score 1, 0 bytes \$\endgroup\$
    – pacman256
    Commented Feb 6, 2023 at 19:46
2
\$\begingroup\$

Shakespeare Programming Language, 8.16e153 1.25e146

7 digits removed thanks to Robin Ryder.

,.Ajax,.Puck,.Act I:.Scene I:.[Exeunt][Enter Ajax and Puck]Puck:If notyou cat.Open
heart.You be twice you.Be twice you nicer I?If solet usact I.

Try it online!

Output:

124816326412825651210242048409681921638432768655361310722621445242881048576209715241943048388608167772163355443267108864134217728268435456536870912

Doubles the integer in a loop until it overflows the 32 bit signed integer type.

\$\endgroup\$
1
  • \$\begingroup\$ 1.24e146 by using I instead of zero and by overflowing one iteration earlier. \$\endgroup\$ Commented Jun 4, 2022 at 19:26
2
\$\begingroup\$

BitCycle (-u), 3.134e144

1v>v>v>v>v>v>v>v>v
AB~>~>~>~>~>~>~>~ v~
  >^>^>^>^>^>^>^>v>+
^                ~^!1BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB@

Try it online!
See it online!
The TiO has been truncated so that you can spend more time with your grandkids
This program multiplies the amount of bits entering by 256, then converts them to 1's and adds it to the output. Each time this happens, a bit moves 1 space through the line of B's. Once the bit reaches the @, the program terminates. The output can be expressed as: \$\sum_{n=1}^{60}256^n\$

BitCycle, 1.111e29 e26

~~ v
 ^~
AB~
~0<~BBB@
!

Try it online!
See it online!
This is a similar concept to the first one, but it outputs in binary. Specifically, 27 1's

BitCycle, 2.417e24

~~ v
 ^~
AB~
~0<~BBBB@
!

Try it online!
See it online!
The best of both worlds! This outputs a binary string of 81 1's, which, in decimal, is \${{2}^{81}}-{1}\$

\$\endgroup\$
1
  • 1
    \$\begingroup\$ Just as some other answers manipulate a string which is then output, your second answer prints a string of binary digits that can be interpreted as a base-10 integer. I'd say it's perfectly valid. \$\endgroup\$
    – emanresu A
    Commented Jun 5, 2022 at 6:09
2
\$\begingroup\$

Pascal,  \$1 \! \cdot \! 10^{43}\$  or   1

See also Free Pascal. This is a complete program according to ISO standard 10206 “Extended Pascal”, though. Write(1E43:1:0) prints (or ought to print) the value 10000000000000000000000000000000000000000000. The :1 specifies the minimum width the output shall occupy. The :0 disables scientific notation and prints exactly 0 digits after the decimal point. Since it doesn’t make sense to print the decimal point . if no digits follow, it also omits the . itself. This behavior is an Extended Pascal extension (in ISO standard 7185 only positive integer values are accepted as format specifiers).

program p(output);begin write(1E43:1:0)end.

Note the characteristics of the built-in data type real are implementation-defined. Write in conjunction with real (such as 1E43) always produces rounded output with respect to the last printed digit(s). For instance, using an implementation of Pascal that internally uses IEEE 754 floating point numbers (depending on the precision) you may observe rounding errors. This, however, is a circumstance outside of the realm of the programming language. Sample:

9999999999999999999740000000000000000000000

Mathematically speaking the smallest positive integer value we can print in Pascal which has a longer printed length than the corresponding source code is \$1\$ (positive one).

program p(output);begin write(1.0:42)end.

This will print (the casing of the letter E may vary):

 1.00000000000000000000000000000000000E+00

This is a representation of the value 1. The value 1 is in the domain of ℤ, the set of integers.

\$\endgroup\$
1
\$\begingroup\$

Bash, 100000000 (9 digits)

bc<<<A^8

Solution by @Digital Trauma ported to bash.

\$\endgroup\$
1
  • \$\begingroup\$ crap, I took a break from my answer before coming back to finish tidying it up and post it, and you snuck in ahead of me >.< \$\endgroup\$ Commented Dec 29, 2015 at 4:58
1
\$\begingroup\$

ResPlicate, score 111111111

2 9 0 49

I was thinking of all kinds of complicated ways to do this, but it turns out the solution is very simple. After one step, you get:

0 49 0 49 0 49 0 49 0 49 0 49 0 49 0 49 0 49

which is just 9 commands to print ASCII number 49, so "111111111" is output.

\$\endgroup\$
1
\$\begingroup\$

C, score ~10^26 (100000000000000004764729344)

main(){printf("%f",1E26);}

Apparently float failes there a little. Tested there.

\$\endgroup\$
1
\$\begingroup\$

BotEngine, floor(1065/9)

v
e1
ldddddd<
ldddddd<
ldddddd<
ldddddd<
ldddddd<
>ddddP

This is probably the largest number of d instructions I've ever used in a single BotEngine program.

\$\endgroup\$
1
\$\begingroup\$

Candy, 10

N

push the number 10 onto the stack. 10 is useful since it's ascii for \n

Candy dumps the stack on exit.

\$\endgroup\$
2
  • 2
    \$\begingroup\$ BTW, your score is the number printed, not the length of the code. \$\endgroup\$ Commented Dec 29, 2015 at 20:29
  • \$\begingroup\$ @ETHproductions oh, should I have printed something like 10 (1 digit)? \$\endgroup\$ Commented Jan 1, 2016 at 2:15
1
\$\begingroup\$

x86 MS-DOS .COM file, score 111,111,111,111

Hex dump of the 11 byte .COM file (to reverse the hex dump, pass it into xxd -r -seek -256):

0100: b4 02 b2 31 b1 0c cd 21 e2 fc c3                   ...1...!...

Unassembled using debug:

0100 B402     MOV AH,02         ; prepare to print character to stdout
0102 B231     MOV DL,31         ; ASCII '1' to be printed
0104 B10C     MOV CL.0C         ; counter=12
0106 CD21     INT 21            ; print
0108 E2FC     LOOP 0106         ; repeat until counter is 0
010A C3       RET               ; end
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

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