Escreva um programa ou função que imprima todos os números inteiros exatamente uma vez, com tempo e memória infinitos.

As saídas possíveis podem ser:

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, …

Esta não é uma saída válida, pois nunca enumeraria números negativos:

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

• A saída deve estar em decimal, a menos que seu idioma não suporte número inteiro decimal (nesse caso, use a representação natural de números inteiros que seu idioma usa).

• Seu programa precisa trabalhar com os números com a maior magnitude do tipo inteiro padrão do seu idioma.

• Cada número inteiro deve ser separado do próximo usando qualquer separador (um espaço, uma vírgula, uma quebra de linha etc.) que não seja um dígito nem o sinal negativo do seu idioma.

• O separador não deve mudar a qualquer momento.

• O separador pode consistir em vários caracteres, desde que nenhum deles seja um dígito nem o sinal negativo (por exemplo, , é tão válido quanto justo ,).

• Qualquer número inteiro suportado deve, eventualmente, ser impresso após um período finito de tempo.

Pontuação

Isso é código-golfe , então a resposta mais curta em bytes vence

Entre os melhores

var QUESTION_ID=93441,OVERRIDE_USER=41723;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Sesos , 11 ₃ 3 bytes

0000000: c4ceb9                                            ...

Experimente online! Marque Debug para ver o código SBIN gerado.

Montagem Sesos

O arquivo binário acima foi gerado montando o seguinte código SASM.

set numout

jmp ; implicitly promoted to nop
    put,   fwd 1
    sub 1, put
    rwd 1, add 1
; jnz (implicit)

Haskell, 19 bytes

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

Produz a lista infinita [0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6,7,-7...

Haskell permite listas infinitas nativamente. A impressão dessa lista imprime seus elementos uma vez para sempre.

Brainfuck, 6 bytes

Isso utiliza o agrupamento de células e imprime todos os valores possíveis. No Brainfuck, a representação inteira nativa é pelo valor de byte .

.+[.+]

Experimente online!

Cubix , 14 12 bytes

.(.\OSo;?.>~

Teste online! Agora você pode ajustar a velocidade se quiser que ela corra mais rápido ou mais devagar.

Como funciona

A primeira coisa que o intérprete faz é remover todo o espaço em branco e preencher o código com no-ops .até que ele caiba perfeitamente em um cubo. Isso significa que o código acima também pode ser escrito assim:

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

Agora o código está sendo executado. O IP (ponteiro de instrução) começa no canto superior esquerdo da face esquerda, apontado para leste. Aqui estão os caminhos a seguir ao longo da execução do programa:

O IP começa na trilha vermelha na extrema esquerda da imagem. Em seguida OSo;, é executado , o que faz o seguinte:

• OImprima os TOS (topo da pilha) como um número inteiro. No início do programa, a pilha contém zeros infinitos, então isso é impresso 0.
• SEmpurre 32, o código de caractere para o caractere de espaço.
• oImprima os Termos de Serviço como um caractere. Isso imprime um espaço.
• ;Faça o TOS. Remove o 32da pilha.

Agora o IP atinge o ?, que o direciona para a esquerda, direita ou reta, dependendo do sinal dos Termos de Serviço. No momento, o TOS é 0, então segue direto. Este é o caminho azul; .não faz nada e o IP atinge a seta >, que o direciona para o leste ao longo do caminho vermelho novamente. ~pega o NOT bit a bit do TOS, alterando-o para -1.

Aqui, o IP atinge a borda direita da rede, que o envolve de volta para a esquerda; isso novamente imprime os TOS (desta vez -1) e um espaço.

Agora o IP atinge ?novamente. Desta vez, o TOS é -1; Como isso é negativo, o IP vira à esquerda, seguindo o caminho verde. O espelho \desvia o IP para o (, que diminui os TOS, alterando-o para -2. Ele volta e acerta a flecha; ~leva bit a bit NOT novamente, virando -2para 1.

Novamente, o TOS é emitido e um espaço é impresso. Desta vez, quando o IP atinge o ?, o TOS é 1; Como isso é positivo, o IP vira à direita, seguindo o caminho amarelo. O primeiro operador que encontra é Sempurrar um extra 32; o ;abre antes que possa causar qualquer problema.

Agora, o IP volta para a seta e executa sua rotina, ~alterando os Termos de Serviço -2e Oimprimindo-os. Como os TOS são negativos novamente, o IP segue o caminho verde mais uma vez. E continua a pedalar assim para sempre *: vermelho, verde, vermelho, amarelo, vermelho, verde, vermelho, amarelo ..., imprimindo no seguinte ciclo:

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

TL; DR

Este programa repete repetidamente estas três etapas fáceis:

1. Envie o número atual e um espaço.
2. Se o número atual for negativo, diminua-o em 1.
3. Tome bit NÃO do número atual.

Versão não separada, 6 bytes

nO?~>~

A remoção da separação simplifica tanto o programa que ele pode caber em um cubo de unidade:

  n
O ? ~ >
  ~

* Nota : nenhum dos programas é realmente infinito, pois conta apenas até 2 ⁵² (quando o JavaScript começa a perder precisão inteira).

MATL , 8 bytes

0`@_@XDT

Isso usa o tipo de dados padrão do MATL, que é double, portanto, funciona 2^53em valor absoluto. A saída é

0
-1
1
-2
2
···

Experimente online!

Explicação

0            % Push 0
  `     T    % Do...while true: infinite loop
   @_        % Push iteration index and negate
     @       % Push iteration index
      XD     % Display the whole stack

Linguagem de programação de Shakespeare , 227 bytes

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

Obviamente, essa resposta não está nem perto de ganhar, mas eu gostei que esse seja um caso de uso em que o SPL seja comparativamente adequado.

Explicado:

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

Como você pode ver ao comparar esse código à minha resposta ao desafio relacionado de contar para sempre (ou seja, imprimir todos os números naturais), o tamanho do código SPL aumenta bastante quando o tamanho do problema aumenta ...

Python 2, 27 bytes

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

Impressões -1 0 -2 1 -3 2 -4 3 ...

05AB1E , 9 6 bytes

Economizou 3 bytes graças a Adnan

[ND,±,

Experimente online!

Imprime 0, -1, 1, -2, 2 ...separado por novas linhas.

GNU sed, 189 + 2 (sinalizadores de rn) = 191 bytes

Essa é provavelmente a solução mais longa, pois o sed não possui operações de tipo inteiro ou aritmética. Como tal, tive que emular um operador de incremento de tamanho arbitrário usando apenas expressões regulares.

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

Corre:

echo | sed -rnf all_integers.sed

Resultado:

0
-1
1
-2
2
-3
3
etc.

Brainfuck, 127 bytes

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

Experimente online!

Dada uma fita infinita, teoricamente, funcionaria para sempre.

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

Descomprimido

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

ShadyAsFuck , 3 bytes

FVd

Explicação:

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

Isso utiliza o agrupamento de células e imprime todos os valores possíveis. No SAF, a representação inteira nativa é pelo valor de byte .

R, 25 24 bytes

Golpeou um byte graças a @JDL.

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

Experimente online!

Exemplo de saída:

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

Lote, 56 bytes

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

Resultado:

0
-1
1
-2
2
-3

etc. Funciona até 2147483647; 58 bytes, se desejar (-) 2147483648 na saída:

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

44 bytes se a impressão de todos os números inteiros positivos suportados, todos os números inteiros negativos suportados e a repetição sem fim forem aceitáveis:

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

Java 7, 151 134 122 118 bytes

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

12 bytes salvos graças a @flawr (e @xnor indiretamente)

Após a alteração da regra .. ( 59 56 63 bytes)

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

Como em Java 2147483647 + 1 = -2147483648, não podemos simplesmente fazer i++e continuar infinitamente, pois o desafio era imprimir todos os números uma vez. Com o código acima com escala adicionado, ele, ao contrário, imprimir todos os números inteiros de -2147483648até 2147483647uma vez cada, na seguinte seqüência: 0, -1, 1, -2, 2, -3, 3, -4, ..., 2147483646, -2147483647, 2147483647, -2147483648. Obrigado a @ OlivierGrégoire por apontar o comportamento do Java em relação a MIN_VALUE-1/ MAX_VALUE+1. Experimente aqui.

Ungolfed & código de teste:

Experimente aqui - resultando em erro de tempo de execução

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();
  }
}

Resultado:

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

DC (sabor GNU ou OpenBSD) - 16 bytes

Esta versão não é mais curta que a versão abaixo, mas deve poder ser executada sem a pilha explodir no seu PC. No entanto, grandes números infinitos ocupam quantidades infinitas de memória ... em algum momento ...

Por causa do rcomando, ele precisa do GNU-DC ou do OpenBSD-DC .

0[rp1+45Pprdx]dx

Teste:

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

DC - 16 bytes

Um pouco malvado agora. ;-)

Esta versão está abusando do comprimento da pilha como contador, enquanto deixa a pilha crescer.

z[pz45Ppllx]dslx

Teste:

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

DC - 17 bytes

Sem truques sujos.

0[p1+45Ppllx]dslx

Teste:

$ dc -e '0[p1+45Ppllx]dslx' | head
0
-1
1
-2
2
-3
3
-4
4
-5

Bytes em 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 + ","));
    }
}

Resultado:

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

Tente:

dotnetfiddle.net (limitado a 1000)

Ruby, 26 22 19 16 bytes

Imprime números separados por novas linhas. -3 bytes de @manatwork. -3 bytes de @ m-chrzan.

0.step{|n|p~n,n}

JavaScript, 29 26 bytes

Versão não infinita, 26 bytes

Economizou 3 bytes graças a ETHproductions

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

exibirá todos os números inteiros entre -9007199254740991 e 9007199254740992.

Versão infinita (ES6), 114 112 bytes

Economizou 2 bytes graças a ETHproductions

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

exibirá todos os números inteiros, com tempo e memória infinitos.

> <> , 19 15 bytes

1::1$-naonao1+!

Isso imprime o seguinte:

0
1
-1
2
-2
3
-3

... e assim por diante. O separador é uma nova linha.

Reescrito depois de ler a resposta do @ xnor para usar uma versão desse algoritmo. Começando em n=1, o programa imprime 1-ne n, cada um seguido por uma nova linha, antes de incrementar n. Após exceder o valor máximo, o programa terminará com um erro de something smells fishy.... Exatamente quando isso acontecerá depende da implementação do intérprete.

Versão anterior:

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

Começando em 0, o programa faz um loop indefinidamente. Em cada loop, o valor atual é impresso junto com uma nova linha. É então negado e incrementado se positivo.

Utilitários Bash + GNU, 26

seq NaN|sed '1i0
p;s/^/-/'

bc, 17 16 bytes

Edit: 1 byte a menos, graças ao Digital Trauma .

Além da diversidade de idiomas usados ​​até agora, apresento uma solução bc que funciona com números inteiros de tamanho arbitrário . Uma nova linha é necessária após o código e é contada no total de bytes.

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

Na primeira iteração inão está definida, mas a impressão dá 0 para minha surpresa.

Labirinto , 9 bytes

!`
\:"
 (

Experimente online!

Isso também funciona e é essencialmente o mesmo:

 "
`:(
\!

Explicação

O fluxo de controle nesse código é bastante engraçado. Lembre-se de que o ponteiro de instrução (IP) em um programa Labirinto segue o caminho de caracteres não espaciais e examina a parte superior da pilha em qualquer junção para decidir qual caminho seguir:

• Se o topo da pilha for positivo, vire à direita.
• Se o topo da pilha for zero, continue em frente.
• Se a parte superior da pilha for negativa, vire à esquerda.

Quando o IP atinge um beco sem saída, ele se vira (executando o comando no final apenas uma vez). E o IP começa no canto superior esquerdo, movendo-se para o leste. Observe também que a pilha é implicitamente preenchida com uma quantidade infinita de zeros para começar.

O programa começa com este pequeno bit:

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

Agora, o IP está na junção relevante e avança para o (que diminui o topo da pilha para -1. O IP atinge um beco sem saída e se vira. :duplica o topo da pilha mais uma vez. Agora, o topo da pilha é negativo e o IP vira à esquerda (oeste). Agora, executamos mais uma iteração do loop principal:

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

Desta vez, a parte superior da pilha é positiva; portanto, o IP vira à direita (oeste) e imediatamente executa outra iteração do loop principal, que imprime o 1. Em seguida, depois de ter sido negado novamente, bateu o :com -1na pilha.

Desta vez, o IP vira à esquerda (leste). O "é apenas um no-op e o IP gira no beco sem saída. :faz outra cópia e desta vez o IP vira para o sul. (diminui o valor para -2, o IP volta novamente. Com o topo da pilha ainda negativo, o IP agora vira para oeste no :e faz a próxima iteração do loop principal.

Dessa maneira, o IP agora iterará entre uma iteração de loop estreito, imprimindo um número positivo e uma iteração que passa pelos dois becos sem saída para diminuir o valor antes de imprimir um número negativo.

Você pode se perguntar por que existe "a segunda linha se ela realmente não faz nada: sem ela, quando o IP atinge :um valor negativo, ele não pode virar à esquerda (leste) e, portanto, virar à direita (oeste) (como regra geral, se a direção usual em uma junção não estiver disponível, o IP seguirá a direção oposta). Isso significa que o IP também nunca alcançaria o (nível mais baixo e não conseguimos distinguir iterações positivas de negativas.

JavaScript (ES5), 32 31 30 29 bytes

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

Impressões 0 -1 1 -2 2 -3 3 -4 4 -5 5 ...

Guardado 1 byte graças a Patrick Roberts! Economizou 2 bytes graças a Conor O'Brien!

Java, 65 54 bytes

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

Código de teste ungolfed

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

    r.accept(0);
}

C #, 83 bytes

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

Ungolfed:

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

Saídas:

0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6.......

C # 86 66 bytes

Nova resposta:

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

Claro:

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

Resposta antiga (86 bytes):

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

Ungolfed:

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

J, 25 bytes

([:$:1:`-`(1+-)@.*[echo)0

Trabalhos sobre site online , mas ainda não consigo verificá-lo no computador. Imprime números como:

0
1
_1
2
_2
3
_3
4

etc.

Powershell, 20 19 18 bytes

Melhorado roubando descaradamente a resposta de TimmyD

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

Resultado:

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

Versão antiga:

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

Não sei por que tbh, mas - a variável não declarada (ou - $ null) é avaliada como 0, o que nos salvou 2 bytes nesta versão ...

Pyke , 7 2 bytes

~I

Experimente aqui!

7 bytes

oDID_)r

Experimente aqui!

Se imprimir + -0 estiver ok, oD_r

Braquilog , 2 bytes

ẉ⊥

Experimente online!

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

Como o programa não recebe nenhuma entrada, a variável de entrada do predicado principal é deixada sem restrição. Inicialmente, assume-se que seja 0, mas quando a execução ⊥é atingida, ela retorna ao único ponto de falha possível: a escolha do valor para a variável de entrada. Então, ele tenta 1, -1 e todos os outros números inteiros, imprimindo cada um deles separado por novas linhas para ⊥sempre, porque sempre força o retorno e o efeito de ẉé executado imediatamente.