[Question]
  [
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>
```
  
[Answer]
## [Retina](https://github.com/mbuettner/retina/), score 1
```
```
The empty program counts the number of matches of the empty regex in the input (which is the empty string). That's exactly 1 match, so it prints `1`.
[Try it online.](http://retina.tryitonline.net/#code=&input=)
[Answer]
# [Pyth](https://pyth.readthedocs.org/en/latest/index.html), 10
```
T
```
First attempt at using Pyth. Having had the question clarified, it seems 10 will be the smallest number. In Pyth the letter T starts off as the number 10, so this simply prints `10` which is larger than the length of the source code. You can [try it here](https://pyth.herokuapp.com/?code=T&debug=0).
[Answer]
# bc, 10
```
A
```
Luckily, `bc` prints the result of the last expression by default. `A` is interpreted as a hex digit, so results in `10`.
[Answer]
# Fishing, score ~~7,958,661,109,946,400,884,391,936~~ 1,208,925,819,614,629,174,706,176
Is this the highest non-trivial-looking score ever in a minimization challenge? (Even though it has been golfed by 84.8%)
```
v+CCCCCCCCCC
  `32`nSSSSP
```
---
Explanation
```
v              Sets the casting direction to down
 +             Increments the casting distance by 1
  CCCCCCCCCC   Casts the rod
`32`         Pushes a string "32" to the stack
    n        Converts the stack from a string to an integer
     SSSS    Repeated squaring of the stack
         P   Prints the stack
```
The number is `32^16` and has 25 digits. The code is 24 bytes long. The previous answer was `6^32`.
[Answer]
# MATLAB, 1,000,000,000 (109)
Also works with **Octave**
```
disp(1e9)
```
Never going to beat the esolangs, but just for fun, this is the smallest MATLAB/Octave will be able to do, so thought I would post it anyway.
[Answer]
# TI-84 BASIC, 120
```
5!
```
`ᴇ2` would score better if not for the silly UTF-8 requirement. (It's only two bytes in the calculator's native tokenized encoding, but it's 4 in UTF-8...)
[Answer]
# [Hexagony](https://github.com/mbuettner/hexagony), score 100100
Code:
```
d!!@
```
In a more readable form:
```
  d !
 ! @ .
  . .
```
The char value of `d` is 100. This will simply print the char value twice and terminates after.
[Try it online!](http://hexagony.tryitonline.net/#code=IGQgIQohIEAgLgogLiAu&input=)
[Answer]
## C#, score ~~10^72~~ ~~10^70~~ ~~10^64~~ 10^63
```
class A{static void Main(){System.Console.Write($"1{0:D63}");}}
```
That's 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000. I guess that I tried...
[Answer]
## JavaScript, score 100,000,000,000 (or 1\*1011)
```
alert(1e11)
```
This is if using alert. Though you can get 100 000 000 times lesser score if using console:
```
1e3
```
[![](https://i.stack.imgur.com/PZ6NV.png)](https://i.stack.imgur.com/PZ6NV.png)
Score 1000 as you can see, I'm not sure it counts using the console though.
[Answer]
# [PlatyPar](https://github.com/cyoce/PlatyPar), 59
```
#
```
`#` starts a numeric base-60 literal, and since no digits are found, it ends up as `59`. This started as a happy accident, but since I have already [ab]used this bug in [another answer](https://codegolf.stackexchange.com/a/66729/41042), I kept it.
[Try it online](https://rawgit.com/cyoce/PlatyPar/master/page.html?code=%23)!
Here's another approach, my take on the boring way that everyone and their grandmother used for this challenge.
# [PlatyPar](https://github.com/cyoce/PlatyPar), 100000000 (9 digits)
```
'18Md0+;
```
Explanation
```
'1        ## push "1" (a string) to the stack
  8Md  ;  ## repeat 8 times
     0+    ## add a 0
          ## [implicitly] print the result
```
[Try it online](https://rawgit.com/cyoce/PlatyPar/master/page.html?code=%2718Md0+%3B)!
[Answer]
# C, 1000000000000000000000000000 (28 digits)
```
main(){printf("1%027d",0);}
```
Similar to my C++ answer, without the `#include <stdio.h>`
(Ignore the warning about missing declaration of `printf`. Thanks @Dennis)
Newline would require an additional 2 bytes, using format `1%029d\n`
[Answer]
# [Brainf\*\*k](http://www.muppetlabs.com/%7Ebreadbox/bf/), 11111111111111111111111111111111111 (~1e34)
And another reduction:
```
+++++++[>+++++++>+<<-]>>[<.....>-]
```
Which gives 35 consecutive 1's, or approximately 1e34.
---
A bit smaller still
```
++++++++[>++++++>+<<-]>+>+[<....>-]
```
Gives 36 1's which is a number about 11% larger than 1e35.
---
Thanks to @Martin Büttner for knocking off a couple of characters reducing the total output by a factor of 100 with this code (yields 1e36):
```
++++++[>++++++++>++<<-]>+.->[<...>-]
```
---
My old code (yields 1+e38):
```
++++++++[>++++++>++<<-]>+.->+++[<..>-]
```
I've been experimenting with esolangs out of boredom. This is the best I could do in BF. I wonder if it is possible to make it smaller?
You can try it online [here](http://esoteric.sange.fi/brainfuck/impl/interp/i.html).
[Answer]
## [Japt](http://ethproductions.github.io/japt/), score 10
```
A
```
As shows the score, prints 10.
[Answer]
## Python 2, 101010101010
```
print'10'*6
```
[Answer]
## PHP, score 10,000,000
```
<?=1e7;
```
This prints 10000000 as can be seen [there](http://justachat.freevar.com/test.php).
[Answer]
# Brainfuck, 3333333333333333333333333 (25 threes)
This is written "from scratch" so I think it's okay to post a separate answer:
```
-[>+>+<<-----]>-[-->.<]
```
23 bytes long.
[Answer]
## [Labyrinth](https://github.com/mbuettner/labyrinth), score 10,000,000
```
1!!!!>@
```
It might be possible to bring this down by one order of magnitude, but I can't find anything right now. 
The first `1!!!!` prints `1000`. Then `>` shifts the source code to
```
@1!!!!>
```
which avoids early termination. Then the IP hits a dead end and turns around. Now `!!!!` prints four more zeroes and `@` terminates the program.
[Try it online.](http://labyrinth.tryitonline.net/#code=MSEhISEKQA&input=)
[Answer]
# [Samau](https://github.com/AlephAlpha/Samau), 42
```
A
```
`A` pushes the Answer to the Ultimate Question of Life, The Universe, and Everything onto the stack. Then the top of the stack is automatically printed.
[Answer]
# [DC](https://rosettacode.org/wiki/Category:Dc), 10000
4 chars program:
```
I4^f
```
5 digits output:
```
$ dc<<<'I4^f'
10000
```
[Answer]
# [Vitsy](https://github.com/VTCAKAVSMoACE/Vitsy), 7! = 5040
```
7FN
```
Outputs 5040.
[Try it online!](http://vitsy.tryitonline.net/#code=N0ZO&input=)
[Answer]
# C, 11111111111111111111111111111111111 (35 ones)
```
main(c){while(c++<36)putchar(49);}
```
Maybe there's a shorter way. The lack of a simple way to print big numbers in C makes it tricky.
[Answer]
# CJam, score 10
```
A
```
[Try it online!](http://cjam.tryitonline.net/#code=QQ&input=)
[Answer]
## Python 2, 107918163081
```
print 69**6
```
[Answer]
# Java, 111111111111111111111111111111111111111111111111111111111111111111111111111111111 (81 ones)
```
interface A{static void main(String[]a){for(A i:new A[81])System.out.print(1);}}
                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
I've underlined the part that is actually "variable" here; everything else is absolutely necessary for a working Java program.
Presumably this is shorter than mucking around with Java's `BigInteger`.
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 100100
```
@'dOu
```
Cubix is a 2-dimensional, stack-based esolang. Cubix is different from other 2D langs in that the source code is wrapped around the outside of a cube.
[Test it online!](https://ethproductions.github.io/cubix/?code=QCdkT3U=&input=&speed=3)
## Explanation
The first thing the interpreter does is figure out the smallest cube that the code will fit onto. In this case, the edge-length is 1. Then the code is padded with no-ops `.` until all six sides are filled. Whitespace is removed before processing, so this code is identical to the above:
```
  @
' d O u
  .
```
Now the code is run. The IP (instruction pointer) starts out on the far left face, pointing east.
The first char the IP encounters is `'`, which pushes the next byte onto the stack; this byte is `d`, or `100`. Next is `O`, which outputs the top item (100) as an integer.
Then the IP hits `u`, which turns it to the right, moves it forward, then turns it again. It switches to the bottom face pointing north, then rotates to the east. This wraps it to the `O` again, outputting 100, then up to `@` which terminates the program.
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), score 120
```
5!
```
Calculates the factorial of 5. [Try it online!](http://jelly.tryitonline.net/#code=NSE&input=)
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 1000
```
1e3
```
*Note: [latest GitHub commit](https://github.com/lmendo/MATL/commit/77a5eba228ccedec8ac0d58d0f1842aba03858cc) of the compiler works on Octave as well as on Matlab.*
This interprets the number in scientific notation, and implicitly prints it, thus producing the output
> 
> 1000
> 
> 
> 
[Answer]
# Perl, 1000000000
```
print 1e9
```
Straightforward.
[Answer]
## C++, 1e46
```
#include <stdio.h>
main(){printf("1%046d",0);}
```
Newline would require an additional 2 bytes, using format "1%048d\n"
[Answer]
# O, 10
```
A
```
Apparently the score is the number we print!
]