十个字节的代码中最大的数字


77

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

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


21
您所说的“计算”到底是什么意思。另外,If it takes longer than an hour to run on any computer in the world, it's invalid.不是客观的。我可以(理论上)制造一台计算机,该计算机需要一个小时才能更改一个T形状态
user80551 2014年

4
移位等效于幂运算符* 2^x吗?
Claudiu 2014年

14
时间限制取决于世界上最快的计算机的性能,这一事实使我们无法确定有效答案的集合……我不是很喜欢
David Z

6
不允许使用幂函数,但可以使用ackermann函数吗?那似乎真的很武断。尚不清楚为什么将符号操作视为“计算”数字。
WolframH,2015年

Answers:


26

Wolfram语言

ack(9!,9!)

ack(9!,9!) =在此处输入图片说明

输出以箭头符号表示。


3
@KyleKanos有所不同,因为代码/程序没有调出网络。其他例子typescriptlang.org/Playground tryfsharp.org/Learn/getting-started
亚当斯佩特

35
Wolfram语言可用于Raspberry Pi,并且不需要Web访问。因此,不违反该规则。
Adam Speight 2014年

6
我认为这是非常有效的答案。在岛上无法访问互联网的愚蠢推理。“无网络”要求仅是为了防止从现有资源打印输出。只要它们“运行”一段代码来计算输出,所有答案都是有效的。最新的Visual Studio即将在Azure云上运行您的代码,因此您要限制C#吗?或者,如果您有Chromebook,那么您不符合资格?
microbian

26
ack(99!,9)大得多。
jimmy23013

11
另一个答案之一是ack(4,2)是他在一小时内可以计算出的最大值,所以如果这样做的话,我会感到惊讶...
Jerry Jeremiah

120

Perl,> 1.96835797883262e + 18

time*time

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


编辑:

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

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

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

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


23
Upvoted因为我喜欢不测
蒂姆·

5
会不会time在某个时候回绕并返回少量数字?取决于我猜是32位还是64位Perl
Claudiu 2014年

3
1000年〜3e10秒,因此您的输出仍将徘徊在1e21左右。也许如果您等待1e50年,您可能会开始与其他答案竞争?
Kyle Kanos 2014年

8
这个时间是“时间乘以时间”吗?:
Pierre Arlaud

1
宇宙死亡热所花费的时间是否可以解释夏令时?您可以再生存几秒钟。
Alpha

65

Wolfram ram 2.003529930×10 19728

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

八个字符:

$ ack(4,2)

200352993...719156733

或≅2.003529930×10 19728

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

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


85
不错,但这与我的ack(4,2)+1解决方案不符。
user19057 2014年

13
ack(4,2)+2,我赢了

1
我想你赢了。
2014年

20
@Kyle,Yimin这篇文章及其下的评论有很多误导性陈述。这不是 Wolfram语言,也不是W | A的后端。它只是Wolfram | Alpha的“自然语言”输入。Wolfram语言ack(4,2)中的输入无效。W | A的自然语言输入甚至不应算作编程语言。它不是图灵完整的,您甚至不能在其中编写基本程序,例如Euclid的算法。因此,我认为这不是Google查询所能提供的有效答案。
Szabolcs 2014年

4
Wolfram语言是Mathematica中使用的编程语言,在此处记录。Wolfram | Alpha将自然语言作为输入,而不是Wolfram语言。
Szabolcs 2014年

30

Python2 Shell,3,010,301位数字

9<<9999999

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

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

前20码和后20码:

40724177878623601356... ...96980669011241992192

2
该死!我在写同样的答案时就发现了这一点
James_pic 2014年

2
那真的很简单9 * 2**9999999,因此可以说它使用了幂运算。
丹尼斯2014年

2
等待,***built-in*** exponentiation functions不允许,所以这可能会违反规则。+1
user80551 2014年

1
计算长度的数学方法:floor(log10(9 * 2**9999999))+1
贾斯汀

8
9 <<(9 << 99)如果终止则大很多。
基思·兰德尔

29

果酱,2×10 268,435,457

A28{_*}*K*

这将计算b,定义如下:

  • 一个0 = 10

  • a n = a n-1 2

  • b = 20×a 28

$ 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,定义如下:

  • 一个0 = 20

  • a n =(n×a n-12

这个怎么运作

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.                               ";
}/

21
哈哈,那是柯比吗?:)
aditsu

您能描述一下这是做什么的吗?
Kyle Kanos 2014年

2
仅供参考,我进行了一些测试以检查BigInteger的性能-我计算出100000!并转换为字符串。结果:java 6:21秒计算,toString 44秒;Java 7:14秒计算,toString 42秒;Java 8:5秒计算,1秒toString!
aditsu

1
@aditsu:升级Java可以将运行时间从5分钟减少到2秒!
丹尼斯

20

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)

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


到目前为止,这似乎是迄今为止最大的答案。毕竟,这是一个10,000,000,000的数字。
nneonneo 2014年

1
@nneonneo:我相信我的解决方案会更大:)
Zaid

您的替代答案需要的内存少于1 MiYiB,并且需要100位可寻址内存(因此,至少要有128位Python才能使用)。(资料来源:我类似的答案
wizzwizz4

19

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

99/sin(PI)

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


1
你不能晒黑(PI / 2)吗?
user80551 2014年

1
@ user80551可以,但是我只是注意到我可以利用限制中的最后一个剩余字符将结果提高99倍。
Niet the Dark Absol 2014年

Common Lisp中的时间太长:(/ 99(sin pi))(14个字符)。TI-83中的错误:99/sin(π(8个字符)导致被零除。在作品的LibreOffice Calc中=99/SIN(PI((10个字符,不计算=)计算808423047055000000. LibreOffice的自动插入最后两个))=99/SIN(PI())
kernigh 2014年

这取决于语言的精度。在PHP 14中,十进制数字是一个常用值。
kenorb 2014年

@kernigh在这种情况下没有关系,但是会99/sin(π是五个字节还是八个字节?我知道TI-BASIC将一堆命令存储为单个字节。是sin(其中之一吗?
wchargin 2014年

16

哈斯克尔

没有任何技巧:

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

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

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

改编Niet的答案

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

第三个项目符号说“您的程序必须计算 ...”
user80551 2014年

8
floor(infinity)是一个有限的数字?什么哈斯克尔?
nneonneo 2014年

3
1/0!=无穷大,未定义。
RubberDuck

1
您确定吗,@ ckuhn203?在GHC 7.6.3和7.8.2中,我得到isInfinite $ 1 / 0 -- True。据我所知,IEEE 754定义 1 / 0为无穷大。
Taylor Fausak 2014年

2
哦,你的意思是数学上的。我完全同意。但就使用IEEE浮点(尤其是Haskell)进行编程而言,1 / 0 == Infinity
Taylor Fausak 2014年

15

Powershell-1.12947668480335E + 42

99PB*9E9PB

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


7
98901 PB 这是用来测量(未来大容量)硬盘的表面位密度的某种方法吗?
user80551 2014年

不错哦。现在还不知道PB是可能的。我一直以为它停止在TB上。
2014年

@Joey现在,如果MS只急着增加yobibytes,答案可能会更好。
雷纳特2014年

1
如果有帮助,我可以将其添加到Pash ... ;-)
Joey

1+“ 1” * 309输出1.1111e308,尽管我认为这违反了精神,如果不是印刷字符规则的话。它强制转换为输出的两倍。
tomkandy '16

14

J(((((((((9)!)!)!)!)!)!)!)!

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

!!!!!!!!9x

5
确实找到了一个编译器,但是20分钟后,!!9x它没有在屏幕上打印任何内容。我真诚地相信那!!!!!!!!9x永远被计算。
Kyle Kanos 2014年

16
“如果在世界上最快的计算机上花费超过一个小时的时间,那将是无效的。” 不确定这样做是否会在一小时内生效
Claudiu 2014年

11
花了70分钟,但!!9x最终打印到屏幕上。我印象深刻的是它实际上计算的值,但它仍然完全失效子弹5
凯尔Kanos

6
@Quincunx:可能是正确的,但是有效答案的条件是程序必须成功输出;这个答案完全不符合该标准。可悲的是,支持者忽略了所有指出这一点的评论,仍然在CJam&Golfscript答案上予以支持,这些答案非常庞大并且可以在合理的时间内计算出来。
Kyle Kanos 2014年

3
拒绝投票,因为它不能打印出答案。
isaacg 2014年

14

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)
  • */ 将向量的每个元素相乘


11

Python-变化,最多13916486568675240(到目前为止)

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

print id(len)*99

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

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


好主意,但不幸的是,它什么都没有calculate
user80551 2014年

3
我确实相信该*99零件会调用计算。
突击队

哦,是的,/ me现在感觉很蠢。
user80551 2014年

1
如果您使用较短的内容(例如id(id)或)id(0j),则可以乘以999
gnibbler

1
docs.python.org/2/library/functions.html中的较小名称中,vars始终给出最高值(但4个字符),后跟sum。使用print(sorted([(id(x),x)for x in[id,len,max,min,str,int,ord,chr,sum,map,abs,all,any,bin,bool,eval,oct,vars,iter,list,set,repr,round,zip,type,pow,dict,dir,hex]])[::-1])检查。
user80551 2014年

10

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)

您的输出中2564前面的两个数字有什么关系?
Kyle Kanos 2014年

@KyleKanos:这不是我的输出,是的输出wc。我将进行编辑以使其更清楚
Claudiu 2014年

您可以wc -c用来使输出更清晰
daniero

真好!几分钟前我也有同样的想法,但是CJam的运行速度要慢得多(这令人惊讶,因为它通常比GolfScript快)。
丹尼斯

1
轻微改进:10{.*}25在我的机器上输出33,554,434位数字,并在90秒内完成。我不知道为什么,但是10{.*}26*什么也不打印。
丹尼斯

7

wxMaxima〜3×10 49948(或10 8565705514

999*13511!

输出是

269146071053904674084357808139[49888 digits]000000000000000000000000000000

不知道它是否完全符合规格(特别是输出格式之一),但是我可以打得更大:

bfloat(99999999!)

输出是

9.9046265792229937372808210723818b8565705513

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


6

哈斯克尔(4950)

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

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

为什么不只是print呢?另外,9/0.000001大于sum[1..99]
泰勒·福萨克

5
以这种速度,我们可能会认为9 999 999 999是结果的下限。
2014年

@TaylorFausak这个答案显然是不被重视的!
Flonk 2014年

6

Mathematica,2.174188391646043 * 10 ^ 20686623745

$MaxNumber

十个字符。


7
从技术上讲,它在计算什么吗?是否输出所有数字而不仅仅是科学计数法?

@Yimin:输出可以采用任何格式(因此您可以打印
999、5e

该值不是在编译时设置的,而是取决于在其上运行命令的特定计算机。我认为这很重要。
Michael Stern 2014年

5

Python外壳,649539 999890001

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

99999*9999

6
9999999999更大,不是吗?
MadTux 2014年

5
@MadTux答案有一个模棱两可的限制calculate
user80551 2014年

1
如果这个答案是正确的,那么我的9**9**9**9也是正确的,因为它是算术运算符(不是内置函数)。
kenorb 2014年

3
@kenorb 不允许使用幂运算
user80551 2014年

5

Wolfram Alpha(网站算作一种语言)吗?

9! ! ! ! !

输出

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

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


我敢肯定,这是我发帖时线程中最大的数字,但是Wolfram很难将其与其他数字进行比较,甚至((99!)!)! > 4永远不会返回。
gggg 2014年

这违反了说不能从网络上获取的规则。
Kyle Kanos 2014年

1
W | A太多!
2014年

5
我不同意这违反了规则。它不会“违背规则地从网络上读取”它,而是确实会“计算出一个数字并打印出来”,这正是它应该做的。唯一可用的界面是网站这一事实并不意味着它不能算作编程语言。
gggg 2014年

1
这是一个完全有效的答案。
microbian

4

Befunge-93(1,853,020,188,851,841)

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

9:*:*:*:*.

所以是9 ^ 16。

:*

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

9
81
6561
43046721
1853020188851841

.

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



4

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

蟒蛇:

9<<(2<<29)

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

9<<(7<<27)

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


3

Matlab(1.7977e + 308)

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

>> realmax

ans =

  1.7977e+308

由于OP要求返回计算值,因此应输入realmax+1。我尝试它很有趣,但惊讶的是它返回的数字与您的数字完全相同(然后,当我意识到...时我笑了eps(realmax)=1.99584030953472e+292)。
Hoki 2015年

3

Python,约。1.26e1388

9<<(9<<9L)

给出:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414014099915140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414014099915140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L


3

至少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解释器和操作系统。


“仅占世界存储空间的0.2%”
本杰明·厄克特

1
@BenjaminUrquhart如果您认为这很好,那为什么不投票呢?
wizzwizz4

有您的双重支持;)
本杰明·厄克特

3

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

斯卡拉2 63 -1

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

但是,只有7个字符的(计数)代码,我们可以打印出最大可能的正数Long

print(-1L>>>1)

2

Brainf ** k 256-2147483647

>+[<+>+]<.

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

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

编辑:

-.

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


第二个答案将打印-1在使用带符号值的解释器上
Benjamin Urquhart,

2

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的必要算法,我一直认为它很简洁。


2

TI-36(不是84、36),大约10个字节。9.999985426E99

较旧的计算器也可以编程到一定程度;)

69!58.4376

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

在此处输入图片说明


2

Perl 6,456,574位数字

[*] 1..ↈ

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

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.