Ecrivez un programme ou une fonction qui imprimera de manière vérifiable tous les nombres entiers exactement une fois, avec un temps et une mémoire infinis.

Les sorties possibles pourraient être:

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

Ce n'est pas une sortie valide, car cela n'énumérerait jamais de nombres négatifs:

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

• La sortie doit être en décimal, sauf si votre langue ne prend pas en charge l'entier décimal (dans ce cas, utilisez la représentation naturelle des entiers utilisée par votre langue).

• Votre programme doit travailler jusqu’aux nombres avec la plus grande magnitude du type entier standard de votre langue.

• Chaque entier doit être séparé du suivant à l'aide d'un séparateur quelconque (un espace, une virgule, un saut de ligne, etc.) qui n'est ni un chiffre ni le signe négatif de votre langue.

• Le séparateur ne doit changer à aucun moment.

• Le séparateur peut être composé de plusieurs caractères, à condition qu'aucun d'entre eux ne soit un chiffre ni un signe négatif (par exemple, il , est aussi valide que juste ,).

• Tout entier pris en charge doit éventuellement être imprimé après un laps de temps déterminé.

Notation

C'est du code-golf , donc la réponse la plus courte en octets gagne

Classement

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 octets

0000000: c4ceb9                                            ...

Essayez-le en ligne! Cochez Debug pour voir le code SBIN généré.

Assemblage Sesos

Le fichier binaire ci-dessus a été généré en assemblant le code SASM suivant.

set numout

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

Haskell, 19 octets

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

Produit la liste infinie [0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6,7,-7...

Haskell permet des listes infinies de manière native. Imprimer une telle liste imprimera ses éléments un à la fois pour toujours.

Brainfuck, 6 octets

Cela utilise le retour à la ligne et imprime toutes les valeurs possibles. Dans Brainfuck, la représentation native sous forme d’ octets .

.+[.+]

Essayez-le en ligne!

Cubix , 14 12 octets

.(.\OSo;?.>~

Testez-le en ligne! Vous pouvez maintenant régler la vitesse si vous voulez qu'elle soit plus rapide ou plus lente.

Comment ça fonctionne

La première chose que fait l’interprète consiste à supprimer tous les espaces et à compléter le code avec no-ops .jusqu’à ce qu’il soit parfaitement adapté à un cube. Cela signifie que le code ci-dessus peut également être écrit comme ceci:

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

Maintenant, le code est exécuté. L’IP (pointeur d’instruction) commence dans le coin supérieur gauche de la face gauche extrême, en direction de l’est. Voici les chemins qu'il faut suivre tout au long de l'exécution du programme:

L'IP commence sur la piste rouge à l'extrême gauche de l'image. Il s'exécute ensuite OSo;et effectue les tâches suivantes:

• OImprimer le TOS (sommet de la pile) sous forme d’entier. Au début du programme, la pile contient des zéros infinis, ainsi ceci est imprimé 0.
• SPush 32, le code de caractère pour le caractère d'espace.
• oImprimer le TOS en tant que personnage. Cela imprime un espace.
• ;Pop le TOS. Supprime le 32de la pile.

Maintenant, l'IP frappe le ?, ce qui le dirige à gauche, à droite ou directement selon le signe du TOS. En ce moment, le TOS est 0, donc ça va tout droit. C'est le chemin bleu; .ne fait rien, et l'IP frappe la flèche >, ce qui le redirige vers l'est le long du chemin rouge. ~prend le bitwise PAS du TOS, en le changeant en -1.

Ici, l’IP atteint le bord droit du filet, qui le retourne à gauche; ceci affiche à nouveau le TOS (cette fois -1) et un espace.

Maintenant, l'IP frappe le ? nouveau. Cette fois, le TOS est -1; comme c'est négatif, l'IP tourne à gauche, en prenant le chemin vert. Le miroir \renvoie l'adresse IP vers le (, ce qui décrémente le TOS et le change en -2. Il revient et frappe la flèche; ~prend bitwise pas encore, en tournant -2à 1.

Là encore, le TOS est sorti et un espace est imprimé. Cette fois, lorsque l'IP frappe le ?, le TOS est 1; puisque c'est positif, l'IP tourne à droite, prenant le chemin jaune. Le premier opérateur qu’il rencontre est Sen poussant un extra 32; le fait ;apparaître avant qu'il puisse causer des ennuis.

Maintenant, l’IP revient à la flèche et effectue sa routine, ~ changeant le TOS -2et en l' Oimprimant. Comme le TOS est à nouveau négatif, l’IP reprend le chemin vert. Et ça continue comme ça pour toujours *: rouge, vert, rouge, jaune, rouge, vert, rouge, jaune ..., dans le cycle suivant:

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

TL; DR

Ce programme passe à plusieurs reprises par ces 3 étapes simples:

1. Affiche le nombre actuel et un espace.
2. Si le nombre actuel est négatif, décrémentez-le de 1.
3. Prenez bitwise PAS du nombre actuel.

Version non séparée, 6 octets

nO?~>~

La suppression de la séparation simplifie tellement le programme qu'il peut tenir sur un cube d'unité:

  n
O ? ~ >
  ~

* Remarque : aucun programme n'est vraiment infini, car ils ne comptent que jusqu'à 2 ⁵² (où JavaScript commence à perdre de la précision en nombre entier).

MATL , 8 octets

0`@_@XDT

Ceci utilise le type de données par défaut de MATL double, c’est-à-dire qu’il fonctionne jusqu’à 2^53valeur absolue. La sortie est

0
-1
1
-2
2
···

Essayez-le en ligne!

Explication

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

Langage de programmation Shakespeare , 227 octets

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

Évidemment, cette réponse est loin d’être gagnante, mais j’ai bien aimé qu’il s’agisse d’un cas d’utilisation à laquelle le SPL est relativement bien adapté.

A expliqué:

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

Comme vous pouvez le constater lorsque je compare ce code à ma réponse au défi connexe consistant à compter pour toujours (imprimer tous les nombres naturels), la longueur du code SPL augmente plutôt mal lorsque la taille du problème augmente ...

Python 2, 27 octets

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

Impressions -1 0 -2 1 -3 2 -4 3 ...

05AB1E , 9 6 octets

3 octets sauvés grâce à Adnan

[ND,±,

Essayez-le en ligne!

Impressions 0, -1, 1, -2, 2 ...séparées par des nouvelles lignes.

GNU sed, 189 + 2 (drapeaux rn) = 191 octets

C'est probablement la solution la plus longue, car sed n'a pas de type entier ni d'opération arithmétique. En tant que tel, je devais émuler un opérateur d'incrément de taille arbitraire en utilisant uniquement des expressions régulières.

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

Courir:

echo | sed -rnf all_integers.sed

Sortie:

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

Brainfuck, 127 octets

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

Essayez-le en ligne!

Étant donné une bande infinie serait théoriquement courir pour toujours.

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 compressé

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

ShadyAsFuck , 3 octets

FVd

Explication:

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

Cela utilise le retour à la ligne et imprime toutes les valeurs possibles. En SAF, la représentation entière native est exprimée en octets .

R, 25 24 octets

Golfé un octet grâce à @JDL.

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

Essayez-le en ligne!

Exemple de sortie:

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

Lot, 56 octets

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

Sortie:

0
-1
1
-2
2
-3

etc. Fonctionne jusqu'à 2147483647; 58 octets si vous voulez (-) 2147483648 dans la sortie:

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

44 octets si tous les entiers positifs pris en charge sont affichés, puis tous les entiers négatifs pris en charge, puis se répétant indéfiniment, est acceptable:

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

Java 7, 151 134 122 118 octets

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 octets enregistrés grâce à @flawr (et @xnor indirectement)

Après le changement de règle .. ( 59 56 63 octets)

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

Depuis Java 2147483647 + 1 = -2147483648, nous ne pouvons pas simplement faire i++et continuer à l'infini, car le défi consistait à imprimer tous les chiffres une fois. Avec le code ci - dessus avec une plage ajoutée, il sera au lieu d' imprimer tous les entiers de -2147483648la 2147483647fois par, dans l'ordre suivant: 0, -1, 1, -2, 2, -3, 3, -4, ..., 2147483646, -2147483647, 2147483647, -2147483648. Merci à @ OlivierGrégoire pour avoir souligné le comportement de Java concernant MIN_VALUE-1/ MAX_VALUE+1. Essayez ici.

Ungolfed & code de test:

Essayez-le ici - entraînant une erreur d'exécution

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

Sortie:

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

DC (version GNU ou OpenBSD) - 16 octets

Cette version n’est pas plus courte que la version ci-dessous mais devrait pouvoir fonctionner sans que la pile n’explose sur votre PC. Néanmoins, un nombre infini de grands nombres occupera une quantité infinie de mémoire ... un peu ...

En raison de la rcommande, il nécessite GNU-DC ou OpenBSD-DC .

0[rp1+45Pprdx]dx

Tester:

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

DC - 16 octets

Un peu méchant maintenant. ;-)

Cette version abuse de la longueur de la pile en tant que compteur tout en laissant la pile grandir.

z[pz45Ppllx]dslx

Tester:

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

DC - 17 octets

Sans astuces sales.

0[p1+45Ppllx]dslx

Tester:

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

C # 74 octets

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

Sortie:

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

Essayez le:

dotnetfiddle.net (limité à 1000)

Ruby, 26 22 19 16 octets

Imprime les nombres séparés par des nouvelles lignes. -3 octets de @manatwork. -3 octets de @ m-chrzan.

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

JavaScript, 29 26 octets

Version non infinie, 26 octets

3 octets sauvés grâce à ETHproductions

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

affichera tous les entiers compris entre -9007199254740991 et 9007199254740992.

Version infinie (ES6), 114 112 octets

2 octets sauvés grâce à 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);

affichera tous les nombres entiers, compte tenu du temps infini et de la mémoire.

> <> , 19 15 octets

1::1$-naonao1+!

Cela imprime ce qui suit:

0
1
-1
2
-2
3
-3

... etc. Le séparateur est une nouvelle ligne.

Re-écrit après avoir lu la réponse de @ xnor pour utiliser une version de cet algorithme. À partir de n=1, le programme est imprimé 1-net nsuivi d'une nouvelle ligne avant d'être incrémenté n. Après avoir dépassé la valeur maximale, le programme se termine par une erreur de something smells fishy.... Le moment exact où cela se produira dépend de la mise en œuvre de l'interprète.

La version précédente:

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

À partir de 0, le programme se poursuit indéfiniment. Sur chaque boucle, la valeur actuelle est imprimée avec une nouvelle ligne. Il est ensuite annulé et incrémenté s'il est positif.

Utilitaires Bash + GNU, 26

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

bc, 17 16 octets

Edit: 1 octet en moins grâce à Digital Trauma .

Ajoutant à la diversité des langages utilisés jusqu’à présent, je présente une solution bc qui fonctionne avec des entiers de taille arbitraire. . Une nouvelle ligne est requise après le code et est comptée dans le nombre total d'octets.

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

Dans la première itération in'est pas définie, mais l'impression donne 0 à ma grande surprise.

Labyrinthe , 9 octets

!`
\:"
 (

Essayez-le en ligne!

Cela fonctionne aussi et est essentiellement le même:

 "
`:(
\!

Explication

Le flux de contrôle dans ce code est plutôt amusant. N'oubliez pas que le pointeur d'instruction (IP) dans un programme Labyrinth suit le chemin des caractères non-espaces et examine le haut de la pile à n'importe quelle jonction pour décider du chemin à suivre:

• Si le haut de la pile est positif, tournez à droite.
• Si le sommet de la pile est nul, continuez tout droit.
• Si le haut de la pile est négatif, tournez à gauche.

Lorsque l'IP frappe une impasse, il tourne (en exécutant la commande à la fin seulement une fois). Et l’IP commence dans le coin supérieur gauche en direction est. Notez également que la pile est implicitement remplie avec une quantité infinie de zéros pour commencer.

Le programme commence par ce petit bit:

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

Maintenant, l'IP est à la jonction appropriée et va tout droit sur ce (qui décrémente le haut de la pile -1. L'IP se trouve dans une impasse et se retourne. :duplique le haut de la pile une fois de plus. Maintenant, le sommet de la pile est négatif et l'adresse IP tourne à gauche (ouest). Nous exécutons maintenant une autre itération de la boucle principale:

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

Cette fois, le sommet de la pile est positif, donc IP tourne à droite (ouest) et exécute immédiatement une autre itération de la boucle principale, qui affiche le 1. Puis, une fois que cela est annulé, nous frappons le :avec -1sur la pile.

Cette fois, l'IP tourne à gauche (est). Il "s’agit simplement d’un non-fonctionnement et l’adresse IP tourne dans l’impasse. :fait une autre copie et cette fois l'IP tourne au sud. (décrémente la valeur à -2, l’IP se retourne à nouveau. Avec le haut de la pile toujours négatif, l’IP passe maintenant à l’ouest :et effectue la prochaine itération de la boucle principale.

De cette manière, l’IP va effectuer une itération entre une itération de boucle étroite, l’impression d’un nombre positif, et une itération qui passe par les deux impasses pour décrémenter la valeur avant l’impression d’un nombre négatif.

Vous vous demandez peut-être pourquoi il y a la "deuxième ligne si cela ne fait rien: sans cela, lorsque l'IP atteint :une valeur négative, il ne peut pas tourner à gauche (est), mais plutôt à droite (ouest). (En règle générale, si la direction habituelle à une jonction n'est pas disponible, l'IP prendra la direction opposée). Cela signifie que la propriété intellectuelle n'atteindrait jamais la limite (inférieure et que nous ne pouvions pas distinguer les itérations positives des négatives.

JavaScript (ES5), 32 31 30 29 octets

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

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

Sauvé 1 octet grâce à Patrick Roberts! 2 octets sauvés grâce à Conor O'Brien!

Java, 65 54 octets

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

Code de test non-golfé

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

    r.accept(0);
}

C #, 83 octets

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

Les sorties:

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

C # 86 66 octets

Nouvelle réponse:

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

Clair:

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

Ancienne réponse (86 octets):

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 octets

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

Fonctionne sur le site en ligne , mais je ne peux pas encore le vérifier sur ordinateur. Imprime des nombres comme:

0
1
_1
2
_2
3
_3
4

etc.

Powershell, 20 ans 19 18 octets

Amélioré en volant sans vergogne de la réponse de TimmyD

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

Sortie:

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

Ancienne version:

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

Vous ne savez pas pourquoi tbh, mais - la variable non déclarée (ou - $ null) est évaluée à 0, ce qui nous a sauvé 2 octets dans cette version ...

Pyke , 7 2 octets

~I

Essayez-le ici!

7 octets

oDID_)r

Essayez-le ici!

Si imprimer + -0 est correct, oD_r

Brachylog , 2 octets

ẉ⊥

Essayez-le en ligne!

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

Étant donné que le programme ne reçoit aucune entrée, la variable d'entrée du prédicat principal n'est pas contrainte. Au début, on suppose que c'est 0, mais quand l'exécution est réussie⊥ , elle retourne au seul point d'échec possible: le choix de la valeur pour la variable d'entrée. Alors, il essaie 1, et -1, et tous les autres entiers, en les imprimant séparés pour ⊥toujours par des nouvelles lignes car force toujours le retour en arrière, et l’effet de ẉest immédiatement exécuté.