text:
What is the smallest positive base 10 integer that can be printed by a program shorter (in characters) than itself?
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 = '
' + c.body.replace(OVERRIDE_REG, '') + '
'; }); var match = body.replace(/([^\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(''+lang+'').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); } }

<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Shortest Solution by Language

Language	User	Score

Leaderboard

	Author	Language	Size

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Number 1 on the Hot Network Questions. Not bad for a first question...

Are you saying <= the number or < the number? From reading the question, I guess <, but just in case.

@Kslkgh Strictly less than, otherwise the question is trivial for programs which implicitly print their last value.

Too bad Forth doesn't have an exponentiation operator.  8 8 ^ .  Seven bytes; would print an eight digit number—but it would take a lot of bytes to define ^

In 7, an esolang I made up a while ago but never implemented, the empty program would print 7. Of course, there's more reason to that than just "because I wanted it to", but it would be a little long to explain here...

Is 1.0 an integer?

It's too late now, but future challenges like this might do well to ask for scores stated as log10(number)

@WGroleau works fine in dc (see my answer below).

Integer?  Bother.  If it were floating-point, Commodore Basic: 1?π

Every Hot Network Question was number 1 at one point :P @trichoplax

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

@ZachGates that's not how the HNQ list works. ;)

@ZachGates Hot Network Questions is sorted by how many "arbitrary hotness points" a question is assigned. This means most questions never get to the top. This question reached over 200 hotness points at one point, keeping all other questions across the network off the number 1 spot.

@trichoplax I saw it at 367 hotness points at one point, beating everything else I've ever seen (except "Hello, World!" and The Programming Language Quiz).

I spent some time looking for a language that would somehow print "1" given the empty program. (Or "0", but I'm not sure that counts.) I couldn't find one, but perhaps it's out there? If anybody else knows a language, feel free to take the idea.

@DavidZ See the Retina answer.

@Martin ah, there it is. I guess it must have been buried near the bottom when I commented, or else I really really can't read :-P because I definitely didn't see it before.

This challenge is very clever in that basically any language can participate. IMHO, it should be a standard "first program" like "Hello, World!" and FizzBuzz.

Ok, but why is the question body and the title inconsistent?

I like how this user gained all 766 rep from this one question... Nice question.

That leaderboard snippet is very broken.

Can it be like 0000100001 when program length is 9 bytes?

@nrgmsbki4spot1 No, leading zeroes are explicitly disallowed

@histocrat Yes, 1.0 is an integer. It has two digits, so a corresponding program has a maximum size of one Byte. After all 1.0 is just a representation of an element in ℤ, the set of integers. I’m afraid that expressions such as 1×10⁸ or similar do not meet the challenge‘s criteria, though. The evaluation must have been done by your program. See also my Pascal submission.

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.

... WE HAVE A WINNER.

Just btw, I'd say the number of matches is infinite. The empty string can repeat an unlimited number of times and be matched infinitely.

@nicael Luckily, that's not how regex works. ;)

@MartinBüttner that depends on  your regex engine. I've definitely encountered systems that will crap out if you ever try to match the empty string.

@Sparr Most of the more common flavours can handle empty matches and treat them such that no two matches can start at the same index, but two can end at the same index (so there can be an empty match at the end of a non-empty one, but not at the beginning of a non-empty one and also no two empty matches in the same position).

I knew this had to be possible in some language... but it never even crossed my mind that that language could be Retina. +1

@nicael it depends on how you define matches and the number of matches. You could easily provide a definition that doesn't allow to have multiple matches at the same position, which is what is usually done.

I thought null programs weren't allowed in these challenges?

@LorenPechtel that rule applies only to quine challenges where the empty program is trivially a solution in most languages. I think it's fair game here, since this empty program actually has non-trivial semantics and Retina does not have this behaviour because of challenges like this but because it's the only consistent generalisation of its behaviour for all single-line programs.

Holy cow, a 0.  You beautiful genius.

Pyth, 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.

I like how your first attempt at using Pyth is just the letter T.

Well, I thought this would be the most readable Pyth program I'd see for a while, but this is impressively easy to understand.

This is a polygot, this works in 05AB1E too. http://05ab1e.tryitonline.net/#code=VA

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.

But there're already (at least) 5 similar answers, including the solution with A, because many golfing languages are defining A as 10.

@nicael Yes, that's true.  I claim this answer is different because bc is not a golfing language.  It is in fact a Posix-defined language available by default on just about any standard *nix system you can find.

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.

Brought a tear to my eye. Thank you for your contribution.

It will probably still beat Java... Hopefully.

Well, it beats C#...

Why 6 and not 9?

@immibis The goal of the challenge is to minimize the score, so it's not just minimizing bytes; putting 9 before would have increased my score unnecessarily.

But the number needs to have MORE digits than the size of the code.

@SuperJedi224 Corrected.

Link to this language?

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.

The esolang answers, while valid, are kinda boring. Glad to see one that isn't!

perl say 1e9 is slightly shorter, if you want to improve your golf score. (Though it's nowhere near the smaller integer for which this approach works...)

@derobert True. 1e1 would satisfy the problem statement and give a score of 10 (the lower, the better) (Assuming a char is 1 byte)

@dberm22 10 (2 characters) is not longer than 1e1 (3 characters)

@SuperJedi224 Ahh, I read it as the magnitude of the printed number has to be larger than the bytecount, not the number of digits in the printed number. Thanks for the clarification.

Wouldn't disp 1e8 work? I can't test at the moment but I don't recall MATLAB requiring parentheses for disp. Edit Oh nevermind, that just prints it as a string.

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

Maybe I’m missing something, but the string "E2" is only two bytes in UTF-8…

@JasperBryant-Greene ᴇ and E are not the same character. In TI-BASIC, ᴇ  is scientific notation and E is a variable.

Thanks :) I should have noticed that the character was subtly-smaller-than-full-height…

Wouldn't 3! score better?

@dberm22 3! has only 1 digit, we need at least 3.

@SuperJedi224 Ahh, I read it as the magnitude of the printed number has to be larger than the bytecount, not the number of digits in the printed number. Thanks for the clarification.

Can't ᴇ2 count as two bytes since the calculator's encoding isn't UTF-8, like Jelly?

@NobodyNada This time the question specifically said to score in UTF8, for some reason.

Oops, I misread that to say "this rule applies if your code is in ASCII or UTF-8."

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!

Cute! Thank you for your contribution.

More readable form? Really? xD

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

Stunning, really.

Wouldn't Write(new string('1',70)) be better?

You can write it out as a double rather than a string, which shortens it to 10^56 : class A{static void Main(){System.Console.Write(1e56);}}

@goric That just outputs 1E+56.

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

Score 1000 as you can see, I'm not sure it counts using the console though.

I don't know why it wouldn't count!

@Arandur I'm guessing "I'm not sure it counts" refers to the lower score of 1000, since that requires using the console as a REPL, rather than being a full program.

@tri exactly, made a clarification.

+1 for alert, I would not allow the automatic console output

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, I kept it.
Try it online!
Here's another approach, my take on the boring way that everyone and their grandmother used for this challenge.
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!

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

Brainf**k, 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.

I wrote a shorter answer, from scratch: link

@Mauris impressive!

Japt, score 10
A

As shows the score, prints 10.

This is not code golf;the goal is to print the smallest number, your score is 10.

@ppp "The number must be longer in bytes than the program -- have more digits than the code has characters" - OP's just edited.

You have not misunderstood; if the Japt program A prints 10, then this is a valid program with a score of 10.

Woohoo, my language is tied for first second place! glares at Retina

Any reason for downvote?

I think the shortest program that doesn't use a variable is #d, scoring 100. With no byte literals, it would be 8s2, scoring 1000.

Oh, 5l scores 120.

Also works in Stax for a score of ten.

Python 2, 101010101010
print'10'*6

PHP, score 10,000,000
<?=1e7;

This prints 10000000 as can be seen there.

Since the OP asked for the smallest integer, why did you pick an exponent of seven?  Does it print without commas?

@WGroleau it does print without any commas, http://justachat.freevar.com/test.php

Brainfuck, 3333333333333333333333333 (25 threes)
This is written "from scratch" so I think it's okay to post a separate answer:
-[>+>+<<-----]>-[-->.<]

23 bytes long.

I was considering a bf solution, are there any current interpreters that only output as numbers?

@RohanJhunjhunwala this outputs 51 (the ASCII code for "3") 25 times.

@LevelRiverSt what Im saying is that there might exist a bf interpreter that doesn't input as ascii and only does integer output, thus (-.) would output 255.

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.

I think something is wrong with your commit messages :P

@Doorknob冰 I don't know how to write commit messages, so I just use random emojis.

Ok, here's the real question: what does Q push?

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.

DC, 10000
4 chars program:
I4^f

5 digits output:
$ dc<<<'I4^f'
10000

+1.  Yep, I think that's optimal in dc.  Unusually bc is shorter.

I thought I was doing well with 6d^p (yielding 46656), but you have that beat - well done!

Vitsy, 7! = 5040
7FN
Outputs 5040.
Try it online!

Why not 3FN outputting 6?

@PeterTaylor The number has to be greater in length, not greater in magnitude.

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.

Python 2, 107918163081
print 69**6

You can remove the space between print and the 2.

@Bakuriu No you can't

69**6 is only 107918163081.

Interstingly enough, this also works in Perl.

Technically, you can remove the space by replacing it with a +.

CJam, score 10
A

Try it online!

Why not Y, score 2?

Because 2 is only one character, so it isn't longer than the source code.

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.

Presumably ... - perhaps System.out.print(BigInteger.TEN.pow(10)); - is that one character less? Sorry - nowhere near big enough - and .pow(10).pow(10) is longer.

You can replace interface with class.

But then main would need to be public.

you can shave off 2 characters by doing this for the for loop: for(A a:new A[81])

@OldCurmudgeon Would .pow(100) not work for some reason?

Why is it an interface??

Read the comment four comments above yours...

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!
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.

C++, 1e46
#include <stdio.h>
main(){printf("1%046d",0);}

Newline would require an additional 2 bytes, using format "1%048d\n"

I don't think C++ allows you to omit the return type of main().  OTOH, this would make a good C answer...

#include <stdio.h> => #include<stdio.h> or even #include<cstdio>

Jelly, score 120
5!

Calculates the factorial of 5. Try it online!

It specifies that the text encoding should be UTF-8 - is that followed here?

I was going to say -- this might be the first esolang that actually can't trivially answer this question.

@FlagAsSpam I missed that unusual rule. It's fixed now.

MATL, 1000
1e3

Note: latest GitHub commit 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

Perl, 1000000000
print 1e9

Straightforward.

Can't you reduce your score by using say?

That would require enabling the -E flag, I suppose. I'm not sure how to count that, in this challenge.

Since "-M5.010, when needed, is free," you shouldn't have to count it at all.

QBasic, 15625
?5^6

? auto-magically gets converted to PRINT, 5 to the power of 6 yields the most convenient number of more than 4 bytes.

QBasic automagically converts your code to PRINT 5 ^ 6 (which is 11 bytes) before it is run. I'm not counting the 2 bytes for the newline because that would be mean but strictly speaking even the empty QBasic program has two bytes...

@CJDennis If I save this in a .BAS file and ask QBasic.exe to /run that, it runs.

O, 10
A

Apparently the score is the number we print!

05AB1E, score 10
Code
T

Explanation:
T         # Puts 10 onto the stack
          # Implicit, print the last item of the stack

Mathematica, score 87,178,291,200
Print[14!]

This solution is not helped by the fact that it takes 6 characters to print anything.

Why do you want to use Print though? Raw operations are valid programs in Mathematica (answer)

@MarchHo the fact that you got away with it in the past does not mean it's generally legitimate to assume a REPL environment. ;)

@MartinBüttner I don't get your point. It manifestly does not "take 6 characters to print anything" for this question in Mathematica. I don't see where REPL environments come into play here.

@MarchHo if you run 14! from a script file, it will not print anything. It only prints something when typed into a notebook, which is a REPL environment.

@MartinBüttner I just tested in Mathematica 10, Get["C:\\test.txt"] containing the string 15! prints the expected output. Did I misinterpret what you said?

@MarchHo, try running MathematicaScript -script C:\test.txt.

@MarchHo what LegionMammal said. You are still invoking the code from a notebook. Mathematica code can be run as an actual script without a notebook environment just like any other programming language.

@MartinBüttner I was about to post in Meta, but someone beat me to it

@MarchHo See my comment on your answer.

We should create a golfing version of Mathematica. With one- or two-byte abbreviated commands and the massive Wolfram Language command set, it would do well in many of these contests.

@LegionMammal978 I love that name, I was assuming "MMA" but yours is better. Don't try to bite off the whole spec in one go -- maybe Mthmtca 0.1 can have shortened command names plus automatic universal right parenthesis (both relatively easy to implement), and leave everything else for version 0.2.

@MichaelStern The repository can be found here.

@LegionMammal978 yessir

@MichaelStern Give me a few minutes to test some things.

Echo[13!] works

@TùxCräftîñg That prints a leading >>.

Brian & Chuck, 11,111,111,111,111 (≈ 1.1e13)
?1<SO>{?
#{>.>-?

Here, <SO> stands for the "shift out" control character with character code 0x0E.
Try it online.
That's all my language covered then. :)
Explanation
The 1 in Brian's code (first line) is used for printing. Then <SO> is used as a counter variable. The rest is just a simple loop setup which prints that 1 while decrementing the <SO> down to zero.

Marbelous, 100000000000000000000000 (24 digits)
Previously 28, 26 digits
@1
-- 10 '0
=0 @1
!! \\ /\ '1

All the spaces are superfluous. Outputs 1 then 0 repeatedly while counting down in parallel. Layout and counter tweaked to produce the desired amount of output for a 23-byte program.

TeaScript, 10 points
e

The e variable is preinitialized to 10
Try it online

Isn't that confusing, given that e is another number?

@Cyoce true but variable Me is e so both are usable

Ruby, 1679616
p 6**8

Computes 68.

Java, 12345678910111213141516171819202122232425262728293031323334353637383940414243444546 (~1082)
Curent version:
interface N{static void main(String[]a){for(int i=0;i<46;)System.out.print(++i);}}

Previous version [score floor(1084/9)=111111111111111111111111111111111111111111111111111111111111111111111111111111111111]:
interface N{static void main(String[]a){for(int i=0;i<84;i++)System.out.print(1);}}

Original version (score 1093):
interface N{static void main(String[]a){System.out.print(java.math.BigInteger.TEN.pow(93));}}

><>, 10560
'*n`

Try it online!
'*n`'         Push chars to stack, giving [42 110 96]
     *        Multiply, giving [42 10560]
      n       Output 10560 as number
       `      Unrecognised char, so the program outputs with an error

Unfortunately, out of all chars smaller than ` which give a 5-digit output, none of [\]^_ work since they are valid instructions which don't cause the termination we require.

Labyrinth, 1001101
>1!:
@

As Martin predicted, one order of magnitude lower is possible! Try it online!
I'm not going to go into full details as to how Labyrinth works, but this trace should give a rough idea as to what's going on anyway:
Inst   Detail                                    Stack            Output
---------------------------------------------------------------------------------
>      Rotate row 0 right                        []

[Board update]
:>1!
@

1      * 10 + 1                                  [1]
!      Output                                    []               1
1      * 10 + 1                                  [1]
>      Rotate row 1 right                        []

[Board update]
:>1!
 @

:      Dup                                       [0 0]
>      Rotate row 0 right                        [0]

[Board update]
!:>1
 @

1      * 10 + 1                                  [1]
>      Rotate row 1 right                        []

[Board update]
!:>1
  @

:      Dup                                       [0 0]
!      Output                                    [0]              0
:      Dup                                       [0 0]
>      Rotate row 0 right                        [0]

[Board update]
1!:>
  @

:      Dup                                       [0 0]
!      Output                                    [0]              0
1      * 10 + 1                                  [1]
!      Output                                    []               1
:      Dup                                       [0 0]
>      Rotate row 0 right                        [0]

[Board update]
>1!:
  @

1      * 10 + 1                                  [1]
!      Output                                    []               1
:      Dup                                       [0 0]
!      Output                                    [0]              0
1      * 10 + 1                                  [1]
>      Rotate row 1 right                        []

[Board update]
>1!:
   @

1      * 10 + 1                                  [1]
!      Output                                    []               1
:      Dup                                       [0 0]
@      Halt

Come Here, floor(1042/9)
0CALL42cCOME FROM SGNcCALLc-1c1TELL49NEXT

Ungolfed:
0 NOTE It is illegal to "COME FROM" a nonexistant label.
CALL 42 c NOTE c=42
COME FROM SGN c NOTE If c>0, come back here after next reaching label 1
CALL c-1 c NOTE decrement c
1 TELL 49 NEXT NOTE I really don't understand why the parser requires NEXT here, but it does

NTFJ, 111111111111111111111111111111 (30 ones)
Code:
#(#~~~#@::::::)$::::*****(~#^

Explanation
One the first run through we push six 49s (ASCII value for one) to set up for the loop this only runs the first time because # is used to enter the loop.  On all subsequent runs the # is skipped and thus the loop is skipped as well.
After that as well as with all future runs we pop a value $ which for the first run is a 49 but for all subsequent runs is the zero used to skip the loop.  We then duplicate the TOS four times and output five times decreasing the total by one.  If the TOS is zero (i.e. not 49) we end the program otherwise we jump back to the first instruction immediately skipping to back to four duplications.
This outputs 30 ones and has a length of 29.
Additional solution
I thought since Conor O'Brien forgot about the : operator I'd do a solution without it to be fair to him.
#(##################~)~##~~~#@*~~##~~~~@*~~##~~~~@*$(~#^

This prints
100100100100100100100100100100100100100100100100100100100

I was going to make an explanation for this but I forgot how it works.

Wow, I like the alternative solution. Fantastic!

GolfScript, 3125
5.?

Computes 55.

Python 2, 1,000,000,000
Even lower than my other answer (but includes a trailing zero, which I did not count towards the score). Similar to the Matlab/Octave solution.
print 1e9

'Lowest integer' - the .0 at the end stops this from being valid.

@muddyfish: The integers are members of the set of all real numbers.  Representing an integer as a decimal string doesn't stop it from being an exact integer.  I won't fully parse with a function that only parses C integral types (like strtol), but the question asked for an integer, not an int.

I have to agree that although it does not look like an integer, it still satisfies all the mathematical properties of an integer.

Windows PowerShell, 1000
1e3

Another methods to achieve something similar, though not as small, may be
1KB   # 1024

Excel & LibreOffice Calc – 10000
=1e4

Save as challenge.csv, then open in Excel or Calc. Usually just double-clicking will do.

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

=1e4 would do for 10000.

C, 327228837632722883924195568 (28 digits)
main(){printf("%u%u%u");}

Undefined behavior is awesome!!! This solution probably doesn't count due to UB, but I just wanted to put the idea out there.
Using Coliru, I get that output every time.

Vim, 11111
5i1␛

Works by inserting the character 1 five times. Try it online!

Flurry, score 1

The empty program returns the identity function λa. a = λab. a b, which is the Church numeral representation of 1. The interpreter recognizes and prints it as such:
$ ./Flurry -nin -c ''
1

It takes the interpreter \$O(n)\$ time to convert from integer to decimal in order to print it, so any other answer would probably need to use character IO if it wanted to execute in reasonable time.

GNU sed, 100010001000100010001000 (~1e23)
Without any basic math support, just text manipulation, the easiest solution I found was to duplicate some starting number, 1000 in this case. Printing is implicit at the end of the script, 22 bytes in length.
s:$:1000:
s:.*:&&&&&&:

Try it online!
I believe this is the first sed answer to this question. It's also my first after a long break from code golf :)

this is the same size, but produces a slightly smaller number

@JoKing Nice. Do you want to post it separately or should I include it in my answer?

Feel free to update your answer. I don't actually know that much sed

Befunge 98 - 10000000000:
a8k:8k*.@

or:
a8k:8k*.q

The number printed has twelve didgits and the program is eleven bytes long.

Microscript/Microscript II, 100
2E

Haskell, 1001129150390625
main=print$75^8

Probably minimal. I can't think of a shorter way to make a large integer and print it than exponentiation (^); you need at least main=print$. Of all choices for base and exponent, 75^8 was the lowest number longer than the code.
EDIT: Thanks, Neil!

We still have no topic on meta that defines the minimum requirements for a full program. Maybe we can use the -e option of ghc and go with ghc -e "4^5" for a 3 byte program with a score of 1024.

Actually 75^8 is only 1001129150390625.

C++, 111111111111111111111111111111111111111111111111111111111111 (60 ones)
#include<cstdio>
int main(int c){while(c++<61)putchar(49);}

Translation of my C answer.

You could get 59 nines with int main(int c){while(c-->-putchar(57);)} for the second line. The same result could be get with a for instead and adding 2 ;.

You should post that yourself, it's quite clever!

Java, 10^72
interface A{static void main(String[]a){System.out.printf("1%072d",0);}}

Befunge (quirkster implementation), 123648
"**.@

Pushes the string **.@ onto the stack, wraps around, exits string mode, and executes it, multiplying the ASCII values of the last three characters and outputting the result as an integer.
Edit: Only works if the playfield width is considered to be implicitly set to the maximum line width, not right-padded to a default size. Thanks to James Holderness for the catch.

R - 134217728
cat(8^9)

I doubt it can be make any shorter having to use cat function. Pretty boring, though.
Edit: Improved thanks to Christian Sievers

My version answers with "1e+09", and anyway, why not 8^9?

Charcoal, 11111111
Ｆ⁸1

Try it online!
for(8)Print('1').
Charcoal could have done better (1111 score) if source was measured in Charcoal bytes.

Lost, score 111111111111111111111111111111111111 (39 36 ones)
/<<<<<%<@<<<?<<</
?+-*66<:<+1$<*77/

-111100000000000000000000000000000000000 score (-4 ones) thanks to @JoKing.
Try it online or verify that it's deterministic.
Explanation:
Explanation of the language in general:
Lost is a 2D path-walking language. Most 2D path-walking languages start at the top-left position and travel towards the right by default. Lost is unique however, in that both the start position AND starting direction it travels in is completely random. So making the program deterministic, meaning it will have the same output regardless of where it starts or travels, can be quite tricky.
A Lost program of 2 rows and 5 characters per row can have 40 possible program flows. It can start on any one of the 10 characters in the program, and it can start traveling up/north, down/south, left/west, or right/east.
In Lost you therefore want to lead everything to a starting position, so it'll follow the designed path you want it to. In addition, you'll usually have to clean the stack when it starts somewhere in the middle.
Explanation of the program:
? will pop the top item of the stack, and will skip the next character if it is NOT a 0. Because of this, the stack will be emptied completely due to the leading characters of both lines while traveling downwards. So the ? pops values, and we'll ignore the /, until the stack is empty. At this point, an implicitly pushed 0 is used for the ?, and the / is no longer skipped.
Another important fact is that in a Lost program, an @ will terminate the program, but only when the safety is 'off'. When the program starts, the safety is always 'on' by default, otherwise a program flow starting at the exit character @ would immediately terminate without doing anything. The % will turn this safety 'off', so when we now encounter an @ the program will terminate (if the safety is still 'on', the @ will be a no-op instead).
As for the program flow: all arrows and / reflects will lead the path towards the < between the % and @.
From there, the program flow will:

<: Travel left/west
%: Turn the safety 'off' (so if we would now encounter the @, the program will stop)
<<<<<: Continue traveling left/west
/: Reflect to a downwards/south direction
?: Pop the top value of the stack, and if it's NOT 0, skip the next operand. As mentioned earlier, this ?/ will clean the entire stack in case we started somewhere in between, after which an implicit pushed 0 will allow us to go to the next step:
/ (first row; first column): Reflect to a left/west direction
/ (first row; last column): Reflect to a downwards/south direction
/ (second row; last column): Reflect to a left/west direction

77*: Push 49 (push 7; push 7; pop and multiply the top two values)
<: Continue traveling left/west
$: Swap the top two values. If the stack only contains a single value, it will implicitly use a 0 to swap.
1+: Add one to this counter-value
<: Continue traveling left/west
:: Duplicate the top of the stack
<: And once again, continue traveling left/west
66*: Push 36 (push 6; push 6; pop and multiply the top two values)
-+: Subtract it from the duplicated counter-value
?: Pop, and if this is NOT 0, skip the next operand. The first iteration this will be -36, thus NOT 0, so it will skip the / when it wraps around to the other side and do the same again starting at 77*. This will continue until the counter-value has become 0, after which the mirror / is not skipped.

/ (second row; last column): In that case, it will reflect downwards/south
/ (first row; last column): Reflect to a left/west direction again
<<<: Continue traveling left/west
?: Pop the top value on the stack (the duplicated counter-value)
<<<: Continue traveling left/west
@: Terminate the program if the safety is 'off' (which it is at this point). After which all the values on the stack will be output implicitly. Using the -A program argument flag, these code-points (the 49s) will be output as a string of characters ('1's) instead without delimiter. Without this flag, it would output the 49s as numbers with space delimiters; so due to those implicit space delimiters, we can't simply push 1s and remove the -A flag.

I was able to shorten the program but I can't get 38, 1s. Try it online!

@AdHocGarfHunter Oh, I initially had the reversed. I was able to make it shorter, but couldn't figure out how to have less than 39 1s. Unfortunately 37 is a prime number, and 38/39 are only divisible by the pairs [[1,38],[2,19]] and [[1,39],[3,13]] respectively, which makes them annoying to work with.

@JoKing Very nice approach with the reflects! Thanks. :)

Pip, 1 byte
t

Outputs 10.
Try It Online!

Commodore Basic, 1000000
1?1E6

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.

why did you change your score from 120 to 1024?

@Sparr It was a  mistake, thanks for pointing it out.

@glenn I was under the impression the length of the number must be longer than the program itself.

"Write a full program (not just a function)"; this isn't a full program, it's a REPL snippet.

I think this would be a valid TI-BASIC answer too.

F#, 10000000000000000000
Here's a pretty clever trick:
printf"%o"(1L<<<57)

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.

AppleScript, 10^3
1e3
Implicit output? :o

gs2, 10
→

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

OP said UTF-8 (I disagree with the rules, but OP might not change them.)

This answer is invalid because this is 2 bytes in UTF-8, which is the encoding specified in the challenge.

@Mego CP437 and UTF-8 are compatible in the first 128 bytes. This is just a dingbat that represents the actual control character.

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

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.

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.

100000000

@JamesHolderness, why not just one d?

@JoKing I'm an idiot! No idea how I missed that. Can also do one c for a smaller number.

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

PowerShell, 111111
"1"*6

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

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

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 : damn you well done torcado !

@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!

marioLANG, 700666666005555550044444400333333002222220011111100 (51 digits for 49 bytes)
still no marioLANG anwser? well here's one,
Try it online
+
+
+
+
+
+!::::::<
+#======"
:>)::(-[!
="======#

Google Sheets, 15625
=5^6

equals 15625

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.

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.

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.

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.

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.

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.

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.

Alchemist, 11109876543210
a->Out_a!12a

Try it online!
Down from ~1e18 to ~1e14 thanks to @Jo King

Vyxal, 1 byte
₀

Try it Online!
literal 10.

Score 0, 0 bytes

@lyxal I asked in TNB, and apparently 0 isn't positive.

score 1,  0 bytes

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}\$

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.

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.

1.24e146 by using I instead of zero and by overflowing one iteration earlier.

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.

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.

BTW, your score is the number printed, not the length of the code.

@ETHproductions oh, should I have printed something like 10 (1 digit)?

Bash, 100000000 (9 digits)
bc<<.<

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.

C, score ~10^26 (100000000000000004764729344)
main(){printf("%f",1E26);}

Apparently float failes there a little. Tested there.

beeswax, 909090 823543
The new solution just computes 7^7, which is 85547 smaller than the old solution.
_7FB{

Explanation:
_       [0,0,0]•       create bee
 7      [0,0,7]•       push 7 on lstack
  F     [7,7,7]•       set all stack values to 1st value
   B    [7,7,823573]•  1st=1st^2nd
    {                  output lstack 1st to STDOUT

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.

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

Binary-Encoded Golfical, floor(1014/9)
Hexdump of binary encoding:
00 90 01 00 31 18 18 18 18 18 18 18 1D

Original image:

Magnified 80x, with color labels:

Explanation: Stores 49 (the code point of the digit 1), prints it as a character 7 times, then turns around and prints it seven more times before terminating.

ForceLang, 1013
io.write 1e13

Reng v.3.3, score 104976
Try it here!
I²²n~

Prints
104976

This squares I (18) twice, yielding 104976. n prints this, and ~ terminates.
Reng v.2.2, score 101010101010
{An}``````~

Previously, score 96549157373046880
Z{ZZ**}#xxxxxxn~

Prints 96549157373046880.

https://github.com/ConorOBrien-Foxx/Assorted-Programming-Languages/tree/master/Reng

Cy, score 134217728
8 9 ^ :<

8 9 pushes a 9 and an 8 to the stack (duh), ^ computes 8 ^ 9 (exponent, not xor), :< prints it.
This was not intended to be a golfing language, but this answer ended up pretty short compared to "real" languages. I didn't even need exponential notation!

AWK, 1e21
I didn't see an AWK answer, so here's mine.
Since a 'full program' was requested, this is the best I could come up with (full program is a bit fuzzy in AWK).
awk '{$0=1e21}1'<<<1

If we don't consider how the program is called as part of the program, then the score could be dropped to about 1e13 using:
 '{$0=1e13}1'

Python 3, 100000000000
One digit shorter than the current python 3
print(1e11)

prints 1*(10^11)

Jelly, score 100
³

Prints 100 when counting as 2 bytes in UTF-8.
Try it Online!

Carrot, 11111
1^*4

1     //"1" is pushed into the stack
 ^    //The stack is finished
  *   //Multiply or duplicate string operator (in this case it is the latter)
   4  //Duplicate the string 5 times (4+1)

"1" is pushed into the stack. Then the * operator duplicates the string 5 times, not 4 times because the * operator on strings always duplicates the strings 1 time more than what is stated, because duplicating it once is meaningless and hence it is removed. So the program outputs 11111.

PHP, 9223372036854775807
I know they're not the shortest for PHP but..
9223372036854775807
<?=PHP_INT_MAX;

10000000000000000000
<?=str_pad(1,20,0);

7, 16031, language postdates challenge
1603

Try it online!
It's unclear what "must be encoded in ASCII or UTF-8" means in 7. The most obvious meaning is that I have to write each command as a single character, and encode its name in ASCII (this is particularly suitable here, because that's an input encoding that the 7 interpreter understands). In this case, the best I can do is 16031 (the first character here is a literal that's never executed, thus could be any octal digit; 0603 outputs 06031, but leading zeroes are disallowed, so the best digit we can use here is 1).
Explanation
A 7 program is basically a sequence of literals that are pushed to the stack, unescaping them in the process; thus the "initial run" of the program is always fairly boring and just puts things on the stack. Then the rightmost stack element is executed (while leaving it on the stack), repeatedly until the program exits.
Although all the commands that can occur in literals have names, some of the commands that can appear as the result of unescaping don't. The usual convention I use for this on PPCG is to bold "active" commands (which do something interesting when executed), and leave "passive" commands (which just push an active command) unboldened. The four active commands that don't have names are then given the same name as the corresponding passive command, and thus I rely on the font to distinguish. 7's "stack" is a little strange, relying on separators | between elements (which are manipulated as though they were a character in the language).

||           1603    Initial stack and program; 6 is active, 103 are passive
|103                 Result after the program's initial run
|103         103     (implicit) Top stack element is copied to the program
|1031        03      1 appends 1 to the stack
716031       3       0 escapes the top stack element and removes the | before it
                     3 prints output, and exits if the stack is low

The output in this case is 716031. The first step in producing output is to check to see if it needs escaping (the algorithm for this is fairly complex, but typically boils down to making active commands passive, and enclosing passive sections in 7 … 6). In most of my 7 programs, it does (due to containing anonymous commands), but all the commands seen there have names (unsurprisingly, because we escaped it manually on the previous line), so no escaping is necessary. Next, the first character output in the entire program (here, 7) specifies the output format (7 means "the same as the input", so the output will be printed as a sequence of octal digits in ASCII). Finally, the remaining characters, 16031, will be printed directly (shown here without the bold because one they're printed, they aren't commands any more, just characters).
Interestingly, the victory condition is different from a code-golf, and that actually mattered. It's possible to write a smaller program that produces numerical output longer than itself: 163 outputs 71631 (basically because it doesn't escape explicitly, and implicit escaping by the 3 command always prepends a 7 to the output). However, in this case, although the program is shorter, the output is larger, so using a longer program gave a smaller score.

Common Lisp (GCL), 1586013445029888
(princ(exp 35))

Brachylog (2), 11111, language postdates challenge
1j₅w

Try it online!
Just makes five copies of 1 and prints them.

Check, score 1000010000
>10000pp

Pyke, 1 byte
T

Try it here!
In Pyke, as well as in Pyth, T is a constant pre-initialised to 10.

Brain-Flak, 106735757048926755512911448358783973263883108352
48 digits, 46 bytes.
(((()()()){})){({}[()]<(({({}[()])}{}){})>)}{}

Try it online! (but not really because it will error with a segment fault).
This uses the common triangular method, ({{}[()]}), but applies it recursively on the previous result. It starts with 6 as both the counter and the total and starts the loop, first decrementing the counter, then replacing the total with 2*triangle(total). Repeat a few times and it gets exponential, with each repetition roughly doubling the amount of digits.
Python code used to calculate the total:
def tri(t):
    return (t)*(t-1)/2

def f(n,t):
    for _ in range(n):
        t = tri(t)*2
    return t

print(len(str(int(f(6,6)))))

Try it online!

PHP, 10000000
10 million (8 digits) printed in 7 bytes:
<?=1e7;

Almost 2.5 years and I am the first to think of that? Amazing.

Perl 6, 10000000
1e7.say

Try it online!
I can't see any Perl6 solutions, so for completeness...

Attache, 8 bytes
8^9|Echo

Try it online!
Outputs 134217728.

Keg -hr, 10

Try it online!
Explanation
\n  # Push the newline character onto the stack (Ord code 10)

-hr # Print the item raw (i.e. as a number)

Keg, 100
d.

Pushes d and prints as integer. Fortunately 100 is a letter in the Keg code page.
Output is 100.
Other solution just for fun and has a larger amplitude(also 2 bytes):
ā

Output is 257
TIO

@FlipTack Thank you. Remember to also remind this answer.

10, using -hd and a newline

Shakespeare Programming Language, ~1.23e186
Prints 1234…95969798, the concatenation of all integers from 1 to 98.
,.Ajax,.Page,.Act I:.Scene I:.[Exeunt][Enter Ajax and Page]Page:You is the sum ofyou a cat.Open heart.Is you worse twice the square ofthe sum ofa big big big cat a pig?If soLet usAct I.

Try it online!
After many iterations, here is a version without any spare characters. The code is 186 characters, and the output is 187 characters.

Abusing integer overflow gets 8e153.

Intcode, 100000000000000000000000000000000
2,7,7,7,4,7,99,10000000000000000

This is almost certainly sub-optimal, given all it does is square the number given at the end.

naz, 100,000,000 11,111
1a5o

Explanation
1a5o # Output "1" five times

I slightly misunderstood the question at first — here's my original 8-byte solution:
1a1o1s8o

Burlesque, 1000 or 1111111
1e3
1cy7.+

Try it online!
First the boring method just printing 1000, or making an infinite number of 1s and clipping it to the length of the code+1.

Python - 52^7, 12 bytes
print(52**7)

Edit 1: (Rip 11-ception)
After (embarrassingly) miscounting bytes, I'm back with the smaller version that turned out to be necessary. 52^7 is 1,028,071,702,528, which (at my count) is 13 bytes, and 13>12.
Of course, if you could write things straight to STDOUT, you could get away with 5**6 or 15,625.

Isn't it 13 bytes?

Oops - gotta go fix that.

Pxem, 1000010000.

Filename: 10000.e.p (9 bytes)
Content: empty (0 bytes)

Total: 9 bytes

Try it online!

Bitcoin Cash Script (BitAuth IDE), 18 bytes
// Golfed
0x0340420f76769595
// The number 1000000000000000000 will be on top of stack

// Ungolfed
OP_DROP // clean up
<1000000> OP_DUP OP_DUP OP_MUL OP_MUL
// The number 1000000000000000000 will be on top of stack

Opcodes reference
Try it online!

Knight (v2), score 117649
O^7 6

Outputs \${7}^{6}=117649\$
Try it online!

C (gcc), >1E25, 25 bytes
main(){printf("1%025u");}

Try it online!
Not determined, not sure if any env make it const result

Using TurboC(C in 16-bit) always result in 1E25+256

Go, 111111111111111111111111111111111111111111111111111111, 53 bytes
package main
func main(){for i:=1;i<55;i++{print(1)}}

Attempt This Online!
Prints to STDERR.

GolfScript, 1010
10.

Try it online!
Same length as Lynn's but gives a smaller number by pushing two copies of 10 and (implicitly) printing them side-by-side.
Some fun alternatives include n). and n(., which extract the charcode of newline from the string "\n" to get 10 (leaving an empty string at the bottom)

Pyt, 100
2ᴇ
2             (push 2 onto the stack)
 ᴇ            (raise 10 to the 2nd power)
              (implicitly print)

Try it online!

Itr, score 120
5P
online interpreter
computes 5 factorial (120)

Itr, score 0

The empty program in Itr prints 0 which has a length longer than the source code but is not positive.

I'd argue the empty program doesn't count.  It outputs 0 and its length is 0, and the constraint was that the output needs to be longer than its length (not equal).  Were Itr to default to outputting 1, I think it would qualify.

Nibbles, score 1
/

Attempt This Online!
The Nibbles program "/" is 1 nibble or 0.5 bytes long, and outputs the value 1.
/       # full program
/$$     # with implicit args added
/       # divide
 $      # the input (which is assigned with
        # a value of 100 if no input given)
  $     # by the input (also assigned to 100)

Uiua, score 1073741824 100000
-1073641824 points from noodle man
&p1e5

Try it online!
Explanation
&p1e5
  1e5   # Push 1e5 to the stack
&p      # Print with newline

&pⁿ7 10 for 10000000, and while you're at it &p1e5 for 100000

Awk, 1000000
$0=1e6

Must be fed a newline.

MSM, 10101010
.;.;.01

7 byes for an 8 byte output. Repeatedly duplicates and concatenenates starting with 10.

Visual Basic .NET, 11111111111111111111111111111111111111111111111111111111111111111111111111111111111111 (86 ones)
Module A
Sub Main
System.Console.Write(New System.String("1"C,86))
End Sub
End Module

Oh dear. (This is shorter than using a loop, unless there's some fast way to do that that I don't know about.)

You don't need to write System..

k4, 10000
$ cat a.k; echo
_1e4
$ wc -c a.k
4 a.k
$ q a.k </dev/null
10000
$

The input file is missing its trailing newline, but that doesn't matter to the interpreter. The language's default behavior on reading code files is to print the output of any statement which is not explicitly suppressed, so all I have to do is create the number. Exponential notation creates floats though, so I have to floor it to create an integer, otherwise the output would be 10000f (the default representation of a float that has no fractional part).

dc, 117649
$ cat a.dc; echo
7 6^p
$ wc -c a.dc
5 a.dc
$ dc -f a.dc
117649
$

Inspired by WGroleau's comment on the question.

Six to the power of something?  Three bytes code.  What happens with five instead of six?

Never mind—I didn't see the seven space

Fortran 77, 36 ones
^Iwrite(*,'(36i1)'),(1,i=1,36)
^Iend

(where ^I represents the TAB character.  This is the first Fortran
program I've written or have even seen that uses TABs)

FORTRAN IV, 54 ones
      PRINT1,(1,I=1,54)
    1 FORMAT(54I1)
      END

Both solutions write a newline after the number.  Note that if you're using a line printer to look at the output, the first "1" will be interpreted as a page-feed and the numbers in the programs will need to be increased by 1, to 37 for Fortran 77 and to 55 for Fortran IV.

Insomnia, 129
i

Apart from i (105), r (115) or } (125) outputs the same result, since the position of the bit pointer doesn't matter when it's the last state-changing operation.

Python 3, 1028071702528
print(52**7)

One byte longer than Python 2, but the same approach.
EDIT: turns out my search wasn't exhaustive enough -- thanks, Neil.

52**7 is only 1028071702528.

Mumps, score 100000
W 1e5

Writes 10^5, or 100000. Had the newline not been optional, that would have added 2 more characters to the program:
W 1e7,!  ; this would output 10000000

Now that I mention it... it would be interesting to see how much would change on some of the winning answers if an explicit newline was required - especially the 0 or 1 byte answers. :-)

Python 2, 111,111,111,111
Lower than the other python answers
print'1'*12

C, 1407260946921681491238744 (25 digits)
24 characters:
main(){printf("%lu%u");}

The output is nondeterministic (which may disqualify this submission).  After a few million runs, I've only gotten 25 digit output.  Some day I should figure out what GCC is (setting up a.out to be) sprinkling past the end of the stack for printf() to use here.

Ceylon, 111111111111111111111111111111111111111111 (42 digits)
This was my second try:
shared void run(){print("1".repeat(42));}

A program with length 41, prints a string of 42 ones.

My first, more complicated try printed  112589990684262411529215046068469761152921504606846976 (54 digits):
shared void run(){print("``2^50````2^60````2^60``");}

This program has a length of 53 bytes.
Ceylon integers go just up to right under 2^63, which gives us only 19 digits. Due to the boilerplate here we need to concatenate three of them, which is done by the use of string templates (the contents of `` ... `` inside a string literal are evaluated as an expression and then converted into a string).
Then it was simply a point of looking up the powers of two with (relatively) smallest first digits (2^50 starts with 1125, 2^60 with 1152), such that the length of them sums to 54. I guess combining other powers might make the program slightly shorter, but this still will not beat the simple one above.

PHP, score 10,000,000,000
echo 1e10;

Assuming the opening/closing tags don't count, otherwise it's
<?=echo 1e13;

And if we allow non-PHP, we have <?=1e7 and 1e3 as options.  Taking the first answer as the "most correct" of the four.

Pylons, 10
B

How it works:
B # Push B to the stack. (pre-initialized to 10)
  # The stack is implicitly printed at the end of the program.

PHP, 100 ones, 23 chars
<?=str_repeat("1",1E2);

@MorganThrapp Thanks, fixed it.

@MorganThrapp bytes.... ok, now.

<?=str_repeat("1",23); works for score 11111111111111111111111.

<?=str_repeat(1,21); 21 ones, 20 bytes - <?=str_pad(1,20,0); - a one plus 19 zeroes, 19 bytes

Mathcad, 3 "bytes", 4 digits, 5040
Updated version.  See text of Original version for suppression of decimal places discussion.   As the original version, used one integer raised to power of another, I've also included what I think is the smallest number that meets the criterion.

Original (and wrong!) Version ...
Here's two Mathcad expressions (you may regard the "3" version as even more cheaty than the 8 version, hence my providing the two versions ...)

Mathcad doesn't have a "text" file as such.  It operates more as a 2D whiteboard, where you can either type characters and operators onto a "worksheet", or enter them via a single-click toolbar.  Mathcad stores the worksheet as an xml file.  From a user perspective, however, typing "cat" counts as 3 distinct characters, which I'm taking to be the equivalent of "bytes" for the purposes of golfing; pi is single character as well.   An operator, such as "=" (evaluate), "+" (add) or ":=" (define), also counts as a "byte".
There are also a number of settings, such as the number of decimal places shown displaying a real number, which are available from a dialog box.   If, for example, setting the number of decimals to zero counts as a 0 "byte" operation, then π= is the shortest one I can think of.  If this is regarded as cheating from a golfing perspective, then the exponent version should meet the spirit of the competition.

Nice answer, but the goal of this challenge is to print an integer that has more digits than the program has bytes, e.g. print a 3-digit number with a 2 byte program. Could you please fix this?

Doh!  yabinm (Yet Another Brain In Neutral Moment).

Oracle SQL 11.2, 30903154382632612361920641803529
SELECT''||POWER(9,33)FROM DUAL;

Desmos, 6561
9^4

equals 6561
previous answer, 1048576
2^{20}

equals 1048576

Forth, 1073741824 (2^30)
1 30 << .

Try it online
If the result could be left on the stack:
100663296
96 20 <<

Turtlèd, 100000000000
11:[*'0l]'1

11- set register to 11
: move right by amount in register
[*'0l] loop: [*   ]- while current cell is not *, '0- write zero to cell, l -move left
'1- write one

///, score 111111111111
/./111/....

Try it online!
/./111/ removes itself and replaces every . with 111, so .... becomes 111111111111.

DUP, 100100
'd$..

Put character d on stack, duplicate it, print its value twice.
Online DUP interpreter.
My Julia implementation on GitHub, with comprehensive language description.

tcl, 10000000000000000
puts [expr 1e16]

Outputs:
10000000000000000.0

The integer part is 1 and 16 zeros.
http://rextester.com/RWNL80143

Doesn't that make this answer invalid?

@LegionMammal978: Waiting feedback from question's author. 1e17 is still an integer!

"1e+17" has a length of 5, while your program has a length of 16

@12Me21: I don't have a + in 1e17!

The output does

@LegionMammal978: I hope my answer is now valid

@12Me21: I hope my answer is now valid

SmileBASIC, 16713480 1111111 10000
?1E4

Boring.
Previous Answers: ?-#CYAN, ?"1"*7

Underload, score 100000100000
(100000):*S

Syms, 999980001 1111111 (noncompeting)
1:7;*>

Try it online!

Alice, 3628800 (10!)
a/P
o@

Try it online!
Explanation
a   Push 10.
/   Reflect to SE. Switch to Ordinal.
    Reflect off bottom right corner, move back NW.
/   Reflect to W. Switch to Cardinal.
a   Push 10.
    Wrap around to the end of the first line.
P   Compute 10! = 3628800.
/   Reflect to NW. Switch to Ordinal.
    Immediately reflect off top boundary, move SW.
o   Implicitly convert the result to a string and print it.
    Reflect off bottom left corner, move back NE.
/   Reflect to S. Switch to Cardinal.
@   Terminate the program.

S.I.L.O.S, 28 byte, 111111111111111111111111111111 (29 ones)
x=29
lbla
print 1
x-1
if x a

Ugh! Looping is expensive!
Try it online!

Braingolf, 20
Oh hey look I can golf it now thanks to niladic stuff
+

Niladic + (ie run when the stack is empty) pushes 20 to the stack, implicit output.
Braingolf, 100
Just throwing in my 2 cents (or 2 bytes, as it were)
#d

Pushes the charcode of the character 'd' to the stack, which is 100. Braingolf will automatically print the last element of the stack when the code terminates if there is no semicolon present in the code.
Note:
As with every Braingolf submission thus-far on PPCG, this is non-competing, as the language was created on 3rd May 2017.

Yabasic/QBasic/VBA, 10000 4 bytes
Takes no input and outputs 10000to the console.
?1E4

Try it online!

Java, 1e66

Shortest full program I could make:
interface A{static void main(String[]a){System.out.print(1e66);}}

With 65 bytes, this program outputs:
1e66

Try it online!

Röda, score 10,000,000,000,000 (1013)
main{[10^13]}

Try it online!
Röda statement, score 1,000,000 (106)
[10^6]

The program is executed using this command (the flags are required to execute the program, so they are free):
röda -e "[10^6]" -n

Prolog(SWI), 1e+15
?-write(1e15).

Outputs (surprise surprise) 1.0e+15
Try it online!

Implicit, score 65
A

Pushes the ASCII value for A (65). Implicit output.

Commodore 64/VIC 20 BASIC, 5 PETSCII characters (excluding the carriage return)
 0?1E5

Some caveats here; firstly, Commodore BASIC adds in a white space before printing any number or numeric variable; secondly, there is no concept of true integer types in Commodore BASIC (I think that applies to all variants through to BASIC 7 on the Commodore 128); and finally LISTing the program will show its un-obfuscate form, and add in a white space after each line number, so the above symbolic listing becomes:
0 PRINT1E5

So, on that basis, it could be that this is automatically disqualified if these caveats are taken into account. Does my initial golfed version count as a valid entry?

Momema, score 10000000001000000000
01000000000-8*0-8*0

Explanation:
0  1000000000  #  [0] = 1000000000
-8 *0          #  print num [0]
-8 *0          #  print num [0]

Canvas, 10
Ａ

Try it here!
Ａ pushes 10 to the stack, then Canvas inplicitly prints the item at the top of the stack.

Pascal (FPC), 10^52 1111111111111111111111111111111111111111111111 (~1.1e46)
var i:word;begin for i:=1to 46do write(1)end.

Try it online!
Obvious one, I missed it somehow at first, thinking it would be bigger number.

Previous approach - 10^52 (10000000000000000000000000000000000000000000000000000)
uses sysutils;begin write(1,Format('%.52D',[0]))end.

Try it online!
Format is a function in sysutils which gives a string from specified formatting string and array of arguments. Formatting string works pretty much like in C: % starts the part which will be replaced, D means integer in decimal format, .52 for D means the number will be written with at least 52 digits; since 0 has less than 52 digits, it is left-padded with zeroes. 1 is written before it to make a valid integer.

Rust, 10²⁸ 10000000000000000000000000000 (28 bytes)
fn main(){print!("{}",1e28)}

Try it online!

Runic Enchantments, 1000
aC@

Try it online!
Huh, another classic I apparently never answered.
Because the number must be strictly longer than the program (so a 3 byte program requires a 4 digit number), this is as small as we can go (but there are two ways to do it).

Wren, 1e+24
Verbosity killed the wren. Calulates 10^24.
System.write(10.pow(24))

Try it online!

T-SQL, 100,000,000,000
SELECT 1e11

Note that the shorter PRINT 1e10 doesn't seem to work in this case; in the SQL versions I tested (2012 to 2017) it keeps the output in the exponential format (1e+010), which I assume isn't allowed.

W, 100
2^

Explanation
 ^ % 10 to the power of ...
2  % ... 2

Python 2, 137438953472 (2^37)
print 2**37

Code is 11 bytes long, output is 12 bytes long.

x86-16, IBM PC DOS, 111,111,111
B8 0A31     MOV  AX, 0A31H  ; AH = 0AH (write chars * CL), AL = '1'
B1 09       MOV  CL, 9      ; display 9 times
CD 10       INT  10H        ; call BIOS
C3          RET             ; return to DOS

This is based on @krubo's answer above, but 3 bytes shorter.  This uses the PC BIOS's INT 10,0AH function for output since it will repeat the same char CL number of times, saving the need for a  LOOP (-2 bytes).  Also, AL and AH can be initialized at the same time (-1 byte).

Fortran (GFortran), 24 ones
print*,("1",i=1,23)
end

Try it online!
Better Fortran score by avoiding formats entirely.

cQuents, 362880 161280 100100
#2;J4

Try it online!
J4 defults to base 2, and evaluates to 100 as a string. '100'+'100' = '100100'.

MAWP 1.0, 76543210
8[1A!:].

As suggested by Jo King.
Try it!
MAWP 1.0, 152587890625
5!W!W!W!W:.

Try it!

Wow, never thought of that.

RGBDS macros, 11,111,111,111,111,111,111,111
REPT 23
 PRINTI 1
ENDR

BitCycle, 100000000100000000 100000000000000
A\10v
~000~!

Try it online!
This program is 12 bytes long and outputs a 15 byte number. It starts with 5 bits, discarding one and printing a copy of the bits each iteration.
BitCycle actually outputs in bits (ones and zeroes), which can be interpreted as a decimal number as above. It is normally interpreted in unary with the -u flag.
BitCycle -u, 60328467484514692442875165185
AB/00v  ~DDDDD@
~111 ~CD^
!

Try it online!
Honestly, not that much longer, but this takes a huge amount of time to execute. The code at 27 bytes, with the number at 29 digits long, which was the shortest of this format that I could find. Essentially, this repeatedly does the sum of 1 to n (as in the triangular numbers) on the same value, starting at 5, which increases exponentially. Then it outputs the sum of all these numbers

Rec, 111111111111
The space before 49 is required, otherwise the character will not display properly. Well, it seems like it's a Python formatting issue.
12[0:^\49p]

Try it online!

ForWhile, score 1111111
7[49#)
prints 1 7 times
online interpeter
ForWhile, score 76543210
8(47+#)
online interpreter
For loop printing decreasing characters for 8+47 (ascii '7') downwards to 1+47 (ascii `'0')

Kotlin, score 123456789101112131415161718192021222324
fun main()=(1..24).forEach{print(it)}

probably could be improved but not sure how

Perl 5, 10000000
say 1e7

Try it online!

HP‑41C series, 1
This submissions presumes there are no other programs in program memory.
We merely need to increase the number of displayed digits before placing the number on top of the stack.
The default setting is to display and round to (up to) 4 places after the radix mark (FIX 4).
01♦LBL⸆T           5 Bytes    global label requires 4 + (length of string) Bytes
02 FIX 9           2 Bytes    display 9 digits after radix point
   NULL            1 Byte     invisible Null byte before numbers
02 1               1 Byte     push 1 on top of the stack (X ≔ 1)

shows, if flag 29 is set (the default),
 1.000000000

or, if flag 29 is cleared,
 1,000000000

If you want to print the number with an HP 82143A Printer, append a VIEW X command (2 Bytes) or shift the printer’s mode switch to the TRACE position (which will, however, print all the other commands, too).