Escriba un programa o función que pueda imprimir todos los enteros exactamente una vez dado un tiempo y memoria infinitos.

Los posibles resultados pueden 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 no es una salida válida, ya que esto nunca enumeraría números negativos:

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

• La salida debe estar en decimal, a menos que su idioma no admita enteros decimales (en ese caso, use la representación natural de enteros que usa su idioma).

• Su programa tiene que trabajar hasta los números con la mayor magnitud del tipo entero estándar de su idioma.

• Cada número entero debe separarse del siguiente utilizando cualquier separador (un espacio, una coma, un salto de línea, etc.) que no sea un dígito ni el signo negativo de su idioma.

• El separador no debe cambiar en ningún momento.

• El separador puede constar de varios caracteres, siempre que ninguno de ellos sea un dígito ni el signo negativo (por ejemplo, , es tan válido como solo ,).

• Cualquier número entero admitido debe imprimirse después de un período de tiempo finito.

Puntuación

Este es el código de golf , por lo que gana la respuesta más corta en bytes

Tabla de clasificación

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

Pruébalo en línea! Verifique la depuración para ver el código SBIN generado.

Asamblea Sesos

El archivo binario anterior se ha generado al ensamblar el siguiente 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]

Produce la lista infinita. [0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6,7,-7...

Haskell permite infinitas listas de forma nativa. Imprimir dicha lista imprimirá sus elementos uno por vez para siempre.

Brainfuck, 6 bytes

Esto hace uso del ajuste de celda e imprime todos los valores posibles. En Brainfuck, la representación entera nativa es por valor de byte .

.+[.+]

Pruébalo en línea!

Cubix , 14 12 bytes

.(.\OSo;?.>~

¡Pruébelo en línea! Ahora puede ajustar la velocidad si desea que funcione más rápido o más lento.

Cómo funciona

Lo primero que hace el intérprete es eliminar todo el espacio en blanco y rellenar el código con no-ops .hasta que encaje perfectamente en un cubo. Eso significa que el código anterior también se puede escribir así:

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

Ahora se ejecuta el código. El IP (puntero de instrucción) comienza en la esquina superior izquierda de la cara izquierda, apuntando al este. Estas son las rutas que toma durante el transcurso de la ejecución del programa:

La IP comienza en el camino rojo en el extremo izquierdo de la imagen. Luego se ejecuta OSo;, lo que hace lo siguiente:

• OImprima los TOS (top-of-stack) como un número entero. Al comienzo del programa, la pila contiene ceros infinitos, por lo que se imprime 0.
• SEmpuje 32, el código de char para el carácter de espacio.
• oImprime los TOS como un personaje. Esto imprime un espacio.
• ;Pop the TOS. Elimina el 32de la pila.

Ahora la IP golpea el ?, que lo dirige hacia la izquierda, la derecha o la recta según el signo de los TOS. En este momento, el TOS es 0, por lo que va directo. Este es el camino azul; .no hace nada, y la IP golpea la flecha >, que lo dirige al este a lo largo del camino rojo nuevamente. ~toma el NOT bit a bit del TOS, cambiándolo a -1.

Aquí la IP llega al borde derecho de la red, que la envuelve de nuevo a la izquierda; esto nuevamente imprime los TOS (esta vez -1) y un espacio.

Ahora la IP golpea de ?nuevo. Esta vez, el TOS es -1; Como esto es negativo, la IP gira a la izquierda, tomando el camino verde. El espejo \desvía la IP hacia el (, lo que disminuye el TOS, cambiándolo a -2. Vuelve y golpea la flecha; ~toma bit a bit NO de nuevo, girando el -2a 1.

Una vez más se imprime el TOS y se imprime un espacio. Esta vez, cuando la IP llega a ?, el TOS es 1; Como esto es positivo, la IP gira a la derecha, tomando el camino amarillo. El primer operador que encuentra es Sempujar un extra 32; el ;aparece antes de que pueda causar problemas.

Ahora la IP vuelve a la flecha y realiza su rutina, ~cambiando el TOS -2e Oimprimiéndolo. Dado que el TOS es negativo nuevamente, la IP toma el camino verde una vez más. Y sigue ciclando así para siempre *: rojo, verde, rojo, amarillo, rojo, verde, rojo, amarillo ..., imprimiéndose en el siguiente 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 realiza repetidamente estos 3 sencillos pasos:

1. Salida del número actual y un espacio.
2. Si el número actual es negativo, disminuya en 1.
3. Tome bit a bit NO del número actual.

Versión no separada, 6 bytes

nO?~>~

Eliminar la separación simplifica tanto el programa que puede caber en un cubo unitario:

  n
O ? ~ >
  ~

* Nota : Ninguno de los programas es realmente infinito, ya que solo cuentan hasta 2 ⁵² (donde JavaScript comienza a perder precisión entera).

MATL , 8 bytes

0`@_@XDT

Utiliza el tipo de datos predeterminado de MATL, que es double, por lo que funciona 2^53en valor absoluto. La salida es

0
-1
1
-2
2
···

Pruébalo en línea!

Explicación

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

Lenguaje de programación 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, esta respuesta no está cerca de ganar, pero me gustó que este es un caso de uso para el que el SPL es relativamente adecuado.

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 puede ver al comparar este código con mi respuesta al desafío relacionado de contar para siempre (es decir, imprimir todos los números naturales), la longitud del código SPL crece bastante mal cuando aumenta el tamaño del problema ...

Python 2, 27 bytes

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

Huellas dactilares -1 0 -2 1 -3 2 -4 3 ...

05AB1E , 9 6 bytes

Guardado 3 bytes gracias a Adnan

[ND,±,

Pruébalo en línea!

Impresiones 0, -1, 1, -2, 2 ...separadas por líneas nuevas.

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

Esta es probablemente la solución más larga, ya que sed no tiene tipo entero ni operaciones aritméticas. Como tal, tuve que emular un operador de incremento de tamaño arbitrario usando solo expresiones 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

Correr:

echo | sed -rnf all_integers.sed

Salida:

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

Brainfuck, 127 bytes

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

Pruébalo en línea!

Dada una cinta infinita, teóricamente funcionaría para siempre.

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

Sin comprimir

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

ShadyAsFuck , 3 bytes

FVd

Explicación:

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

Esto hace uso del ajuste de celda e imprime todos los valores posibles. En SAF, la representación entera nativa es por valor de byte .

R, 25 24 bytes

Golfé un byte gracias a @JDL.

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

Pruébalo en línea!

Salida de ejemplo:

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

Salida:

0
-1
1
-2
2
-3

etc. Funciona hasta 2147483647; 58 bytes si desea (-) 2147483648 en la salida:

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

44 bytes si se imprimen todos los enteros positivos admitidos, entonces todos los enteros negativos admitidos, y luego se repiten sin fin, es aceptable:

@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 guardados gracias a @flawr (y @xnor indirectamente)

Después del cambio de regla .. ( 59 56 63 bytes)

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

Dado que en Java 2147483647 + 1 = -2147483648, no podemos simplemente hacer i++y continuar infinitamente, ya que el desafío era imprimir todos los números una vez. Con el código anterior con rango añadido, será su lugar muestra todos los números enteros de -2147483648a 2147483647una vez cada uno, en el orden siguiente: 0, -1, 1, -2, 2, -3, 3, -4, ..., 2147483646, -2147483647, 2147483647, -2147483648. Gracias a @ OlivierGrégoire por señalar el comportamiento de Java con respecto a MIN_VALUE-1/ MAX_VALUE+1. Pruébalo aquí

Ungolfed y código de prueba:

Pruébelo aquí: se produce un error de tiempo de ejecución

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

Salida:

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

DC (sabor GNU u OpenBSD) - 16 bytes

Esta versión no es más corta que la versión siguiente, pero debería poder ejecutarse sin que la pila explote en su PC. Sin embargo, infinitos números grandes ocuparán cantidades infinitas de memoria ... en algún momento ...

Debido al rcomando necesita GNU-DC u OpenBSD-DC .

0[rp1+45Pprdx]dx

Prueba:

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

DC - 16 bytes

Un poco malo ahora. ;-)

Esta versión está abusando de la longitud de la pila como contador mientras deja que la pila crezca.

z[pz45Ppllx]dslx

Prueba:

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

DC - 17 bytes

Sin trucos sucios.

0[p1+45Ppllx]dslx

Prueba:

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

C # 74 bytes

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

Salida:

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

Intentalo:

dotnetfiddle.net (limitado a 1000)

Ruby, 26 22 19 16 bytes

Imprime números separados por nuevas líneas. -3 bytes de @manatwork. -3 bytes de @ m-chrzan.

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

JavaScript, 29 26 bytes

Versión no infinita, 26 bytes.

Guardado 3 bytes gracias a ETHproductions

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

mostrará todos los enteros entre -9007199254740991 y 9007199254740992.

Versión infinita (ES6), 114 112 bytes

Ahorró 2 bytes gracias 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);

mostrará todos los enteros, dado el tiempo y la memoria infinitos.

> <> , 19 15 bytes

1::1$-naonao1+!

Esto imprime lo siguiente:

0
1
-1
2
-2
3
-3

... y así. El separador es una nueva línea.

Reescrito después de leer la respuesta de @ xnor para usar una versión de ese algoritmo. Comenzando en n=1, el programa imprime 1-ny n, cada uno seguido de una nueva línea, antes de incrementar n. Después de desbordar el valor máximo, el programa terminará con un error de something smells fishy.... Exactamente cuándo ocurrirá esto depende de la implementación del intérprete.

Versión previa:

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

A partir de 0, el programa se repite indefinidamente. En cada bucle, el valor actual se imprime junto con una nueva línea. Luego se niega y se incrementa si es positivo.

Bash + GNU utilidades, 26

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

a. C., 17 16 bytes

Editar: 1 byte menos gracias a Digital Trauma .

Agregando a la diversidad de lenguajes usados ​​hasta ahora, presento una solución bc que funciona con enteros de tamaño arbitrario . Se requiere una nueva línea después del código y se cuenta en el total de bytes.

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

En la primera iteración ino está definida, pero la impresión da 0 para mi sorpresa.

Laberinto , 9 bytes

!`
\:"
 (

Pruébalo en línea!

Esto también funciona y es esencialmente lo mismo:

 "
`:(
\!

Explicación

El flujo de control en este código es bastante divertido. Recuerde que el puntero de instrucción (IP) en un programa Labyrinth sigue la ruta de los caracteres que no son espacios y examina la parte superior de la pila en cualquier cruce para decidir qué ruta tomar:

• Si la parte superior de la pila es positiva, gire a la derecha.
• Si la parte superior de la pila es cero, sigue avanzando en línea recta.
• Si la parte superior de la pila es negativa, gire a la izquierda.

Cuando la IP llega a un punto muerto, se da la vuelta (ejecutando el comando al final solo una vez). Y la IP comienza en la esquina superior izquierda hacia el este. También tenga en cuenta que la pila está implícitamente llena con una cantidad infinita de ceros para empezar.

El programa comienza con este breve fragmento:

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

Ahora la IP está en la unión relevante y avanza directamente hacia la (que disminuye la parte superior de la pila -1. La IP llega a un callejón sin salida y se da vuelta. :duplica la parte superior de la pila una vez más. Ahora la parte superior de la pila es negativa y la IP gira a la izquierda (oeste). Ahora ejecutamos una iteración más del bucle principal:

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

Esta vez, la parte superior de la pila es positiva, por lo que IP gira a la derecha (oeste) e inmediatamente ejecuta otra iteración del bucle principal, que imprime el 1. Luego, después de que se niega nuevamente, golpeamos :con -1en la pila.

Esta vez la IP gira a la izquierda (este). El "es simplemente un no-op y la IP se da vuelta en el callejón sin salida. :hace otra copia y esta vez la IP gira hacia el sur. (disminuye el valor a -2, la IP vuelve a girar. Con la parte superior de la pila aún negativa, la IP ahora gira hacia el oeste :y realiza la siguiente iteración del bucle principal.

De esta manera, la IP ahora iterará entre una iteración de bucle cerrado, imprimiendo un número positivo y una iteración que atraviesa ambos callejones sin salida para disminuir el valor antes de imprimir un número negativo.

Puede preguntarse por qué está "en la segunda línea si en realidad no hace nada: sin ella, cuando la IP alcanza :un valor negativo, no puede girar a la izquierda (este), por lo que en su lugar giraría a la derecha (oeste) (como regla general, si la dirección habitual en un cruce no está disponible, la IP tomará la dirección opuesta). Eso significa que la IP nunca alcanzaría la (parte inferior y no podríamos distinguir las iteraciones positivas de las negativas.

JavaScript (ES5), 32 31 30 29 bytes

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

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

¡Salvado 1 byte gracias a Patrick Roberts! ¡Ahorré 2 bytes gracias a Conor O'Brien!

Java, 65 54 bytes

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

Código de prueba sin golf

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

Sin golf:

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

Salidas:

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

C # 86 66 bytes

Nueva respuesta:

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

Respuesta anterior (86 bytes):

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

Sin golf:

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

J, 25 bytes

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

Funciona en el sitio en línea , pero todavía no puedo verificarlo en la computadora. Imprime números como:

0
1
_1
2
_2
3
_3
4

etc.

Powershell, 20 19 18 bytes

Mejorado al robar descaradamente de la respuesta de TimmyD

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

Salida:

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

Versión antigua:

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

No estoy seguro de por qué tbh, pero - la variable no declarada (o - $ null) se evalúa como 0, lo que nos ahorró 2 bytes en esta versión ...

Pyke , 7 2 bytes

~I

Pruébalo aquí!

7 bytes

oDID_)r

Pruébalo aquí!

Si imprimir + -0 está bien, oD_r

Brachylog , 2 bytes

ẉ⊥

Pruébalo en línea!

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

Como el programa no recibe ninguna entrada, la variable de entrada del predicado principal se deja sin restricciones. Al principio, se supone que es 0, pero cuando la ejecución golpea ⊥, retrocede al único punto posible de falla: la elección del valor para la variable de entrada. Entonces, intenta 1, y -1, y todos los demás enteros, imprimiendo cada uno separado por nuevas líneas para ⊥siempre porque siempre fuerza el retroceso, y el efecto de ẉse ejecuta de inmediato.