输出字符串的googol副本


63

我感兴趣的是看到不需要任何输入的程序,打印一些非空字符串的googol副本,不少不多,然后停止。甲固高被限定为10 ^ 100,即1后面一百0的以十进制。

输出示例:

111111111111111111111111111111111111111111111111111111111111111111111111...

要么

Hello world
Hello world
Hello world
Hello world
Hello world
Hello world
...

该字符串也可以完全由空格或特殊符号组成。固定字符串的相同副本的唯一例外是,如果您的语言以某种无法避免的方式装饰输出,但可以在包装脚本中微不足道地撤消该输出,例如在每行前添加行号。在这种情况下,无需提供包装脚本。

您可以假设您的计算机永远不会用完时间,但是除此之外,您的程序必须对资源有合理的需求。另外,您必须遵守您选择的编程语言所施加的任何限制,例如,您不能超过其整数类型所允许的最大值,并且在任何时候都不需要多于4 GB的内存。

换句话说,该程序原则上应该可以通过在计算机上运行来进行测试。但是由于这个数字的范围,您应该证明它输出的字符串的副本数恰好是10 ^ 100,并且程序随后会停止。停止可能由于错误而退出,停止甚至终止,但如果是这样,则错误一定不能产生无法轻易与程序输出分离的输出。

这是,因此以字节数最少的解决方案为准。

解决方案示例(C,未填充,3768字节)

#include <stdio.h>

int main() {
  int a00, a01, a02, a03, ..., a99;
  for(a00 = 0; a00 < 10; a00++)
  for(a01 = 0; a01 < 10; a01++)
  for(a02 = 0; a02 < 10; a02++)
  for(a03 = 0; a03 < 10; a03++)
  ...
  for(a99 = 0; a99 < 10; a99++)
    puts("1");
  return 0;
}

10
下次首先考虑沙箱

9
当您发布新问题时,系统会要求您先将其发布到沙盒中
瑕疵的

1
@KritixiLithos这个想法很有趣,但是我不能很快提出一个示例解决方案。随意制作续集:-)
The Vee

3
@closevoter您确定这太广泛了吗?常识自动将其范围从“打印非空字符串10 ^ 100次”缩小为“打印字符10 ^ 100次”。
dorukayhan

Answers:


34

果冻6 4 字节

³Ȯ*¡

这是一个niladic链接(不带参数的函数),它打印10 200个字符串100副本,这意味着它打印10 100个字符串副本,其中包括10 100字符串100副本。

在线尝试!

请注意,出于实际原因,在线解释器会将输出削减为100 KB。该代码也可以作为完整程序使用,但是由于隐式输出,该程序打印的副本太多。

这个怎么运作

³Ȯ*¡  Niladic link. No arguments.

³     Set the left argument and initial return value to 100.
 Ȯ    Print the current return value.
  *   Compute 100 ** 100 = 1e200.
   ¡  Call Ȯ 1e200 times. 

3
嗯...哇...印刷10^100原始输出(拷贝10^100字符串的副本)正在成为一个有点远,甚至整整两个字节。您是否已将此问题提交给“得分是输出/程序长度,最高胜利”挑战?
wizzwizz16年

1
不确定您要指的是哪项挑战(我们有一些此类挑战),但是3e200可能并不具有竞争力。
丹尼斯,

2
@ wizzwizz4如果您可以用标准符号表示数字,则可能太小了。
Orlp

1
“跌倒” =失败/崩溃
Loren Pechtel '16

4
@LorenPechtel Jelly是用Python实现的,它可以轻松处理665位整数。
丹尼斯

60

Fuzzy Octo鳄梨酱,13 12 11 10字节

9+ddpp![g] 

说明:

9+ddpp![g]
9+           # push 9 and increment, giving 10
  dd         # duplicate, twice. now you have [10,10,10]
    pp       # raise a 10 to the 10th power, then raise that to the 10th again. That ends up being 10^100.
      ![ ]   # for loop, `!` sets the counter to the top of stack
        g    # prints an ASCII art goat. 

印刷的山羊样品:

                  ___.
                 //  \\
                ((   ""
                 \\__,
                /6 (%)\,
               (__/:";,;\--____----_
                ;; :";,:";`;,";,;";`,`_
                  ;:,;;";";,;":,";";,-Y\
                   ;,;,;";";,;":;";"; Z/
                   / ;,";";,;";,;";;"
                  / / |";/~~~~~\";;"
                 ( K  | |      || |
                  \_\ | |      || |
                   \Z | |      || |
                      L_|      LL_|
                      LW/      LLW/

2
我花了一段时间才了解山羊的头。这不容易识别。
mbomb007 '16

考验给了我ASCII艺术,问他。
Rɪᴋᴇʀ

9
我不知道你在说什么。+1。
djechlin

15
@djechlin Downgoat要求我添加一个内置组件来打印山羊。我有义务
Rɪᴋᴇʀ

21

Python,28个字节

-1字节感谢乔纳森·艾伦!

Python 2:

i=10**100
while i:print;i-=1

Python 3(30字节):

i=10**100
while i:print();i-=1

2
i=10**100换行符while i:print();i-=1保存一个字节。通过将Python 2与while i:print;i-=1
Jonathan Allan

@JonathanAllan感谢-1个字节。至于Python 2解决方案,我将其留给您发布:)
FlipTack

不错的第一答案!:)
丹尼尔(Daniel)

Python可以实际存储10到100的整数吗?
阿图罗·托雷斯·桑切斯

7
@ArturoTorresSánchez是的,python中的int大小没有上限:)
FlipTack

18

Haskell,28个字节

main=putStr$[1..10^100]>>"1"

连接字符串的10 ^ 100副本"1"并打印。


在开始打印之前是否已完成字符串连接?如果是这样,我会认为这违反了“不超过4 GB内存”的规则...
daniero

8
@daniero:由于Haskell的懒惰,打印立即开始。在我的计算机上,程序需要少于2MB的内存(包括运行时系统RTS)。
nimi

s=[1..10^100]>>"1"允许的答案格式吗?
user253751 '16

无限整数?否则,它会落在10 ^ 100上
洛伦·佩希特尔

@immibis:挑战说“打印”,通常表示“打印到标准输出”。s您的示例中的不会打印-或者如果您使用REPL,则将括1起来"。我想putStr$[1..10^100]>>"1"没有这个main=也可以,但是我想提交一个完整的程序。
nimi

17

笨蛋, 480 188 114 106 98字节

仅因为它需要完成。

假定8位单元带有换行。打印250个255 NUL字节,这是10 100倍10 155倍25个255 NUL字节。

>>>>>>-[[->>>+<<<]------>>>-]<<<[<<<]+[+[>>>]<<<->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-[<<<].>>>-]

说明:

>>>>>> 需要留一点工作空间。

- 产生255。

[[->>>+<<<]------>>>-] 将其转换为255个值250的副本,得到如下所示的磁带:

0 0 0 0 0 0 250 0 0 250 0 0 ... 250 0 0 [0]

<<<[<<<]+ 向后移动数据指针并完成初始数据:

0 0 0 [1] 0 0 250 0 0 250 0 0 ...

然后是循环:[+...-]最初将1设置为2,然后在循环结束时将其设置回1。当循环主体已将2设置为1时,循环终止。

现在,数字2 250 250 250 ... 250以基数250表示一个计数器,每个数字都比它所表示的数字大一。

  • [>>>]<<<一直向右移动。由于每个数字都由非零数字表示,因此这是微不足道的。

  • ->+[<[+>-]>[-<<<<->+>>------>>]<<<<]>>-将计数器减1。从最后一位开始:该位递减。如果仍然是积极的,我们就完成了。如果变为零,则将其设置为250,然后继续输入前面的数字。

  • [<<<].>>>将指针移到最左边的数字之前,这是打印NUL字节的好时机。然后重新定位到最左边的数字,看看是否完成。

为了验证正确性,改变初始-+打印250个1 NUL字节,++250 2,等等。


16

C,51个字节

函数g()将递归函数调用f()到深度99。

为清楚起见,不包括在f()和之间添加的不必要的换行符g()

f(n,i){for(i=10;i--;)n?f(n-1):puts("");}
g(){f(99);}

//call like this
main(){g();}

打印1E100换行符。

宣言i的第二个参数f()不能保证在测试我自己的机器(在Cygwin GCC)上和ideone.com(我相信他们也跑GCC)下的所有版本中工作,但达不到F(99)为明显原因!


1
这符合4 GiB内存限制吗?
丹尼斯

3
@Dennis它应该这样做,它只在堆栈中存储f,n和i的深度99递归,避免了C无法处理100位数字十进制数的事实。对于f()大约1980个字节的每个实例,我估计最多大约20个字节。该puts转储换行到API和API应该输出和刷新缓冲区是必要的。
水平河圣

3
在本地对其进行测试,内存使用量甚至没有超过1 MiB。
丹尼斯

我的)声明为f的第二个参数(不保证C.在所有版本的工作:它可以用一个堆栈ARGS调用约定,其中被叫方从堆栈(弹出ARGS打破或者f写入堆栈空间调用者WASN没想到)。clang确实在-std=c89和中警告“对'f'的调用中的参数太少” -std=c99,因此该定义的确充当了具有特定数量args的声明。但是我忘记了;我认为这可能意味着编译器知道该函数需要2个args,并且始终会为第二个arg留出空间。
彼得·科德斯

1
@FelixDombek社区不久前决定,“程序”表示您可以编写程序或函数,除非明确指定“完整程序”。meta.codegolf.stackexchange.com/a/6912/15599。因此,我的意见书包括g及其辅助功能fmain会更长。如果您仔细查看的话,这里还有其他一些功能提交。
水平河圣

14

Commodore VIC 20机器代码(40字节)

...此处显示为十六进制:

1040   A9[64]A2 00 9D 68 10 E8  E0[32]D0 F8 A9 00 9D 68
1050   10 A9[31]20 D2 FF A2 00  A9[64]DE 68 10 30 08 D0
1060   F0 9D 68 10 E8 D0 F3 60

(使用发起者:SYS 4160

括号中字节的含义

  • 0x64(出现两次)是基数(100);(值从2到127应该有效)
  • 0x32是指数(50)(任何非零值(1-255)都应起作用)
  • 注意100 ^ 50 = 10 ^ 100; 运行程序100 ^ 50次比执行程序10 ^ 100次具有更高的RAM效率
  • 0x31是要打印的ASCII字符

并且在任何时候都不需要超过4 GB的内存。

这是打字错误吗?

我们有1981年。

典型的家用计算机具有1到16 K B的RAM!而且,您几乎找不到具有1 M B或更多的专业型号。

(好,开个玩笑。)

换句话说,该程序原则上应该可以通过在计算机上运行来进行测试。但是由于这个数字的范围,您应该证明它输出的字符串的副本数恰好是10 ^ 100,并且程序随后会停止。

该程序已经过其他基准和指数的测试。我毫不怀疑它也可以与100和50一起使用。

至少它不会因这些数字而崩溃(但也不会在可测量的时间内终止)。

内存大小足以使指数为50,而100小于127,因此以100为底应该不是问题。

基本思想

在100个系统中有一个50位计数器。字节0x01-0x64代表数字0-99。计数器的第一个字节是最低位。计数器的最后一个字节(最高位数)后跟一个值为0x00的字节。

计数器的初始值为100 ^ 50。

一个外部循环将一个字节写入“当前通道”(在现代系统上通常为“屏幕”上的“标准输出”),然后使计数器递减。

递减是通过一个内循环完成的:它会递减一个数字,并且在下溢从1到99的情况下会前进到下一个数字。如果递减计数器末尾的字节0x00,程序将停止。

汇编代码是

    ; Some constants
    base=10
    exponent=100
    character=0x32

    ; Initialize the content of the counter to 100^50
    ; (Fill the first 50 bytes with the value 100)
    lda  #base
    ldx  #0
initLoop:
    sta  counter,x
    inx
    cpx  #exponent
    bne  initLoop
    ; (The terminating 0 at the end of the counter)
    lda  #0
    sta  counter,x

    ; Now do the actual job
outerLoop:
    ; Output a character
    lda  #character
    jsr  (0xFFD2)
    ; Prepare for the inner loop
    ldx  #0
    lda  #base
innerLoop:
    ; Decrement one digit
    dec  counter,x
    ; Result is negative -> must have been the terminating
    ; NUL byte -> Exit
    bmi  progEnd
    ; Result is not zero -> Print the next byte
    bne  outerLoop
    ; Result is zero -> Was 0x01 before -> As 0x01 represents
    ; digit 0 this is an underflow -> set the digit to
    ; "exponent" (100) again (which represents digit 99)
    sta  counter,x
    ; Go to the next digit and...
    inx
    ; ... repeat the inner loop (decrement next digit)
    ; (Note that this conditional branch is ALWAYS taken)
    bne  innerLoop

progEnd:
    rts

counter:
    ; The memory used by the counter is here...

编辑

该程序也可以在Commodore C64上运行!


我为我借了@LevelRiverSt的递归想法 x86-64机器代码实现,以30B(使用libc的putchar进行打印)输入。我考虑了扩展精度循环计数器,它也可以在x86中工作。(并且可以类似地便宜地初始化)。也许我会在某个时候尝试...
彼得·科德斯

1
大声笑,我..... <高尔夫球拍> ...我好长时间没有看过6502的组装了。
Alex Howansky '16

12

节点,89字节

for(i="0".repeat(100)+1;+i;i=i.replace(/0*./,x=>"9".repeat(x.length-1)+~-x))console.log()

输出10 100个换行符。(从理论上讲,即通过替换1001进行测试,以输出10 1个换行符。)

通过设置i为字符串可以工作

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

(100个零和一个1; googol反转了),然后使用正则表达式重复“减去1”并输出换行符,直到字符串全为零为止。

C ++答案的端口为49个字节:

(f=n=>{for(i=10;i--;)n?f(n-1):console.log()})(99)

1
这是天才!要么就是您是Retina的专家,那不一定排除“天才”……
Patrick Roberts

7

05AB1E,6个字节

Tn°F1?

说明

Tn°    # push 10^100
   F   # 10^100 times do
    1? # print 1

5
@MartinRosenau:幸运的是05AB1E使用了没有限制的python 3个整数。
Emigna

1
@JanDvorak:根据Python 3文档 ,整数值不再受限制
Emigna '16

1
@JanDvorak:的确如此。我已经使用了一些很大的数字而没有问题(虽然不是那么大)。我们只需要在这里处理1e100,而python绝对可以处理:)
Emigna '16

1
@JanDvorak Python整数的最大大小仅取决于可用内存量。
Mego

4
在尝试混淆大量数字之前,我已经达到极限。我使用的计算机能够在整数溢出之前处理大于10 ^ 3000的数字。
Esolanging Fruit

6

Ruby,20个字节

(10**100).times{p 1}

打印1,然后换行1E100次。

1E100 在计算为浮点数而不是任意精度整数时不起作用。


可以删除括号吗?
OldBunny2800 '16

1
@ OldBunny2800号方法优先于运算符,因此它将被解释为10**(100.times{p 1})
Level River St

1
对于那些好奇的人,请1E100.to_i在我的计算机上将其评估为10000000000000000159028911097597518046836080856394528138978132755774783877170381060813469985856815104。
Andrew Grimm

6

///,36个ASCII字符(4个不同)

/t./.ttttt//.t/t\..........//t//t...

输出.字符3 * 10 ^ 125次,这意味着它将输出由字符的3 * 10 ^ 25次重复组成的字符串.10 ^ 100次。

说明:

  1. /t./.ttttt/:更换t..ttttt整个程序的其余部分,重复,直到没有的情况t.依然存在。这将替换t......之后125 t秒。
  2. /.t/t\........../:更换.tt..........整个程序的其余部分,重复,直到没有的情况.t依然存在。这需要花费...125 ts,然后变成125 ts,然后出现10 ^ 125次...
  3. /t//:删除所有剩余t的。
  4. t...:将其替换为3 * 10 ^ 125 .s。输出它们。

现在,输出某种感觉像作弊的3 * 10 ^ 25次重复的10 ^ 100次重复。该程序.使用45个ASCII字符将字符精确输出10 ^ 100次:

/T/tttttttttt//.t/t..........//t//.TTTTTTTTTT

对此的解释:

  1. /T/tttttttttt/:更换Ttttttttttt整个节目的其余部分。替换TTTTTTTTTT为的100次重复t
  2. /.t/t........../:更换.tt..........整个节目的其余部分。这需要.100 t秒,然后变成100 t秒,然后是10 ^ 100.秒。
  3. /t//:删除所有剩余t的。
  4. .TTTTTTTTTT:将替换为10 ^ 100 .s。输出它们。

最后,这是一个折衷程序,该程序.使用40个字符输出2 * 10 ^ 100次字符:

/t./.tttttttttt//.t/t\..........//t//t..

6

Befunge 93,33个字节

1>01g0`#@!# _01v
d^.1 **52p10-1g<

不幸的是,Befunge没有幂函数,因此几乎所有代码都是我对幂函数的实现。我还在努力。

说明:

1 > 01g 0` #@!# _ 01g 1- 01p 25** 1. v
d ^                                  <

1:从1左上角开始,这样我们相乘时就不会0每次都。

01g:获取位置(0,1)处的字符,即d,其ASCII码为100。

0`:查看存储在(0,1)中的值是否大于0;这个值会改变。

#@!# _:逻辑上不!使用从上一步(0或1)获得的值,因此,如果该值为1,则现在为0,并且请注意,这#意味着您跳过了代码中的下一个字符。

01g 1- 01p:再次取存储在(0,1)中的值,从中减去1,然后将此新值存储在(0,1)中

25**:将栈顶值乘以10

1.1每次循环时打印

1 (理论上)打印了googol时间,但很快就超出了我测试过的页面。

您可以在此处运行Befunge 93代码。出于某种原因,堆栈的最高值是1.0000000000000006e+100应有的时间1.0e+100。我不知道那6是哪里来的,但我不认为它应该在那儿,并且可能是一些舍入错误或类似的东西。


4

ABCR,56个字节

++++++++++AAAAAAAAAA7a*A!(x4bBBBBBBBBBB7b+B@(xa(Ax5b(Box

图灵tarpit很有趣,尤其是当它们没有简单的乘法或指数时。另一方面,我只需要使用三个队列中的两个!

说明:

++++++++++                                             Set register to 10
          AAAAAAAAAA                                   Queue 10 to queue A 10 times
                    7a*A!(x                            Sum up all of queue A by:
                    7     x                             While the register is truthy:
                     a*                                 Dequeue two elements of A, sum them...
                       A                                ...and queue the result back to A.
                        !(                              If there's only one element left,
                                                        i.e. !(A.len - 1),
                                                        break from the loop.  A now has 100, our exponent.

                             4                        While A's front is truthy:
                              bBBBBBBBBBB              Clone the front of B 10 (our base) times.  (The first iteration fills it up with ten 1s)
                                         7b+B@(x       Sum up all of queue B like we did with A
                                                a(A    Decrement a (so that the loop actually ends. Runs 101 times like it should) x   

                                                       B now contains 10^100 only.

                                                   5b(B x   10^100 times:
                                                       o     print the front of queue A (0)

4

批次,574242字节

@echo off
set t=for /l %%a in (2,1,33554432)do call:
set f=for /l %%a in (2,1,9765625)do call:
%t%a
:a
%t%b
:b
%t%c
:c
%t%d
:d
%f%e
:e
%f%f
:f
%f%g
:g
%f%h
:h
%f%i
:i
%f%j
:j
%f%k
:k
%f%l
:l
%f%m
:m
%f%n
:n
echo

每个循环都会结束,因此要执行附加的迭代。由于32位整数限制,循环限制为〜2³²。前四个循环各计2²,合计2 1,而其余十个循环各计5,合计5。

编辑:由于@ ConorO'Brien,节省了不可思议的58%。



1
@ ConorO'Brien等等,你可以做到吗?我从来不知道!
尼尔

4

TI基本(20字节)

直截了当。一次仅显示八行,并且前几行不保留在内存中。由于ᴇ100不受支持,因此我们必须从循环-ᴇ999ᴇ99。然后,如果I!=0显示字符串(顺便说一下,它是3)。这样,我们就可以准确地打印ᴇ100时间。

For(I,-ᴇ99,9ᴇ99:If I:Disp 3:End

您确定变量“ I”足够精确以存储99位数字吗?
马丁·罗斯瑙

好的,是的,我应该足够保留它,尽管如果使用“ Disp”它最多只能显示14,但是我们实际上并没有输出它,只检查它是否不等于零。另外,您对符号的看法是正确的,但我认为您会理解我的意思。我现在将其复制到我的帖子中。
Timtech '16

我从来没有遇到过带有无限整数的BASIC版本,但这根本没有关系,因为您的循环执行的次数不足。
罗兰·佩希特尔

1
嗯,这里没有无限整数。整数必须在+ -10 ^ 100之内
Timtech '16

4

x86-64机器码功能,30字节。

使用与@Level River St的C答案相同的递归逻辑。(最大递归深度= 100)

使用puts(3)libc中的函数,无论如何,该函数都链接到普通可执行文件。它可以使用x86-64 System V ABI来调用,即从Linux或OS X上的C语言调用,并且不会破坏不应有的任何寄存器。


objdump -drwC -Mintel 输出,带有解释的评论

0000000000400340 <g>:  ## wrapper function
  400340:       6a 64                   push   0x64
  400342:       5f                      pop    rdi       ; mov edi, 100  in 3 bytes instead of 5
  ; tailcall f by falling into it.

0000000000400343 <f>:  ## the recursive function
  400343:       ff cf                   dec    edi
  400345:       97                      xchg   edi,eax
  400346:       6a 0a                   push   0xa
  400348:       5f                      pop    rdi       ; mov edi, 10
  400349:       0f 8c d1 ff ff ff       jl     400320 <putchar>   # conditional tailcall
; if we don't tailcall, then eax=--n = arg for next recursion depth, and edi = 10 = '\n'

  40034f:       89 f9                   mov    ecx,edi   ; loop count = the ASCII code for newline; saves us one byte


0000000000400351 <f.loop>:
  400351:       50                      push   rax       ; save local state
  400352:       51                      push   rcx
  400353:       97                      xchg   edi,eax   ; arg goes in rdi
  400354:       e8 ea ff ff ff          call   400343 <f>
  400359:       59                      pop    rcx       ; and restore it after recursing
  40035a:       58                      pop    rax
  40035b:       e2 f4                   loop   400351 <f.loop>
  40035d:       c3                      ret    
# the function ends here

000000000040035e <_start>:

0x040035e - 0x0400340 = 30 bytes

# not counted: a caller that passes argc-1 to f() instead of calling g
000000000040035e <_start>:
  40035e:       8b 3c 24                mov    edi,DWORD PTR [rsp]
  400361:       ff cf                   dec    edi
  400363:       e8 db ff ff ff          call   400343 <f>
  400368:       e8 c3 ff ff ff          call   400330 <exit@plt>    # flush I/O buffers, which the _exit system call (eax=60) doesn't do.

内置 yasm -felf64 -Worphan-labels -gdwarf2 golf-googol.asm && gcc -nostartfiles -o golf-googol golf-googol.o。我可以发布原始的NASM源代码,但是看起来似乎很混乱,因为反汇编中就存在asm指令。

putchar@plt距离不到128个字节jl,因此我可以使用2字节的短跳转而不是6字节的近跳转,但这仅适用于小型可执行文件,而不是较大程序的一部分。因此,如果我还利用简短的jcc编码来实现它,那么我认为没有理由不计算libc的puts实现的大小。

每个递归级别都使用24B的堆栈空间(两次压入和CALL压入返回地址)。每隔一个深度调用一次putchar,堆栈仅对齐8,而不是16,因此这确实违反了ABI。使用对齐存储将xmm寄存器溢出到堆栈的stdio实现可能会出错。但是glibc putchar不会这样做,而是使用完全缓冲写入管道或使用行缓冲写入终端。在Ubuntu 15.10上测试。可以使用中的虚拟push / pop来解决此问题.loop,以在递归调用之前使堆栈再偏移8。


证明可以打印正确数量的换行符:

   # with a version that uses argc-1  (i.e. the shell's $i)  instead of a fixed 100
$ for i in {0..8}; do echo -n "$i: "; ./golf-googol $(seq $i) |wc -c; done
0: 1
1: 10
2: 100
3: 1000
4: 10000
5: 100000
6: 1000000
7: 10000000
8: 100000000
... output = 10^n newlines every time.

我的第一个版本是43B,用于puts()9个换行符(以及一个终止的0字节)的缓冲区,因此看跌期权将附加在第10个之后。递归的基本情况更接近于C的灵感。

以不同的方式分解10 ^ 100可能会缩短缓冲区,也许减少到4个换行符,节省5个字节,但是到目前为止使用putchar更好。它只需要一个整数arg,不需要指针,也根本不需要缓冲区。C标准允许在其中将其作为宏的实现putc(val, stdout),但是在glibc中,它作为可从asm调用的真实函数存在。

每个调用仅打印一个换行符而不是10,这意味着我们需要将递归最大深度增加1,以获得另一个10换行符的因子。由于99和100都可以用符号扩展的8位立即数表示,push 100因此仍然只有2个字节。

更好的是,10在寄存器中用作换行符和循环计数器,可以节省一个字节。

保存字节的想法

32位版本可以为节省一个字节dec edi,但是stack-args调用约定(用于putchar之类的库函数)使尾部调用工作变得不那么容易,并且可能在更多地方需要更多字节。我可以使用private的register-arg约定f(),仅由调用g(),但是我不能尾调用putchar(因为f()和putchar()会使用不同数量的stack-args)。

f()可以保留调用者的状态,而不是在调用者中进行保存/恢复。但是,这可能很糟糕,因为它可能需要在分支的每一侧分别获取,并且与尾调用不兼容。我尝试过,但没有发现任何节省。

在堆栈上保留循环计数器(而不是在循环中推送/弹出rcx)也没有帮助。使用puts的版本差了1B,而使用该版本更便宜地设置rcx的损失可能更大。


2
大会的答案万岁!:)

4

PHP,44字节

for($i=bcpow(10,1e2);$i=bcsub($i,print 1););

此代码段将输出1googol时间。它不会耗尽内存,但速度非常慢。我正在使用BCMath来处理长整数。

性能好一点,但不那么小(74字节):

for($m=bcpow(10,100);$m;$m=bcsub($m,$a))echo str_repeat(a,$a=min(4e9,$m));

将输出字母agoogol次。它将消耗将近4GB的内存,一次输出大约4e9个字符。


如果仅一个“ a”需要将近4GB,那么“ aaa”会做什么?它将需要更多代码,但要使用ob_flush();。您可能会走得更远
Martijn

嗯,不是一个a,而是4 * 10 ^ 9 as 的字符串。如果要在其中放入3倍的内存,就无法超过4GB a。Ob_flush与它无关,第二个示例的要点是一次输出大字符串,而不是每次都输出少量字符,这导致程序运行相当快,但会占用更多内存。
chocochaos

据我所知“> =”无法处理大整数,您应该使用bccomp
Crypto Crypto

您是正确的,在比较字符串时不会给出正确的结果。我会在一分钟内修复它。
chocochaos

使用稍微不同但
可行的

3

Haskell,45个 43字节

r 0=[]
r i='1':r(i-1)
main=putStr.r$10^100

3

Pyke,6个 5字节

TTX^V

在这里尝试!

未经测试,因为它使我的浏览器崩溃。前四个字符生成10 ^ 100,并V打印出许多换行符。用测试100V


3

拍子36字节

(for((i(expt 10 100)))(display "1"))

输出:

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111...

3

JAISBaL,4 个字节

˖Q

Chrome无法读取所有符号,而且我不确定其他浏览器,所以下面是图片:

说明:

# \# enable verbose parsing #\
10^100       \# [0] push 10^100 onto the stack #\
for          \# [1] start for loop #\
    space    \# [2] print a space #\

非常简单....仅打印googol空间。三个指令,但是googol常数是两个字节。

(写在版本3.0.5中)


这是6个UTF-8字节。您使用哪种编码?
科纳·奥布莱恩

“字节”确实链接到它…
苏格拉底凤凰城

加,对不起。我有一个使链接看起来像普通文本的用户脚本。
科纳·奥布莱恩

哦,我不知道那是不可能的,好吧:)
苏格拉底凤凰城

@ ConorO'Brien嗯,为什么?
Cyoce

3

的JavaScript ES6,85 83个字节

ETHproductions节省了2个字节!

eval([...Array(i=100)].map(_=>`for($${--i}=0;$${i}++<10;)`).join``+"console.log()")

这将打印1e100换行符。

内部生成该程序,然后对其进行评估。

for($0=0;$0++<10;)for($1=0;$1++<10;)for($2=0;$2++<10;)for($3=0;$3++<10;)for($4=0;$4++<10;)for($5=0;$5++<10;)for($6=0;$6++<10;)for($7=0;$7++<10;)for($8=0;$8++<10;)for($9=0;$9++<10;)for($10=0;$10++<10;)for($11=0;$11++<10;)for($12=0;$12++<10;)for($13=0;$13++<10;)for($14=0;$14++<10;)for($15=0;$15++<10;)for($16=0;$16++<10;)for($17=0;$17++<10;)for($18=0;$18++<10;)for($19=0;$19++<10;)for($20=0;$20++<10;)for($21=0;$21++<10;)for($22=0;$22++<10;)for($23=0;$23++<10;)for($24=0;$24++<10;)for($25=0;$25++<10;)for($26=0;$26++<10;)for($27=0;$27++<10;)for($28=0;$28++<10;)for($29=0;$29++<10;)for($30=0;$30++<10;)for($31=0;$31++<10;)for($32=0;$32++<10;)for($33=0;$33++<10;)for($34=0;$34++<10;)for($35=0;$35++<10;)for($36=0;$36++<10;)for($37=0;$37++<10;)for($38=0;$38++<10;)for($39=0;$39++<10;)for($40=0;$40++<10;)for($41=0;$41++<10;)for($42=0;$42++<10;)for($43=0;$43++<10;)for($44=0;$44++<10;)for($45=0;$45++<10;)for($46=0;$46++<10;)for($47=0;$47++<10;)for($48=0;$48++<10;)for($49=0;$49++<10;)for($50=0;$50++<10;)for($51=0;$51++<10;)for($52=0;$52++<10;)for($53=0;$53++<10;)for($54=0;$54++<10;)for($55=0;$55++<10;)for($56=0;$56++<10;)for($57=0;$57++<10;)for($58=0;$58++<10;)for($59=0;$59++<10;)for($60=0;$60++<10;)for($61=0;$61++<10;)for($62=0;$62++<10;)for($63=0;$63++<10;)for($64=0;$64++<10;)for($65=0;$65++<10;)for($66=0;$66++<10;)for($67=0;$67++<10;)for($68=0;$68++<10;)for($69=0;$69++<10;)for($70=0;$70++<10;)for($71=0;$71++<10;)for($72=0;$72++<10;)for($73=0;$73++<10;)for($74=0;$74++<10;)for($75=0;$75++<10;)for($76=0;$76++<10;)for($77=0;$77++<10;)for($78=0;$78++<10;)for($79=0;$79++<10;)for($80=0;$80++<10;)for($81=0;$81++<10;)for($82=0;$82++<10;)for($83=0;$83++<10;)for($84=0;$84++<10;)for($85=0;$85++<10;)for($86=0;$86++<10;)for($87=0;$87++<10;)for($88=0;$88++<10;)for($89=0;$89++<10;)for($90=0;$90++<10;)for($91=0;$91++<10;)for($92=0;$92++<10;)for($93=0;$93++<10;)for($94=0;$94++<10;)for($95=0;$95++<10;)for($96=0;$96++<10;)for($97=0;$97++<10;)for($98=0;$98++<10;)for($99=0;$99++<10;)console.log()

现在,为了证明正确性,我们将使用一些归纳法。让我们来替代其它值初始100,一般ñ。我声称插入N将产生10 N个换行符。让我们将其结果传递给wc -l,以计算输入中换行的数量。我们将使用经过修改但等效的脚本,接受输入N

eval([...Array(+process.argv[2])].map(_=>`for($${i}=0;$${i++}++<10;)`,i=0).join``+"console.log()")

现在,这是一些输出:

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 1 | wc -l
10

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 2 | wc -l
100

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 3 | wc -l
1000

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 4 | wc -l
10000

我们可以看到,这会将较小值的输入N转换为10 N换行符。

这是N = 1 的示例输出:

C:\Users\Conor O'Brien\Documents\Programming
λ node googol.es6 1











C:\Users\Conor O'Brien\Documents\Programming
λ

真好 使用eval([...Array(i=100)].map(_=>`for($${--i}=0;$${i}++<10;)`).join``+"console.log()")
ETHproductions

@ETHproductions谢谢!:D
科纳·奥布莱恩

PS我计数83个字节;)
ETHproductions

这里的另一个例子。不知道它是否对其他人有用,但是我不确定这是如何工作的,并为评估函数编写了包装函数。您可以清楚地看到该程序计数到10 ^ n,其中n是所评估的循环数。我设置了返回条件,以便在googol之前将其打破;更改该条件下使用的变量以计算不同的循环级别。另外,还有一个nitpick:您的第二个代码示例显示外循环为$ 0,下降到$ 99;它应该被逆转,99美元是外部循环。
MichaelS

@MichaelS是的。下次有机会我会更改它。
科纳·奥布莱恩

3

Mathematica,48 30 25字节

For[n=1,n++<Echo@1*^100,]

输出:

>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
>> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
etc.

目前无法测试,但是如何For[n=0,n++<10^100,Echo[]]呢?
Martin Ender

我会考虑>>输出的主要部分。如果您Echo在控制台上使用,它们将被打印出来。
Martin Ender

@MartinEnder哎呀,固定
LegionMammal978 '16

如何Echo@0&~Array~10^100;为21个字节?
格雷格·马丁

3

Fortran 95,自由格式,递归,117字节

Program M
Call R(99)
END
Recursive Subroutine R(L)
IF(L)3,1,1
1 DO 2 I=1,10
2 Call R(L-1)
RETURN
3 PRINT*,0
END

打印包含以下内容的行的googol

          0

Fortran 90,递归,149字节

     CallR(99)
     END
     RecursiveSubroutineR(L)
     IF(L)3,1,1
   1 DO2I=1,10
   2 CallR(L-1)
     RETURN
   3 PRINT*,0
     END     

递归调用100个嵌套循环,每个循环10次,恰好完成了一个googol。N,L和循环计数器都适合字节大小的整数。

通过将99替换为1、2、3、4、5进行测试,并注意到在每种情况下,“ wc”产生的行数均具有n + 1个零。

Fortran II,IV,66或77、231个字节:

      N=2*10**9
      DO1I0=1,5**10
      DO1I=1,N
      DO1J=1,N
      DO1K=1,N
      DO1L=1,N
      DO1M=1,N
      DO1I1=1,N
      DO1J1=1,N
      DO1K1=1,N
      DO1L1=1,N
      DO1M1=1,N
1     PRINT2
2     FORMAT(X)
      END

打印换行符。

所有这些程序都将在32位计算机上运行。实际上,递归版本在16位计算机上就可以正常工作。通过在具有60位整数的旧Cray上运行,可以在暴力版本中使用更少的循环。在这里,一个5 ^ 10(9765625)循环中的10个2 * 10 ^ 9嵌套循环等于10 ^ 100次总迭代。

除了目标代码本身,计数器,输出字符串的一个副本以及在递归版本中的100级返回堆栈外,所有版本都不使用任何内存来讲话。

通过比较检查因素

bc<<<2000000000\^10*5\^10
bc<<<10\^100

3

图灵机模拟器,1082字节

0 * 6 r 1
1 * E r 2
2 * C r 3
3 * 1 r 4
4 * B r 5
5 * C r 6
6 * F r 7
7 * 4 r 8
8 * 6 r 9
9 * 8 r A
A * 8 r B
B * 3 r C
C * 0 r D
D * 9 r E
E * G r F
F * H r G
G * 8 r H
H * 0 r I
I * 6 r J
J * H r K
K * 9 r L
L * 3 r M
M * 2 r N
N * A r O
O * D r P
P * C r Q
Q * C r R
R * 4 r S
S * 4 r T
T * E r U
U * E r V
V * G r W
W * 6 r X
X * D r Y
Y * E r Z
Z * 0 r a
a * F r b
b * E r c
c * 9 r d
d * F r e
e * A r f
f * H r g
g * D r h
h * E r i
i * 6 r j
j * 6 r k
k * D r l
l * G r m
m * H r n
n * 1 r o
o * 0 r p
p * 8 r q
q * C r r
r * 9 r s
s * G r t
t * 3 r u
u * 6 r v
v * 2 r w
w * 3 r x
x * E r y
y * 0 r z
z * 4 r +
+ * 5 r /
/ * A r =
= * 0 r -
- * H r \
\ * 7 r !
! * A r @
@ * 9 r #
# * 5 r $
$ * A r %
% * B r ^
^ * 5 r &
& * 9 r ?
? * 4 r (
( * C r )
) * E r `
` * 9 r ~
~ * 9 r _
_ * A * .
. 0 I l *
. 1 0 r <
. 2 1 r <
. 3 2 r <
. 4 3 r <
. 5 4 r <
. 6 5 r <
. 7 6 r <
. 8 7 r <
. 9 8 r <
. A 9 r <
. B A r <
. C B r <
. D C r <
. E D r <
. F E r <
. G F r <
. H G r <
. I H r <
. _ * r ]
< _ * r >
< * * r *
> _ = l [
> * * r *
[ _ * l .
[ * * l *
] _ * * halt
] * _ r *

图灵机模拟器

我不知道这是否算作正确的输出,因为它有82个前导空格。

我不知道这是否符合4 GB的限制,因此,如果不遵守,则不具有竞争力,仅用于展示。输出为1e100字节,因此应从内存字节数中扣除。最终字节数为82个字节。

这里是一个解释:

代码的前80行是80种不同的状态,它们生成以19为底的1循环计数6EC1BCF4688309GH806H932ADCC44EEG6DE0FE9FAHDE66DGH108C9G3623E045A0H7A95AB594CE99A

接下来的19行代码是计数器状态,每次打印一个字符时,计数器状态都会减少。

接下来的6行是打印机状态,其后会附加一个=

最后,最后两行是更清洁的状态,需要使用此状态来确保唯一的输出是=====...=====。前导/后缀空格不能避免作为输出,因为它们是不可避免的副作用。

然后程序停止。

1我为此做了数学。



2

Python 3,32个字节

for i in range(10**100):print()

替代解决方案,33字节:

[print()for i in range(10**100)]

在Python 2中,这是一个非常好的答案。

1
没有那么多,@ Lembik。在Python 2中,range(10**100)创建一个数字列表[1, 2, 3, 4, ...],结果为OverflowError: range() result has too many items。这将在Python 2中使用调用来xrange()工作,并且在Python 3中由于将xrange()其重命名为而起作用range(),并且range()不推荐使用生成列表的原始文件。
James Murphy

2
@JamesMurphyb是的,我知道。我试图对codegolf答案的不切实际性感到有趣。

1
抱歉。我在很多SE评论中很难读懂幽默。
James Murphy

2

爪哇198 179 155字节

import java.math.*;class a{void A(a[]x){for(BigInteger b=BigInteger.ZERO;!(b=b.add(BigInteger.ONE)).equals(BigInteger.TEN.pow(100));)System.out.print(x);}}

打印(x== nullnull:启动用绳[La;@或类似的东西)10个100在O次数(永远)的时间。


3
您有class,但没有public static void main(String[]a)方法。至于打高尔夫球的技巧:可以更换new BigInteger("0")new BigInteger("1")new BigInteger("10")BigInteger.ZEROBigInteger.ONEBigInteger.TEN; 您可以替换import java.math.BigInteger;import java.math.*;
凯文·克鲁伊森

1
无需进口:类似的东西应该可以工作:java.math.BigInteger b=null;for(b=b.ZERO;!(b=b.add(b.ONE)).equals(b.TEN.pow(100);)System.out.print(x);
OlivierGrégoire16年

@OlivierGrégoire这给了我NullReferenceException,可能是因为它b为null。
Xanderhall,2013年

@Xanderhall您可能在C#中尝试过此操作(因为您说的是NRE,而不是NPE)。我现在无法测试Java版本,因此无法分辨出问题所在。无论如何,我说的是“应该工作”,而不是“将工作”。采取的想法是,您可以对实例引用进行静态方法调用,甚至可以对null进行引用。
奥利维尔·格雷戈雷(OlivierGrégoire)

@OlivierGrégoire我在Java中尝试过。我没有用C#编写代码。
Xanderhall '16

2

Java,153个字节

import java.math.*;interface M{static void main(String[]a){for(BigInteger i=BigInteger.ZERO;!i.add(i.ONE).equals(i.TEN.pow(100));)System.out.print(1);}}

输出:1e100 1s

我知道还有另一个Java答案也很接近。我的有一个主要的,但仍然较短。

这是我的第一个代码高尔夫条目。提示赞赏。


可以使用lambda将其压缩到117个字节。但是,您仍然需要包括导入。import java.math.*;()->{for(BigInteger i=BigInteger.ZERO;!i.add(i.ONE).equals(i.TEN.pow(100));)System.out.print(1);};
肖恩·怀尔德

@BasicallyAlanTuring实际上我javac不会让我编译它。
Niclas M

然后更新您的Java。另外,这也不是完整的可编译代码。只是允许进入的最低要求。
肖恩·怀尔德

@BasicallyAlanTuring获得Java 8.我猜想OP不允许使用函数。
Niclas M

我给您的代码不是完整的程序。这只是有效的CG答案所需要的。
肖恩·怀尔德

2

Pyth,8个 7字节

V^T100G

链接

解决方案经过小量输出测试,但应打印abcdefghijklmnopqrstuvwxyz1e100次。

p正如31343(Maltysen)所说,由于某种原因,这是不必要的。


为什么需要p?
Maltysen '16

@Maltysen我认为是因为有4 GB的限制。
暴民埃里克(Erik the Outgolfer)

为什么?缓冲区的Cuz?那不是自动冲洗吗?
Maltysen '16

@Maltysen我不知道,在线解释器没有即时输出功能。它可能会冲洗,但可能不会...
暴民埃里克

它在本地工作,而没有p
Maltysen '16
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.