Scrivi un programma o una funzione che stamperà tutti gli interi esattamente una volta dati tempo e memoria infiniti.

Le possibili uscite potrebbero essere:

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

Questo non è un output valido, in quanto non enumererebbe mai i numeri negativi:

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

• L'output deve essere decimale, a meno che la tua lingua non supporti l'intero decimale (in tal caso usa la rappresentazione naturale degli interi che usa la tua lingua).

• Il tuo programma deve lavorare fino ai numeri con la massima grandezza del tipo intero standard della tua lingua.

• Ogni numero intero deve essere separato dal successivo utilizzando qualsiasi separatore (uno spazio, una virgola, un'interruzione di riga, ecc.) Che non sia una cifra né il segno negativo della tua lingua.

• Il separatore non deve cambiare in nessun punto.

• Il separatore può essere composto da più caratteri, purché nessuno di essi sia una cifra né un segno negativo (ad es. , È valido come solo ,).

• Qualsiasi numero intero supportato deve essere infine stampato dopo un periodo di tempo limitato.

punteggio

Questo è code-golf , quindi vince la risposta più breve in byte

Classifica

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 byte

0000000: c4ceb9                                            ...

Provalo online! Controlla Debug per vedere il codice SBIN generato.

Assemblaggio Sesos

Il file binario sopra è stato generato assemblando il seguente codice SASM.

set numout

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

Haskell, 19 byte

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

Produce l'elenco infinito [0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6,7,-7...

Haskell consente nativamente infiniti elenchi. La stampa di tale elenco stampa i suoi elementi uno alla volta per sempre.

Brainfuck, 6 byte

Questo utilizza il wrapping delle celle e stampa tutti i possibili valori. In Brainfuck, la rappresentazione intera nativa è in base al valore byte .

.+[.+]

Provalo online!

Cubix , 14 12 byte

.(.\OSo;?.>~

Provalo online! Ora puoi regolare la velocità se vuoi che funzioni più velocemente o più lentamente.

Come funziona

La prima cosa che fa l'interprete è rimuovere tutti gli spazi bianchi e riempire il codice con nessuna operazione .finché non si adatta perfettamente a un cubo. Ciò significa che il codice sopra può anche essere scritto in questo modo:

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

Ora il codice è in esecuzione. L'IP (puntatore alle istruzioni) inizia nell'angolo in alto a sinistra della faccia dell'estrema sinistra, puntato verso est. Ecco i percorsi necessari durante l'esecuzione del programma:

L'IP inizia sulla scia rossa all'estrema sinistra dell'immagine. Quindi viene eseguito OSo;, il seguente:

• OStampa il TOS (parte superiore dello stack) come numero intero. All'inizio del programma, lo stack contiene zero infiniti, quindi questo stampa 0.
• SPush 32, il codice carattere per il carattere spazio.
• oStampa il TOS come personaggio. Questo stampa uno spazio.
• ;Pop il TOS. Rimuove lo 32dallo stack.

Ora l'IP colpisce il ?, che lo dirige a sinistra, a destra o dritto a seconda del segno del TOS. In questo momento, il TOS è 0, quindi va dritto. Questo è il percorso blu; .non fa nulla e l'IP colpisce la freccia >, che la dirige nuovamente verso est lungo il percorso rosso. ~prende il NOT bit a bit del TOS, cambiandolo in -1.

Qui l'IP raggiunge il bordo destro della rete, che lo avvolge nuovamente a sinistra; questo stampa di nuovo il TOS (questa volta -1) e uno spazio.

Ora l'IP colpisce di ?nuovo. Questa volta, il TOS è -1; poiché questo è negativo, l'IP gira a sinistra, prendendo il percorso verde. Lo specchio \devia l'IP su (, che diminuisce il TOS, cambiandolo in -2. Torna indietro e colpisce la freccia; ~prende di nuovo NON bit a bit, girando -2a 1.

Anche in questo caso viene emesso il TOS e viene stampato uno spazio. Questa volta quando l'IP colpisce il ?, il TOS è 1; poiché questo è positivo, l'IP gira a destra, prendendo il percorso giallo. Il primo operatore che incontra è S, spingendo un extra 32; lo ;fa scoppiare prima che possa causare problemi.

Ora l'IP torna alla freccia ed esegue la sua routine, ~cambiando il TOS -2e Ostampandolo. Dato che il TOS è di nuovo negativo, l'IP prende ancora una volta il percorso verde. E continua a pedalare così per sempre *: rosso, verde, rosso, giallo, rosso, verde, rosso, giallo ..., stampa nel seguente ciclo:

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

TL; DR

Questo programma esegue ripetutamente questi 3 semplici passaggi:

1. Emette il numero corrente e uno spazio.
2. Se il numero corrente è negativo, decrementalo di 1.
3. Prendi a bit NON il numero corrente.

Versione non separata, 6 byte

nO?~>~

La rimozione della separazione semplifica il programma così tanto che può adattarsi a un cubo unità:

  n
O ? ~ >
  ~

* Nota : nessuno dei due programmi è veramente infinito, poiché contano solo fino a 2 ⁵² (dove JavaScript inizia a perdere la precisione dei numeri interi).

MATL , 8 byte

0`@_@XDT

Questo utilizza il tipo di dati predefinito MATL, che è double, quindi funziona fino a 2^53in valore assoluto. L'output è

0
-1
1
-2
2
···

Provalo online!

Spiegazione

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

Shakespeare Programming Language , 227 byte

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

Ovviamente, questa risposta non è affatto vincente, ma mi è piaciuto che si tratti di un caso d'uso a cui SPL è relativamente adatto.

Ha spiegato:

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

Come puoi vedere confrontando questo codice con la mia risposta alla sfida correlata di contare per sempre (cioè stampare tutti i numeri naturali), la lunghezza del codice SPL aumenta piuttosto male quando aumenta la dimensione del problema ...

Python 2, 27 byte

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

stampe -1 0 -2 1 -3 2 -4 3 ...

05AB1E , 9 6 byte

Salvato 3 byte grazie ad Adnan

[ND,±,

Provalo online!

Stampe 0, -1, 1, -2, 2 ...separate da newline.

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

Questa è probabilmente la soluzione più lunga, poiché sed non ha alcun tipo intero né operazioni aritmetiche. Come tale, ho dovuto emulare un operatore di incremento di dimensione arbitrario usando solo espressioni regolari.

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

Correre:

echo | sed -rnf all_integers.sed

Produzione:

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

Brainfuck, 127 byte

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

Provalo online!

Dato che un nastro infinito teoricamente avrebbe funzionato per 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,...

Non compresso

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

ShadyAsFuck , 3 byte

FVd

Spiegazione:

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

Questo utilizza il wrapping delle celle e stampa tutti i possibili valori. In SAF, la rappresentazione intera nativa è in base al valore byte .

R, 25 24 byte

Golfato di un byte grazie a @JDL.

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

Provalo online!

Esempio di output:

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

Lotto, 56 byte

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

Produzione:

0
-1
1
-2
2
-3

ecc. Funziona fino a 2147483647; 58 byte se si desidera (-) 2147483648 nell'output:

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

44 byte se la stampa di tutti gli interi positivi supportati, quindi tutti gli interi negativi supportati, quindi si ripete all'infinito, è accettabile:

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

Java 7, 151 134 122 118 byte

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 byte salvati grazie a @flawr (e @xnor indirettamente)

Dopo la modifica della regola .. ( 59 56 63 byte)

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

Dato che in Java 2147483647 + 1 = -2147483648, non possiamo semplicemente fare i++e continuare all'infinito, poiché la sfida era stampare tutti i numeri una volta. Con il codice di cui sopra con la gamma aggiunto, sarà invece di stampare tutti i numeri interi da -2147483648a 2147483647una volta ciascuno, nel seguente ordine: 0, -1, 1, -2, 2, -3, 3, -4, ..., 2147483646, -2147483647, 2147483647, -2147483648. Grazie a @ OlivierGrégoire per aver segnalato il comportamento di Java in merito a MIN_VALUE-1/ MAX_VALUE+1. Provalo qui.

Codice non testato e test:

Provalo qui - con conseguente errore di runtime

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

Produzione:

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

DC (GNU o OpenBSD) - 16 byte

Questa versione non è più corta della versione seguente ma dovrebbe essere in grado di funzionare senza che lo stack esploda nel tuo PC. Tuttavia infiniti numeri grandi occuperanno infinite quantità di memoria ... in qualche modo ...

A causa del rcomando necessita di GNU-DC o OpenBSD-DC .

0[rp1+45Pprdx]dx

Test:

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

DC - 16 byte

Un po 'cattivo ora. ;-)

Questa versione sta abusando della lunghezza dello stack come contatore mentre fa crescere lo stack.

z[pz45Ppllx]dslx

Test:

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

DC - 17 byte

Senza trucchi sporchi.

0[p1+45Ppllx]dslx

Test:

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

C # 74 byte

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

Produzione:

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

Provalo:

dotnetfiddle.net (limitato a 1000)

Rubino, 26 22 19 16 byte

Stampa i numeri separati da nuove righe. -3 byte da @manatwork. -3 byte da @ m-chrzan.

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

JavaScript, 29 26 byte

Versione non infinita, 26 byte

Risparmiato 3 byte grazie a ETHproductions

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

visualizzerà tutti i numeri interi compresi tra -9007199254740991 e 9007199254740992.

Versione infinita (ES6), 114 112 byte

Risparmiato 2 byte grazie 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);

visualizzerà tutti i numeri interi, dati il ​​tempo e la memoria infiniti.

> <> , 19 15 byte

1::1$-naonao1+!

Ciò stampa quanto segue:

0
1
-1
2
-2
3
-3

... e così via. Il separatore è una nuova riga.

Riscritto dopo aver letto la risposta di @ xnor per utilizzare una versione di tale algoritmo. A partire da n=1, il programma stampa 1-ne n, ciascuno seguito da una nuova riga, prima di incrementare n. Dopo aver traboccato il valore massimo, il programma terminerà con un errore di something smells fishy.... Esattamente quando ciò accadrà dipende dall'implementazione dell'interprete.

Versione precedente:

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

A partire da 0, il programma scorre in modo indefinito. Su ogni ciclo, il valore corrente viene stampato insieme a una nuova riga. Viene quindi negato e incrementato se positivo.

Utilità Bash + GNU, 26

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

bc, 17 16 byte

Modifica: 1 byte in meno grazie a Digital Trauma .

Aggiungendo alla diversità dei linguaggi finora utilizzati, presento una soluzione bc che funziona con numeri interi di dimensioni arbitrarie . Una nuova riga è richiesta dopo il codice e viene conteggiata nel totale dei byte.

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

Nella prima iterazione inon è definito, ma la stampa dà 0 con mia sorpresa.

Labirinto , 9 byte

!`
\:"
 (

Provalo online!

Questo funziona anche ed è essenzialmente lo stesso:

 "
`:(
\!

Spiegazione

Il flusso di controllo in questo codice è piuttosto divertente. Ricorda che il puntatore di istruzioni (IP) in un programma Labyrinth segue il percorso di caratteri non spaziali ed esamina la parte superiore dello stack in qualsiasi giunzione per decidere quale percorso prendere:

• Se la parte superiore della pila è positiva, girare a destra.
• Se la parte superiore della pila è zero, continua a muoverti dritto.
• Se la parte superiore della pila è negativa, girare a sinistra.

Quando l'IP raggiunge un vicolo cieco, si gira (eseguendo il comando alla fine una sola volta). E l'IP inizia nell'angolo in alto a sinistra spostandosi verso est. Si noti inoltre che lo stack è implicitamente riempito con una quantità infinita di zeri per cominciare.

Il programma inizia con questo breve bit:

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

Ora l'IP si trova sulla giunzione pertinente e si sposta direttamente sul (quale diminuisce la parte superiore dello stack -1. L'IP raggiunge un vicolo cieco e si gira. :duplica ancora una volta la parte superiore dello stack. Ora la parte superiore dello stack è negativa e l'IP gira a sinistra (ovest). Ora eseguiamo un'ulteriore iterazione del ciclo principale:

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

Questa volta, la parte superiore dello stack è positiva, quindi IP gira a destra (ovest) ed esegue immediatamente un'altra iterazione del ciclo principale, che stampa il file 1. Quindi dopo che è stato nuovamente negato, abbiamo colpito il :con -1nello stack.

Questa volta l'IP gira a sinistra (est). Il "è solo un no-op e il PI si gira nel vicolo cieco. :ne fa un'altra copia e questa volta l'IP gira a sud. (diminuisce il valore a -2, l'IP si gira di nuovo. Con la parte superiore dello stack ancora negativa, l'IP ora gira a ovest su :e esegue la successiva iterazione del ciclo principale.

In questo modo, l'IP ora eseguirà l'iterazione tra un'iterazione a ciclo stretto, stampando un numero positivo e un'iterazione che attraversa entrambi i vicoli ciechi per diminuire il valore prima di stampare un numero negativo.

Potresti chiederti perché c'è "la seconda riga se in realtà non fa nulla: senza di essa, quando l'IP raggiunge :un valore negativo, non può girare a sinistra (est) quindi girerebbe a destra (ovest) (come regola generale, se la solita direzione in corrispondenza di un incrocio non è disponibile, l'IP prenderà la direzione opposta). Ciò significa che anche l'IP non raggiungerebbe mai (il fondo e non siamo in grado di distinguere le iterazioni positive da quelle negative.

JavaScript (ES5), 32 31 30 29 byte

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

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

Salvato 1 byte grazie a Patrick Roberts! Salvato 2 byte grazie a Conor O'Brien!

Java, 65 54 byte

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

Codice di prova non golfato

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

    r.accept(0);
}

C #, 83 byte

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

Uscite:

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

C # 86 66 byte

Nuova risposta:

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

Chiaro:

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

Vecchia risposta (86 byte):

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 byte

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

Funziona sul sito online , ma non riesco ancora a verificarlo sul computer. Stampa numeri come:

0
1
_1
2
_2
3
_3
4

eccetera.

Powershell, 20 19 18 byte

Migliorato rubando spudoratamente dalla risposta di TimmyD

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

Produzione:

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

Vecchia versione:

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

Non so perché tbh, ma - la variabile non dichiarata (o - $ null) è valutata come 0, il che ci ha salvato 2 byte in questa versione ...

Pyke , 7 2 byte

~I

Provalo qui!

7 byte

oDID_)r

Provalo qui!

Se stampare + -0 è ok, oD_r

Brachylog , 2 byte

ẉ⊥

Provalo online!

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

Poiché al programma non viene fornito alcun input, la variabile di input del predicato principale non viene vincolata. Inizialmente, si presume che sia 0, ma quando l'esecuzione ha ⊥esito negativo, torna all'unico possibile punto di errore: la scelta del valore per la variabile di input. Quindi prova 1, -1 e tutti gli altri numeri interi, stampandoli per sempre separati da newline perché ⊥forza sempre il backtracking e l'effetto di ẉviene eseguito immediatamente.