打印所有整数

48

编写一个程序或函数，一旦给定了无限的时间和内存，该程序或函数将精确地打印所有整数。

可能的输出可能是：

0, 1, -1, 2, -2, 3, -3, 4, -4, …

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -2, -3, -4, -5, -6, -7, -8, -9, 10, 11, …

这不是有效的输出，因为它永远不会枚举负数：

0、1、2、3、4、5、6、7、8、9、10、11…

  • 输出必须为十进制，除非您的语言不支持十进制整数（在这种情况下，请使用您语言使用的整数的自然表示形式）。

  • 您的程序必须处理语言中标准整数类型最大的数字。

  • 每个整数必须使用任何不是数字也不是语言负号的分隔符（空格，逗号，换行符等）与下一个分隔。

  • 分隔符在任何时候都不得更改。

  • 分隔符可以由多个字符组成，只要它们都不是数字也不是负号（例如, ，与一样有效,）。

  • 最终必须在有限的时间后打印所有受支持的整数。

计分

这是代码高尔夫球，因此最短答案以字节为单位

排行榜

显示代码段

code-golf  number  integer 
— 致命
source
3
如果我们的语言支持无限列表，是否可以从函数而不是打印输出列表？（在这样的列表上调用print将永远一次打印其元素。）
— xnor
5
我觉得对任意大小整数的要求只是无奈阻止没有此类整数参与的语言。他们要么必须导入才能使用，要么要解决与其他所有人完全不同的挑战。
— xnor
2
@xnor进行了更改，尽管这种残垣断壁是挑战的名称。
— 致命
5
@xnor，具有任意精度整数的语言仍然必须与其他所有人解决一个不同的问题，因此所做的改变就是使这种问题在许多语言中变得无聊无聊。
— 彼得·泰勒
2
@PeterTaylor是的，这很不幸。包装解决方案对我来说并不像他们在打印任何底片一样，但是我没有一种方法可以明确地表示差异。
— xnor

Answers:

19

Sesos，11 3 3个字节

0000000: c4ceb9                                            ...

在线尝试！选中调试以查看生成的SBIN代码。

Sesos组装

上面的二进制文件是通过组合以下SASM代码生成的。

set numout

jmp ; implicitly promoted to nop
    put,   fwd 1
    sub 1, put
    rwd 1, add 1
; jnz (implicit)
— 丹尼斯
source
这3个字节如何？
— HopefulHelpful
1
GitHub上的自述文件（链接在标题中）详细说明了指令的编码方式。
— 丹尼斯
1
6个十六进制数字/ 2 = 3个字节@HopefullyHelpful
— Stan Strum
@StanStrum感谢
— HopefullyHelpful
47

Haskell，19个字节

do n<-[1..];[1-n,n]

产生无限列表 [0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6,7,-7...

Haskell本机允许无限列表。打印这样的列表将永远一次打印其元素。

— 异或
source
2
我爱[n,1-n]！
— 瑕疵的
3
恕我直言，[1-n,n]将产生更好的输出。
— 尼尔
@Neil，我同意，更改了它。
— xnor
2
啊，那是monadese concatMap (\n -> [1-n, n]) [1..]，对吧？真好！
— 卡斯顿S
@CarstenS是的，完全正确。
— xnor
29

Brainfuck，6个字节

这将利用单元格换行并打印所有可能的值。在Brainfuck中，本机整数表示形式是按字节value。

.+[.+]

在线尝试！

— 瑕疵
source
2
好的，这是我到目前为止在PPCG上看到的最简短的Brainfuck答案。
— 凯文·克鲁伊森
1
这对于具有无限单元格的Brainfuck版本不起作用。请修正（即使是单独回答）
— John Dvorak
16
@JanDvorak答案不需要在每个实现中都起作用，只需在其中任何一个中都可以。
— 马丁·恩德
7
我可以解释为什么这是有效的吗？问题中没有分隔符，也没有负面要求。事实是您可以在脑袋中输出大于9的值。我对代码高尔夫缺乏经验，因此开始研究可以在输出前增加负数和正数的东西，然后逐渐增加。
— gtwebb
5
@SQB即使有无限的内存，整数的本机类型仍然是8位。Java int不会突然因为添加或删除了一些ram而具有更多或更少的位。
— 瑕疵的2016年
26

Cubix，14 12字节

.(.\OSo;?.>~

在线测试！现在，您可以调整速度，以使其运行得更快或更慢。

这个怎么运作

解释器要做的第一件事是删除所有空格，并在没有操作的情况下填充代码，.直到完全适合多维数据集为止。这意味着上面的代码也可以这样写：

    . (
    . \
O S o ; ? . > ~
. . . . . . . .
    . .
    . .

现在运行代码。IP（指令指针）从最左边的左上角开始，指向东方。这是在运行程序的整个过程中所采用的路径：

在此处输入图片说明

IP从图像最左侧的红色轨迹开始。然后运行OSo;，它执行以下操作：

  • O将TOS（堆栈顶部）打印为整数。在程序开始时，堆栈包含无限零，因此将输出0。
  • S按32，空格字符的char代码。
  • o将TOS打印为字符。这将打印一个空格。
  • ;弹出TOS。32从堆栈中删除。

现在，IP命中?，根据TOS的符号将IP指向左，右或笔直。现在，TOS为0，所以它一直保持不变。这是蓝色的道路；.什么也没做，IP击中了箭头>，再次将其沿红色路径向东引导。~采用TOS的按位非，将其更改为-1。

在这里，IP到达网络的右边缘，然后将其环绕回左侧。这会再次打印TOS（这次-1）和一个空格。

现在IP ?再次命中。这次，TOS是-1；由于这是负面的，因此IP向左转，采用绿色路径。镜像\将IP偏转到(，从而使TOS递减，将其更改为-2。它回来并击中了箭头；~再次按位非，将-2转到1。

再次输出TOS并打印空格。这次IP命中时?，TOS为1; 因为这是肯定的，所以IP向右转，采用黄色路径。它遇到的第一个操作员是S推额外的32; 在;弹出之前，它可引起任何麻烦。

现在，IP返回箭头并执行其例行程序，~将TOS更改为-2并O打印它。由于TOS再次为负，因此IP再次走绿色路线。而且它会一直这样循环下去*：红色，绿色，红色，黄色，红色，绿色，红色，黄色...，在以下循环中进行打印：

0 -1 1 -2 2 -3 3 -4 4 -5 5 -6 6 -7 7 -8 8 -9 9 -10 10 ...

TL; DR

该程序反复执行以下3个简单步骤：

  1. 输出当前数字和空格。
  2. 如果当前数字为负，则将其减1。
  3. 取当前数字的按位非。

非分隔版本，6字节

nO?~>~

消除分隔会大大简化程序，使其适合单位立方体：

  n
O ? ~ >
  ~

* 注意：这两个程序都不是真正无限的，因为它们最多只能计数2 52（JavaScript开始失去整数精度）。

— ETH生产
source
4
不错的图！:)您是手工创建的还是编写了生成它的工具？
— Martin Ender
5
@MartinEnder谢谢！它的灵感来自于您的六角图。我手动创建了一个。虽然我想在有足够的时间编写工具来生成它们。
— ETHproductions 2016年
18

MATL，8字节

0`@_@XDT

这使用了MATL的默认数据类型，即double，因此可以达到2^53绝对值。输出是

0
-1
1
-2
2
···

在线尝试！

说明

0            % Push 0
  `     T    % Do...while true: infinite loop
   @_        % Push iteration index and negate
     @       % Push iteration index
      XD     % Display the whole stack
— 路易斯·门多
source
为什么开始打印之前会有这么大的延迟？
— 致命
@Fatalize我认为每次在TIO中运行MATL程序时都需要重新启动Octave，这需要一些时间。
— 瑕疵的
@Fatalize我不确定。它发生在联机编译器中，而不是脱机。我认为这可能与Octave分页输出有关，但是现在我不确定这是否是原因
— Luis Mendo
1
@_@XD而不是@_D@D这样做的明智想法是，您可以在第一次运行时包括0。
— 桑契斯
3
XD+1表示笑脸
— TuxCrafting
16

莎士比亚编程语言，227字节

.
Ajax,.
Puck,.
Act I:
Scene I:
[Enter Ajax,Puck]
Puck:You ox!
Ajax:Be me without myself.Open thy heart.
Scene II:      
Ajax:Be thyself and ash.Open thy heart.Be me times you.Open thy heart.Be me times you.Let us return to scene II.

显然，这个答案遥遥无期，但我喜欢这是SPL比较适合的用例。

解释：

// Everything before the first dot is the play's title, the parser treats it as a comment.
.

// Dramatis personae. Must be characters from Shakespeare's plays, again with a comment.
Ajax,.
Puck,.

// Acts and scenes serve as labels. Like the whole play, they can have titles too,
// but for the sake of golfing I didn't give them any.
Act I:

// This scene would've been named "You are nothing"
Scene I:

// Characters can talk to each other when on stage
[Enter Ajax,Puck]

// Characters can assign each other values by talking. Nice nouns = 1, ugly nouns = -1.
Puck: You ox!                 // Assignment: $ajax = -1;
Ajax: Be me without myself.   // Arithmetic: $puck = $ajax - $ajax;
      Open thy heart.         // Standard output in numerical form: echo $puck;

// Working title "The circle of life"
Scene II:

// Poor Ajax always doing all the work for us
Ajax: Be thyself and ash.          // $puck = $puck + (-1);
      Open thy heart.              // echo $puck;
      Be me times you.             // $puck *= $ajax;  (remember $ajax==-1 from scene I)
      Open thy heart.              // echo $puck;
      Be me times you.             // negate again
      Let us return to scene II.   // infinite goto loop

正如您所看到的，当将此代码与我对相关挑战的答案进行永久计数（即打印所有自然数）时，当问题大小增加时，SPL代码长度会增长得非常糟糕...

— 克里斯托克
source
1
我喜欢这个。打高尔夫球很糟糕，但是阅读却很棒。
— 猪鱼16/09/19
错字说明的最后一行。Let us return to scene II.应该是scene I。
— 奥利弗·尼
感谢您指出差异！错字实际上是在上面的代码中：我们不能重复场景I，因为它将重置$puck为0，然后向上计数将不再起作用。我I在代码中添加了缺失内容，并更正了字节长度（无论如何，还是有点错了）
— Christallkeks，2016年
14

Python 2，27个字节

n=0
while 1:print~n,n,;n+=1

版画 -1 0 -2 1 -3 2 -4 3 ...

— 异或
source
10

05AB1E，9 6字节

感谢Adnan，节省了3个字节

[ND,±,

在线尝试！

打印0, -1, 1, -2, 2 ...用换行符分隔。

— 艾米尼亚
source
2
我可以使用一些按位魔术将其缩减到6个字节[N,N±,。
— 阿德南
1
@Adnan：太好了！我曾尝试做类似的事情，但是没有使用±，它的长度比您的长3个字节。
— Emigna
我知道已经有一段时间了，但是D,可以替换=为保存一个字节。
— Kevin Cruijssen
10

GNU sed，189 + 2（rn个标志）= 191个字节

这很可能是最长的解决方案，因为sed没有整数类型或算术运算。因此，我不得不仅使用正则表达式来模拟任意大小的增量运算符。

s/^/0/p
:
:i;s/9(@*)$/@\1/;ti
s/8(@*)$/9\1/
s/7(@*)$/8\1/
s/6(@*)$/7\1/
s/5(@*)$/6\1/
s/4(@*)$/5\1/
s/3(@*)$/4\1/
s/2(@*)$/3\1/
s/1(@*)$/2\1/
s/0(@*)$/1\1/
s/^@+/1&/;y/@/0/
s/^/-/p;s/-//p
t

跑：

echo | sed -rnf all_integers.sed

输出：

0
-1
1
-2
2
-3
3
etc.
— Seshoumara
source
10

Brainfuck，127个字节

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

在线尝试！

给定无限的磁带，理论上将永远运行。

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

未压缩

+[-->+>+[<]>-]>-->+
[
  [.<<<]>>-.>>+<
  [[-]>[->+<]
    ++++++++[-<++++++>>-<]>--
    [++++++++++>->-<<[-<+<+>>]]>+>+<
  ]<<<
  [.<<<]>>.+.>
  [>>>]<<<
]
— 原始
source
9

ShadyAsFuck，3个字节

FVd

说明：

F     prints the current cell value (0) and increases it by 1
 V    starts a loop and prints the current value
  d   increases the current value and ends the loop

这将利用单元格换行并打印所有可能的值。在SAF中，本机整数表示形式是字节值。

— 瑕疵
source
5
这个答案是...阴暗的。
— Conor O'Brien
1
我想知道是谁提出了语言名称，然后我注意到了它的源语言。
— John Dvorak
8

R，25 24字节

感谢@JDL，打了一个字节。

repeat cat(-F,F<-F+1,'')

在线尝试！

输出示例：

0 1 -1 2 -2 3 -3 4 -4 5 -5 6 -6 7 -7 8 -8 9 -9 10
— 土拨鼠
source
2
您可以替换while(1)与repeat 保存字符。
— JDL
@JDL谢谢！我忘记了有时存在这种构造。
— rturnbull
7

批次，56个字节

@set n=0
:l
@echo %n%
@set/an+=1
@echo -%n%
@goto l

输出：

0
-1
1
-2
2
-3

等等，直到2147483647；58字节（如果要在输出中显示（-）2147483648）：

@set n=0
:l
@echo %n:-=%
@set/an-=1
@echo %n%
@goto l

如果打印所有支持的正整数，然后打印所有支持的负整数，然后不断重复，则为44字节：

@set n=0
:l
@echo %n%
@set/an+=1
@goto l
— 尼尔
source
7

Java 7中，151个 134 122 118字节

import java.math.*;void c(){for(BigInteger i=BigInteger.ONE,y=i;;i=i.add(y))System.out.println(y.subtract(i)+"\n"+i);}

@flawr（和间接@xnor）节省了12个字节

更改规则后。（59 56 63字节）

void c(){for(int i=0;i>1<<31;)System.out.println(~--i+"\n"+i);}

由于在Java中2147483647 + 1 = -2147483648，我们不能简单地i++无限执行并继续操作，因为面临的挑战是一次打印所有数字。使用上面添加了范围的代码，它将按以下顺序将所有整数从-2147483648到打印2147483647一次0, -1, 1, -2, 2, -3, 3, -4, ..., 2147483646, -2147483647, 2147483647, -2147483648。感谢@OlivierGrégoire指出Java关于MIN_VALUE-1/ 的行为MAX_VALUE+1。在这里尝试。

取消测试代码：

在这里尝试-导致运行时错误

import java.math.*;
class M{
  static void c() {
    for(BigInteger i = BigInteger.ONE, y = i; ; i = i.add(y)){
      System.out.println(y.subtract(i) + "\n" + i);
    }
  }

  public static void main(String[] a){
    c();
  }
}

输出：

0
1
-1
2
-2
3
-3
4
-4
5
-5
...
— 凯文·克鲁伊森
source
1
我认为您可以通过同时打印n和1-n来节省一些字节，这样可以消除比较。@xnor是第一个在此使用此想法的人。
— 瑕疵的
1
int给定无限时间，您的-version程序将在无限时间内打印每个整数。
— OlivierGrégoire'16
1
@OlivierGrégoire啊，当然，MAX_VALUE +1是MIN_VALUE。我已经对其进行了编辑，感谢您指出。
— 凯文·克鲁伊森
1
如果你想要更多的高尔夫球场（即摆脱的MAX_VALUE，你可以检查鸥我的回答（可能还在最后一页）。
— 奥利维尔格雷
1
您的53字节解决方案是代码段，而不是函数或程序，因此无效。
— Mego
6

DC（GNU或OpenBSD风格） -16个字节

该版本不短于以下版本，但应能够在PC中不爆炸堆栈的情况下运行。然而，无限大的数量会占用无限的内存...

由于该r命令，它需要GNU-DC或OpenBSD-DC。

0[rp1+45Pprdx]dx

测试：

$ dc -e '0[rp1+45Pprdx]dx' | head
0
-1
1
-2
2
-3
3
-4
4
-5

DC -16个字节

现在有点意思。;-)

此版本滥用堆栈长度作为计数器，同时使堆栈增长。

z[pz45Ppllx]dslx

测试：

$ dc -e 'z[pz45Ppllx]dslx' | head
0
-1
1
-2
2
-3
3
-4
4
-5

DC -17个字节

没有肮脏的把戏。

0[p1+45Ppllx]dslx

测试：

$ dc -e '0[p1+45Ppllx]dslx' | head
0
-1
1
-2
2
-3
3
-4
4
-5
— 雪人
source
+？对于“早晚……比您预期的更快”
— Greg Martin
2
代替[-]P，做45P。“ GNU-Dc或OpenBSD-Dc” -在野外是否有其他常见的版本？
— Digital Trauma
1
我有另一种解决方案（或几种），但是它们涉及实际的负数。我可以在新答案中发布它们吗？我之所以问是因为它们看起来很像这些，因为dc只有几个运算符。我确实独立于这些开发了它们。
— 乔
@DigitalTrauma ...确定... 原始DC没有/没有r作为“交换”。在查看不同版本时，有时会感到困惑。可能没有人希望再使用古老的Dc进行编码（并且r可以清除堆栈）。也许我会将“ Dc”更改为“ AT＆T dc”？...并感谢您的45P提示...
— Yeti
2
@yeti我只是在答案上加上“ dc”。我认为这里的人不会太担心，特别是考虑到“现代”直流风味无处不在的情况。
— Digital Trauma
6

C＃74字节

class P{void Main(){for(var x=0m;;System.Console.Write(x+++","+-x+","));}}

class P
{
    void Main()
    {
        for(var x = 0m; ; System.Console.Write(x++ + "," + -x + ","));
    }
}

输出：

0,-1,1,-2,2,-3,3,-4,4,-5,5,-6,6,-7,7,-8,8,-9,9,-10,10,...

试试吧：

dotnetfiddle.net （限制为1000）

— 亚历克斯
source
这些摘要不是功能/完整程序吗？
— pinkfloydx33 2013年
抱歉，已添加完整程序
— Alex
2
您可以省略public修饰符并保存14个字节。默认值将同样好。
— 亚历杭德罗
@Alejandro谢谢，这是我的第一篇文章:)
— alex
6

Ruby，26 22 19 16个字节

打印以换行符分隔的数字。@manatwork中的-3个字节。@ m-chrzan中的-3个字节。

0.step{|n|p~n,n}
— 价值墨水
source
您将在此处输出数值，因此p也将这样做。
— manatwork's
0.step{|n|p n,~n}为17个字节。
— m-chrzan
1
@ m-chrzan因为顺序无关紧要，所以除了您的建议外，我还可以剃掉一个额外的字节！
— Value Ink 2016年
6

JavaScript，29 26字节

非无限版本，26字节

ETHproductions节省了3个字节

for(n=1;;)alert([1-n,n++])

将显示-9007199254740991和9007199254740992之间的所有整数。

无限版本（ES6），114个 112字节

ETHproductions节省了2个字节

for(n=[-1];1;alert(n[a||n.unshift(1),0]?(x=n.join``)+' -'+x:0))for(i=n.length,a=0;i--;a=(n[i]+=1-a)>9?n[i]=0:1);

给定无限的时间和内存，它将显示所有整数。

— Arnauld
source
您可以删除功能样板，并将其称为完整程序。
— Conor O'Brien
@ ConorO'Brien-哦，对了。谢谢:)
— Arnauld
n[a,b,c]返回n[c]，因此您可以将括号放在中n[(a||n.unshift(1),0)]。
— ETHproductions 2013年
您不需要1in的for循环；for(;;)永远运行。您还可以使用保存两个字节for(n=1;;)alert([1-n,n++])。而且，它不再使用任何ES6功能；-)
— ETHproductions
5

> <>，19 15字节

1::1$-naonao1+!

打印以下内容：

0
1
-1
2
-2
3
-3

... 等等。分隔符是换行符。

阅读@xnor的答案以使用该算法的版本后重新编写。从开始n=1，该程序打印，1-n并n在增加之前分别打印一个换行符n。超过最大值后，程序将以错误结束something smells fishy...。确切的时间将取决于解释器的实现。

先前版本：

0:nao0$-:10{0(?$~+!

从0开始，程序无限循环。在每个循环中，当前值与换行符一起打印。然后取反，如果为正则递增。

— 索
source
xnor无疑是“他”吗？还是我们的无意识偏见显示...？
— 格雷格·马丁
2
@GregMartin有趣的是，我认为我从未提到过性别。
— xnor
5

Bash + GNU实用程序，26

seq NaN|sed '1i0
p;s/^/-/'
— 数字创伤
source
我从未见过seq使用过这种方式，这就像一个错误吗？另外，在类型溢出后会开始重复数字吗？我知道这样$[++i]做是bash。
— seshoumara
看起来像一个较新的功能-请参见源代码。将1加到NaN不会引起环绕。
— Digital Trauma
我离开seq NaN去跑步，在999999之后，以5位数精度的科学计数法完成了打印。关于挑战，该值是您打印的最大整数，这很好，因为其余值不会重复前一个数字。还注意到您可以使用seq进行操作inf，不区分大小写，就像for一样nan。+1
— seshoumara
5

bc，17 16字节

编辑：多亏了Digital Trauma少了1个字节。

除了目前为止所使用的语言的多样性之外，我还提出了一种bc解决方案，该解决方案可以处理任意大小的整数。代码后需要换行符，换行符以字节总数计。

for(;;){i;-++i}

在第一个迭代i中没有定义，但是打印它给我一个惊喜。

— Seshoumara
source
短1个字节：for(;;){i;-++i}
— Digital Trauma
@DigitalTrauma谢谢，我更新了我的答案。有趣的是，我今天在另一个bash答案中使用了该循环构造，但也忘记bc了它。
— seshoumara
或for(;;){i++;-i}（相同长度）。
— sch 2016年
5

迷宫，9字节

!`
\:"
 (

在线尝试！

这也有效并且基本相同：

 "
`:(
\!

说明

这段代码中的控制流程很有趣。请记住，迷宫程序中的指令指针（IP）遵循非空格字符的路径，并检查任何交界处的堆栈顶部以决定采用哪个路径：

  • 如果堆栈顶部为正，请向右拐。
  • 如果堆栈顶部为零，请继续向前移动。
  • 如果堆栈顶部为负，请向左拐。

当IP到达死胡同时，它会转过来（最后只执行一次命令）。IP从左上角开始向东移动。还要注意，堆栈以无限数量的零开始隐式填充。

程序以以下简短的开头：

!    Print top of stack (0).
`    Multiply by -1 (still 0).
:    Duplicate.

现在，IP位于相关的交界处，并直接向前移动到(，将栈顶递减至-1。IP陷入死胡同，转过身来。:再次复制堆栈的顶部。现在，堆栈的顶部为负数，并且IP向左转（向西）。现在，我们再执行一次主循环迭代：

\   Print linefeed.
!   Print top of stack (-1).
`   Multiply by -1 (1).
:   Duplicate.

这次，堆栈的顶部为正，因此IP向右转（向西），并立即执行主循环的另一次迭代，并打印出1。它再次被否定此之后，我们打的:跟-1在堆栈中。

这次IP向左转（向东）。这"只是一个禁忌，而IP却在死胡同中转弯。:再进行一次复制，这次IP向南。(将值减小到-2，IP再次转回。在堆栈顶部仍为负数的情况下，IP现在在上向西旋转:，并进行主循环的下一次迭代。

这样，IP现在将在紧循环迭代（打印一个正数）和一个遍历两个死胡同的迭代之间进行迭代，以在打印负数之前减少值。

您可能会问自己，"如果实际上什么都没做，那么第二行上为什么会有：如果没有它，当IP达到:负值时，它就不能向左转（向东），因此会向右转（向西） （根据经验，如果在交界处没有通常的方向，则IP将采用相反的方向）。这意味着IP也永远不会到达(底部，我们无法区分正迭代与负迭代。

— 马丁·恩德
source
这是我在看到您的答案之前想到的：pastebin.com/VHzAvABe
— Robert Hickman
5

JavaScript（ES5），32 31 30 29字节

for(i=0;;)[i++,-i].map(alert)

版画 0 -1 1 -2 2 -3 3 -4 4 -5 5 ...

感谢Patrick Roberts，节省了1个字节！感谢Conor O'Brien，节省了2个字节！

— 保罗·施密茨
source
1
怎么样[i++,-i].map(alert)，而不是alert(i++),alert(-i)？
— 科纳·奥布莱恩
for(;;)比while(1)
— Patrick Roberts
@ ConorO'Brien map是ES6
— Paul Schmitz
@PaulSchmitz Nope，第5版。
— 科纳·奥布莱恩
您可以i=0;在for循环内移动该位以保存一个字节。
— Conor O'Brien
4

Java，65 54字节

i->{for(;;)System.out.print(i+++" "+(-i<i?-i+" ":""));

取消测试代码

public static void main(String[] args) {
    Consumer<Integer> r = i -> {
        for (;;) {
            System.out.print(i++ + " " + (-i < i ? -i + " " : ""));
        }
    };

    r.accept(0);
}
— 肖恩·怀德（Shaun Wild）
source
3
biggest magnitude of the standard integer type of your language int是Java的标准整数类型。
— 肖恩·怀德（Shaun Wild）
1
抱歉，要求在此期间发生了变化...
— 瑕疵的
2
您可以将其()->{for(int i=0;;)System.out.print(i+" "+(1-i++));};
— 打入
@KevinCruijssen搞砸了间隔...
— 肖恩·
1
给定无限时间，它将对每个整数打印无限次。
— OlivierGrégoire'16
4

C＃，83个字节

void f(){for(decimal n=0;;n++){Console.Write(n+",");if(n>0)Console.Write(-n+",");}}

取消高尔夫：

void f()
{
  for (decimal n=0;;n++)
  {
    Console.Write(n + ",");
    if (n > 0) Console.Write(-n + ",");
   }
}

输出：

0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6.......
— 皮特·阿登
source
为了减少字符，可以做很多事情。首先，您的程序不需要名称空间。其次，类名不必太长。您还可以对console.writeline进行两次调用，这些调用可以简化为委托。while true可以简化为aa for（;;），并且if语句可以通过首先通过委托输出零值来删除。
— Nico
谢谢。我不知道代表是否可能在“作弊”？
— 皮特·阿登
嗨，欢迎来到PPCG！我认为您可能会阅读以下内容，这很有趣：C＃高尔夫技巧。另外，您不需要完整的程序，只需一个函数即可（除非挑战另有说明）。因此void f(){code_present_in_main}，字节数就足够了。至于代码本身，您可以像这样：void f(){for(decimal n=1;;)Console.Write((1-n)+","+n+++",");}（61字节）
— Kevin Cruijssen
1
哦，太好了，现在健康了85，谢谢！使用您的所有答案我都会觉得不对劲，但这绝对是一项改进，这些提示将有助于我将来的高尔夫运动！
— 皮特·阿登
我理解@PeteArden不使用我的代码，因为这是另一种方法。嗯，您仍然可以通过将decimal n=0and和n++;放置在for循环中来在自己的答案中打2个字节：void f(){for(decimal n=0;;n++){Console.Write(n+",");if(n>0)Console.Write(-n+",");}}:)
— Kevin Cruijssen
4

C＃86 66字节

新答案：

void b(){for(var i=0;;i++)Console.Write(i==0?","+i:","+i+",-"+i);}

明确：

void b() 
{
    for(var i=0;;i++)
        Console.Write(i == 0 ? "," + i : "," + i + ",-" + i);
}

旧答案（86字节）：

void a(){Console.Write(String.Join(",",Enumerable.Range(int.MinValue,int.MaxValue)));}

取消高尔夫：

void a()
{
    Console.Write(String.Join(",", Enumerable.Range(int.MinValue, int.MaxValue)));
}
— 丹尼尔·勒普斯
source
1
有2个无用的空格。一前Enumerable.Range一前int.MaxValue。
— Yytsi
1
欢迎来到PPCG！+1您可能会发现以下有趣的内容：C＃高尔夫技巧。在您当前的答案中，for循环的括号可以删除，因为里面只有一行。可替代地，这是一个更短的方法：void f(){for(var n=1;;)Console.Write((1-n)+","+n+++",");}（57个字节）。
— 凯文·克鲁伊森
@KevinCruijssen谢谢。括号不见了。
— 丹尼尔·勒普斯
4

Powershell，20 19 18字节

通过从TimmyD的答案中偷偷偷窃而得到改善 

0;for(){-++$i;$i}

输出：

0
-1
1
-2
2
-3
3
-4
4

旧版本：

for(){-$i;$i++;$i}

不知道为什么要使用tbh，但是- 未声明的变量（或-$ null）被评估为0，因此在此版本中为我们节省了2个字节...

— 随你
source
1
欢迎来到PPCG！
— AdmBorkBork
4

Brachylog，2个字节

ẉ⊥

在线尝试！

ẉ     Print with a newline
      the input,
 ⊥    then try again.

由于该程序没有输入，因此主谓词的输入变量不受约束。最初，它假定为0，但是当执行命中时⊥，它会回溯到唯一可能的故障点：输入变量的值选择。因此，它会尝试1和-1以及其他所有整数⊥，并始终打印每个换行符，因为它们总是强制回溯，并且ẉ立即执行效果。

— 不相关的字符串
source
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.