您的目标是仅使用十个字符的代码即可打印（至标准输出）最大数量的打印机。

• 您可以使用语言的任何功能，但内置指数功能除外。
  • 同样，您可能无法使用科学计数法输入数字。（因此，没有9e+99。）
• 程序必须在没有用户输入的情况下打印号码。同样，也不会读取其他文件或Web等信息。
• 您的程序必须计算一个数字并打印出来。您不能打印字符串，也不能打印相同的数字数千次。
• 您可以从10个字符的限制中排除打印任何内容所需的任何代码。例如，在使用该print x语法的Python 2中，您的程序最多可以使用16个字符。
• 该程序实际上必须在输出中成功。如果在世界上最快的计算机上运行需要一个多小时，则它无效。
• 输出可以是任何格式（这样你就可以打印999，5e+100等等）
• 无限是一个抽象概念，而不是数字。因此这不是有效的输出。

Wolfram语言

ack(9!,9!)

ack（9！，9！） =

输出以箭头符号表示。

Perl，> 1.96835797883262e + 18

time*time

可能不是今天最大的答案！但是等待足够的千年，它将成为现实！

用“足够的千年”来表达一些评论，实际上是指¹⁰⁰多年。

公平地说，如果宇宙的巨大冻结/热死是宇宙的终结方式（估计发生时间约为1 ⁰¹⁰⁰年），则“最终”值将约为¹⁰²¹⁴，这肯定比某些其他响应（尽管“随机量子涨落或量子隧穿会在10 ^{10 56}年内产生另一个大爆炸”）。如果我们采用更乐观的方法（例如，循环模型或多元模型），那么时间将无限长，因此在某个宇宙中某天的某个高位架构上，答案将超过其他一些答案。

另一方面，正如所指出的那样，time确实受到整数/长整数大小的限制，因此实际上类似的东西~0总是会产生大于time（即time架构所支持的最大值）的数字。

这不是最严重的答案，但我希望你们喜欢！

Wolfram ram 2.003529930×10 ¹⁹⁷²⁸

是的，这是一种语言！它驱动了受欢迎的Wolfram Alpha网站的后端。这是我发现的唯一内置Ackermann函数并将其缩写为少于6个字符的语言。

八个字符：

$ ack(4,2)

200352993...719156733

或≅2.003529930×10 ¹⁹⁷²⁸

ack(4,3)，ack(5,2)等要大得多，但过大。ack(4,2)可能是一个小时内最大的阿克曼数，可能是无法完全计算出的最大阿克曼数。

较大的数字以符号形式呈现，例如：

$ ack(4,3)

2↑²6 - 3 // using Knuth's up-arrow notation

规则说允许使用任何输出格式，因此这可能是有效的。该值大于10 ^{10 19727}，该值比此处的其他任何条目都大，重复的阶乘除外。

然而，

$ ack(9,9)

2↑⁷12 - 3

比重复的阶乘大。我可以输入的十个字符中最大的数字是：

$ ack(99,99)

2↑⁹⁷102 - 3

这是一个巨大的疯狂，即使您反复记录数字，宇宙也不足以代表其很大一部分数字。

Python2 Shell，3,010,301位数字

9<<9999999

计算长度：Python将在这些长数字后面附加一个“ L”，因此它报告的字符数多于数字的1个字符。

>>> len(repr( 9<<9999999 ))
3010302

前20码和后20码：

40724177878623601356... ...96980669011241992192

果酱，2×10 ^268,435,457

A28{_*}*K*

这将计算b，定义如下：

• 一个₀ = 10

• a _n = a _n-1 ²

• b = 20×a ₂₈

$ time cjam <(echo 'A28{_*}*K*') | wc -c
Real    2573.28
User    2638.07
Sys     9.46
268435458

背景

这遵循与Claudiu的答案相同的想法，但它并非基于此。我有一个类似的想法，在他发布他的消息后几分钟我就发布了，但是由于它没有在时间限制内出现，所以我将其丢弃。

但是，aditsu提出了升级到Java 8 的建议，以及我使用10的幂的想法，使CJam可以计算GolfScript无法达到的数字，这似乎是由于Ruby的Bignum的某些错误/限制所致。

这个怎么运作

A    " Push 10.                                                          ";
28{  " Do the following 28 times:                                        ";
  _* " Duplicate the integer on the stack and multiply it with its copy. ";
}*   "                                                                   ";
K*   " Multiply the result by 20.                                        ";

果酱，^≈8.1 ×10 ^1,826,751

KK,{)*_*}/

在我的机器上花费不到五分钟，因此仍有改进的空间。

计算得出₂₀，定义如下：

• 一个₀ = 20

• a _n =（n×a _n-1）²

这个怎么运作

KK,   " Push 20 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ]. ";
{     " For each integer in the array:                                 ";
  )*  " Increment it and compute the its product with the accumulator. ";
  _*  " Multiply the result with itself.                               ";
}/

Python 3、9 * 2 ^（7 * 2 ^ 33）> 10 ^ 18,100,795,813

9 * 2 ^（2 ^ 35）> 10 ^ 10,343,311,894

编辑：我的新答案是：

9<<(7<<33)

对于后代的旧答案：

9<<(1<<35)

十个字符。

我用十六进制打印数字，并且

您可以从10个字符的限制中排除打印任何内容所需的任何代码。例如，在使用print x语法的Python 2中，您的程序最多可以使用16个字符。

因此，我的实际代码是：

print(hex(9<<(7<<33)))

证明它在指定的时间内运行并生成指定大小的数字：

time python bignum.py > bignumoutput.py

real    10m6.606s
user    1m19.183s
sys    0m59.171s
wc -c bignumoutput.py 
15032385541 bignumoutput.py

我的电话号码> 10 ^（15032385538 * log（16））> 10 ^ 18100795813

由于开头的原因，比上面的wc打印输出少3个十六位数0x9。

Python 3是必需的，因为在python 2中，7<<33它将很长，并且<<不需要很长的时间作为输入。

我不能使用9 <<（1 << 36），因为：

Traceback (most recent call last):
  File "bignum.py", line 1, in <module>
    print(hex(9<<(1<<36)))
MemoryError

因此，这是a<<(b<<cd)我的计算机上可打印表格的最大数量。

很有可能，世界上最快的机器比我拥有更多的内存，因此我的替代答案是：

9<<(9<<99)

9 * 2 ^（9 * 2 ^ 99）> 10 ^（1.7172038461 * 10 ^ 30）

但是，我当前的答案是任何人提交的最大答案，因此它可能足够好。而且，所有这些都假设移位是允许的。从其他答案来看，它似乎是。

具有足够短的常量名称的任何语言，大约18位数字。

99/sin(PI)

我会将其发布为PHP答案，但可悲的M_PI是使它有点太长了！但是PHP会为此生成8.0839634798317E + 17。基本上，它滥用了PI：p中缺乏绝对精度的情况

哈斯克尔

没有任何技巧：

main = print -- Necessary to print anything
    $9999*9999 -- 999890001

可以说无需计算任何内容：

main = print
    $floor$1/0 -- 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216

改编Niet的答案：

main = print
    $99/sin pi -- 8.083963479831708e17

Powershell-1.12947668480335E + 42

99PB*9E9PB

乘以99 PB乘以9,000,000,000 PB。

J（((((((((9)!)!)!)!)!)!)!)!）

是的，很多。10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))不太准确。

!!!!!!!!9x

K /科纳：8.977649e261 1.774896e308

*/1.6+!170

• !170 创建一个从0到169的数字向量
• 1.6+ 向向量的每个元素加一个并转换为实数（范围为1.6到170.6）
• */ 将数组的每个元素相乘

如果Kona支持四精度，我可以做到*/9.+!999并达到1e2584。可悲的是，它没有，而且我只能达到双精度。

旧方法

*/9.*9+!99

• !99 创建一个从0到98的数字向量
• 9+ 向向量的每个元素加9（现在为9到107）
• 9.* 将每个元素乘以9.0（隐式转换为实数，因此从81.0到963.0）
• */ 将向量的每个元素相乘

HTML，9999999999

9999999999

.. 搞定了。

Python-变化，最多13916486568675240（到目前为止）

虽然不是很严重，但我认为这会很有趣。

print id(len)*99

在我尝试过的所有事情中，len最能使我获得大量ID的方法。

在我的计算机上产生了13916486568675240（17位），在此网站上产生了13842722750490216（也为17位）。我想这有可能使您低至0，但也可能更高。

Golfscript，1e + 33,554,432

10{.*}25*

在10 ^ (2 ^ 25)不使用指数的情况下，计算可以在96秒内运行：

$ time echo "10{.*}25*" | ruby golfscript.rb  > BIG10

real    1m36.733s
user    1m28.101s
sys     0m6.632s
$ wc -c BIG10
 33554434 BIG10
$ head -c 80 BIG10
10000000000000000000000000000000000000000000000000000000000000000000000000000000
$ tail -c 80 BIG10
0000000000000000000000000000000000000000000000000000000000000000000000000000000

9 ^ (2 ^ 9999)如果只给定足够的时间，它最多可以计算一次，但是将内部指数加1会使时间大约增加三倍，因此很快就会达到一小时的限制。

说明：

使用具有相同想法的早期版本：

8{.*}25*

分解：

8         # push 8 to the stack
{...}25*  # run the given block 25 times

每个块开始处的堆栈由一个数字（当前数字）组成。开头为8。然后：

.         # duplicate the top of the stack, stack is now | 8 | 8 |
*         # multiply top two numbers, stack is now       | 64 |

因此，堆栈逐步显示如下：

8
8 8
64
64 64
4096
4096 4096
16777216
16777216 16777216

...等。用数学符号表示的过程是：

n=0, 8                     = 8^1  = 8^(2^0)
n=1, 8*8                   = 8^2  = 8^(2^1)
n=2, (8^2)*(8^2) = (8^2)^2 = 8^4  = 8^(2^2)
n=3,               (8^4)^2 = 8^8  = 8^(2^3)
n=4,               (8^8)^2 = 8^16 = 8^(2^4)

wxMaxima〜3×10 ⁴⁹⁹⁴⁸（或10 ^8565705514）

999*13511!

输出是

269146071053904674084357808139[49888 digits]000000000000000000000000000000

不知道它是否完全符合规格（特别是输出格式之一），但是我可以打得更大：

bfloat(99999999!)

输出是

9.9046265792229937372808210723818b8565705513

这是大约10 ^8565705514这是显著比最顶级的答案大，在约2秒计算。该bfloat函数给出任意精度。

哈斯克尔（4950）

天哪，这不是很多！美元符号后以10个字符开头。

main=putStr.show$sum[1..99]

Mathematica，2.174188391646043 * 10 ^ 20686623745

$MaxNumber

十个字符。

Python外壳，649539 999890001

击败Haskell，这不是一个认真的答案。

99999*9999

Wolfram Alpha（网站算作一种语言）吗？

9! ! ! ! !

输出

10^(10^(10^(10^(10^(6.27...))))

感谢Cory提供的提示，即空格和括号都有效。

Befunge-93（1,853,020,188,851,841）

很高兴还没有人做过Befunge（这是我的利基市场），但是该死，我找不到增加该数字的任何巧妙技巧。

9:*:*:*:*.

所以是9 ^ 16。

:*

基本上将栈顶的值与其自身相乘。因此，堆栈顶部的值变为：

9
81
6561
43046721
1853020188851841

和

.

输出最终值。我很想看看是否有人有更好的主意。

我宁愿在上面发表评论，但显然我不能，因为我是菜鸟。

蟒蛇：

9<<(2<<29)

我会进行较大的移位，但是Python似乎希望移位的正确操作数为非长整数。我认为这接近理论最大值：

9<<(7<<27)

这些的唯一问题是它们可能不满足规则5。

Matlab（1.7977e + 308）

Matlab将最大（双精度）浮点数的值存储在名为的变量中realmax。在命令窗口（或命令行）中调用它会显示其值：

>> realmax

ans =

  1.7977e+308

Python，约。1.26e1388

9<<(9<<9L)

给出：

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414014099915140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414014099915140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L

至少Python 3.5.0（64位），大于10 ^ 242944768872896860

print("{:x}".format( 9<<(7<<60) ))

在理想的世界中，这应该是9<<(1<<63)-1，但是没有足够的字节用于此。这个数字太大，以至于几乎需要1 EiB的内存才能容纳它，这比我在计算机上拥有的要多一点。幸运的是，您只需要使用约0.2％的全球存储空间作为交换即可容纳它。二进制值1001后面是8070450532247928832零。

如果Python用于128位计算机，则最大值为9<<(9<<99)，这需要少于1 MiYiB的内存。这很好，因为您将有足够的可寻址空间来存储Python解释器和操作系统。

Cubix，9.670457478596419e + 147（非竞争）

****"///**

不竞争，因为Cubix比此挑战新。您可以在此处在线对其进行测试，但请注意，它实际上并没有打印数字。您必须*在运行最后两个秒后暂停程序才能在堆栈上看到该值。

这个怎么运作

Cubix是一个二维esolang，其中的代码被包裹在一个立方体上。此代码完全等效于以下多维数据集网，其中.是no-op：

    * *
    * *
" / / / * * . .
. . . . . . . .
    . .
    . .

然后运行代码，指令指针（IP）从最左侧的右上角开始。"打开字符串模式，在此模式下遇到的所有字符，直到下一个"将其字符代码压入堆栈。IP一直环绕代码，将3 /s（47），2 *s（42）和2 .s（46）压入堆栈，然后再次退出字符串模式。

这就是有趣的地方。第一个镜像/反映IP，因此它朝上。然后它绕立方体旋转，击中了这些字符：

           
    * *
  /     *      
  .     .      
    . .

3 *乘以堆栈中的前两项。现在，与大多数基于堆栈的语言（其中算术运算符会弹出其参数）不同，Cubix将先前的值保留在堆栈中。因此，这意味着计算46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976。

当IP /再次到达时，它被右移。然后，它到达下一个镜像并遵循以下路径：

    *  
    *  
    /         .
    .         .
    .  
    .  

两个星号再一次乘以前两个项目。然后镜像再次将IP指向正确，第三个镜像再次重复该过程：

      *
      *
      /     .  
      .     .  
      .
      .

最后，IP离开镜向东。最后两个星号再相乘两次，结果为9.670457478596419e + 147。可以用进行打印O，但是没有简单的方法可以执行此操作，因为几乎已经使用了多维数据集上的每个点。

斯卡拉2 ⁶³ -1

可怜，可怜的斯卡拉。至少需要8个字符才能获得一个BigInt值，但实际上没有足够的空间使其变大。

但是，只有7个字符的（计数）代码，我们可以打印出最大可能的正数Long：

print(-1L>>>1)

Brainf ** k 256-2147483647

>+[<+>+]<.

_{如果您忽略大多数编译器和解释器以与ascii等效的方式输出数据的事实（要保持简洁，它就是;））}，这将返回解释器/编译器的数据类型的最大值。

在某些系统上，这仅为256，尽管在某些系统上（例如，我的），这是32位整数的最大值，即2147483647。

编辑：

-.

将用更少的字符打印相同的内容

Perl，非竞争产品

我用它来突出一点有关perl的知识。

Perl不能真正与之竞争，因为它没有内置的bignums（当然，您可以加载bignum库）。

但是每个人都知道的并不完全正确。一个核心功能实际上可以处理大量数字。

该pack格式w实际上可以在base 10和base 之间转换任何大小的自然数128。但是，基数128的整数表示为字符串字节。位串xxxxxxxyyyyyyyzzzzzzz变为字节：（ 1xxxxxxx 1yyyyyyy 0zzzzzzz每个字节以1开头，最后一个除外）。您可以通过解压缩将这样的字符串转换为以10为底的字符串。因此，您可以编写如下代码：

unpack w,~A x 4**4 .A

这使：

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

您可以用4**4较大的值替换，直到感觉到它花费的时间太长或占用了太多的内存。

不幸的是，对于此挑战的限制来说，这太长了，您可以争辩说以10为基础的结果在成为结果之前就已转换为字符串，因此表达式实际上不会产生数字。但是在内部，perl确实执行了将输入转换为10的必要算法，我一直认为它很简洁。

TI-36（不是84、36），大约10个字节。9.999985426E99

较旧的计算器也可以编程到一定程度；）

69!58.4376

这非常接近TI计算器可以显示的最大范围：-1E100<x<1E100

Perl 6，456,574位数字

[*] 1..ↈ

没有TIO，因为需要2分钟才能运行。