Напишите программу или функцию, которая будет достоверно печатать все целые числа ровно один раз, учитывая бесконечное время и память.

Возможные результаты могут быть:

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

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

Это неверный вывод, так как он никогда не будет перечислять отрицательные числа:

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

• Выходные данные должны быть в десятичном формате, если только ваш язык не поддерживает десятичное целое число (в этом случае используйте естественное представление целых чисел, которое использует ваш язык).

• Ваша программа должна работать с числами с наибольшей величиной стандартного целочисленного типа вашего языка.

• Каждое целое число должно быть отделено от следующего с помощью любого разделителя (пробел, запятая, перевод строки и т. Д.), Который не является ни цифрой, ни отрицательным знаком вашего языка.

• Разделитель не должен меняться в любой точке.

• Разделитель может состоять из нескольких символов, если ни один из них не является ни цифрой, ни знаком минус (например , , так же, как и просто ,).

• Любое поддерживаемое целое число должно в конечном итоге быть напечатано через некоторое время.

счет

Это код-гольф , поэтому выигрывает самый короткий ответ в байтах

Leaderboard

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 байта

0000000: c4ceb9                                            ...

Попробуйте онлайн! Проверьте Debug, чтобы увидеть сгенерированный код SBIN.

Сесос сборка

Двоичный файл выше был сгенерирован путем сборки следующего кода SASM.

set numout

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

Haskell, 19 байтов

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

Производит бесконечный список [0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6,7,-7...

Haskell допускает бесконечные списки изначально. Печать такого списка будет печатать его элементы один раз навсегда.

Brainfuck, 6 байтов

Это использует обтекание ячейки и печатает все возможные значения. В Brainfuck нативное целочисленное представление является байтовым значением .

.+[.+]

Попробуйте онлайн!

Cubix , 14 12 байтов

.(.\OSo;?.>~

Проверьте это онлайн! Теперь вы можете регулировать скорость, если хотите, чтобы она работала быстрее или медленнее.

Как это устроено

Первое, что делает интерпретатор, это удаляет все пробелы и дополняет код no-ops .до тех пор, пока он полностью не уместится на кубе. Это означает, что приведенный выше код также может быть написан так:

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

Теперь код запускается. IP (указатель инструкций) начинается в верхнем левом углу крайне левого лица и указывает на восток. Вот пути, которые нужно пройти во время работы программы:

IP начинается на красном следе в дальнем левом углу изображения. Затем он запускается OSo;, что делает следующее:

• OВыведите TOS (верхнюю часть стопки) как целое число. В начале программы стек содержит бесконечные нули, поэтому он печатается 0.
• SНажмите 32, код символа для пробела.
• oРаспечатайте TOS как символ. Это печатает пробел.
• ;Поп TOS. Удаляет 32из стека.

Теперь IP попадает в ?точку, которая направляет его влево, вправо или прямо, в зависимости от знака TOS. Прямо сейчас, TOS есть 0, так что все идет прямо. Это синий путь; .ничего не делает, и IP попадает в стрелку >, которая снова направляет его на восток по красной дорожке. ~принимает побитовое НЕ ТОС, изменяя его на -1.

Здесь IP достигает правого края сети, который оборачивает его обратно влево; это снова печатает TOS (на этот раз -1) и пробел.

Теперь IP попадает ?снова. На этот раз TOS есть -1; так как это отрицательно, IP поворачивает налево, выбирая зеленый путь. Зеркало \отклоняет IP-адрес (, который уменьшает TOS, изменяя его на -2. Он возвращается и поражает стрелу; ~принимает снова побитовое НЕ, поворачивая -2к 1.

Снова выводится TOS и печатается пробел. На этот раз, когда IP попадает в ?, TOS есть 1; так как это положительно, IP поворачивает направо, выбирая желтый путь. Первый оператор, с которым он сталкивается S, это нажатие лишнего 32; ;хлопает его , прежде чем он может вызвать какие - либо проблемы.

Теперь IP возвращается к стрелке и выполняет свою процедуру, ~изменяя TOS -2и Oпечатая его. Так как TOS снова отрицательный, IP снова выбирает зеленый путь. И он просто продолжает ездить так вечно *: красный, зеленый, красный, желтый, красный, зеленый, красный, желтый ..., печатая в следующем цикле:

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

TL; DR

Эта программа неоднократно проходит через эти 3 простых шага:

1. Выведите текущий номер и пробел.
2. Если текущее число отрицательно, уменьшите его на 1.
3. Взять поразрядно НЕ текущего номера.

Неразделенная версия, 6 байт

nO?~>~

Удаление разделения настолько упрощает программу, что она может поместиться в единичный куб:

  n
O ? ~ >
  ~

* Примечание : ни одна из программ не является действительно бесконечной, так как они рассчитывают только до 2 ⁵² (где JavaScript начинает терять целочисленную точность).

MATL , 8 байт

0`@_@XDT

При этом используется тип данных по умолчанию MATL, то есть doubleон работает до 2^53абсолютного значения. Выход

0
-1
1
-2
2
···

Попробуйте онлайн!

объяснение

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

Язык программирования Шекспира , 227 байт

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

Очевидно, что этот ответ далеко не победил, но мне понравилось, что это тот случай использования, для которого SPL сравнительно хорошо подходит.

Разъяснение:

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

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

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

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

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

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

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

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

Как вы можете видеть, сравнивая этот код с моим ответом на связанную задачу подсчитать навсегда (то есть вывести все натуральные числа), длина кода SPL довольно сильно возрастает при увеличении размера задачи ...

Python 2, 27 байт

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

Печать -1 0 -2 1 -3 2 -4 3 ...

05AB1E , 9 6 байтов

Сохранено 3 байта благодаря Аднану

[ND,±,

Попробуйте онлайн!

Отпечатки 0, -1, 1, -2, 2 ...разделены переводом строки.

GNU sed, 189 + 2 (флаги rn) = 191 байт

Скорее всего, это самое длинное решение, так как у sed нет целочисленного типа или арифметических операций. Поэтому мне пришлось эмулировать произвольный оператор приращения размера, используя только регулярные выражения.

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

Бегать:

echo | sed -rnf all_integers.sed

Выход:

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

Brainfuck, 127 байт

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

Попробуйте онлайн!

Данная бесконечная лента теоретически будет работать вечно.

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

несжатого

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

ShadyAsFuck , 3 байта

FVd

Объяснение:

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

Это использует обтекание ячейки и печатает все возможные значения. В SAF нативное целочисленное представление является байтовым значением .

R, 25 24 байта

Гольф один байт благодаря @JDL.

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

Попробуйте онлайн!

Пример вывода:

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

Пакетная, 56 байтов

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

Выход:

0
-1
1
-2
2
-3

и т. д. Работает до 2147483647; 58 байт, если вы хотите (-) 2147483648 в выводе:

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

44 байта, если вывести все поддерживаемые положительные целые числа, тогда все поддерживаемые отрицательные целые числа, а затем повторяться бесконечно, приемлемо:

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

Java 7, 151 134 122 118 байт

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

12 байтов сохранено благодаря @flawr (и @xnor косвенно)

После смены правила .. ( 59 56 63 байта)

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

Поскольку в Java 2147483647 + 1 = -2147483648мы не можем просто делать i++и продолжать бесконечно, так как задача состояла в том, чтобы напечатать все числа один раз. С учетом указанных выше кода с добавлением диапазона, то вместо этого напечатать все целые числа от -2147483648до 2147483647один раз, в следующей последовательности: 0, -1, 1, -2, 2, -3, 3, -4, ..., 2147483646, -2147483647, 2147483647, -2147483648. Спасибо @ OlivierGrégoire за указание на поведение Java в отношении MIN_VALUE-1/ MAX_VALUE+1. Попробуй это здесь.

Ungolfed & тестовый код:

Попробуйте здесь - в результате ошибки во время выполнения

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

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

Выход:

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

DC (GNU или OpenBSD) - 16 байт

Эта версия не короче указанной ниже, но должна быть в состоянии работать без взрыва стека на вашем ПК. Тем не менее, бесконечные большие числа будут занимать бесконечные объемы памяти ... когда-нибудь ...

Из-за этой rкоманды ему нужен GNU-DC или OpenBSD-DC .

0[rp1+45Pprdx]dx

Контрольная работа:

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

DC - 16 байтов

Немного значит теперь. ;-)

Эта версия использует длину стека как счетчик, позволяя стеку расти.

z[pz45Ppllx]dslx

Контрольная работа:

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

DC - 17 байтов

Без подвохов.

0[p1+45Ppllx]dslx

Контрольная работа:

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

C # 74 байта

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

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

Выход:

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

Попробуй:

dotnetfiddle.net (ограничено 1000)

Рубин, 26 22 19 16 байт

Печатает числа, разделенные переводом строки. -3 байта от @manatwork. -3 байта от @ m-chrzan.

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

JavaScript, 29 26 байт

Неограниченная версия, 26 байт

Сохранено 3 байта благодаря ETHproductions

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

отобразит все целые числа от -9007199254740991 до 9007199254740992.

Бесконечная версия (ES6), 114 112 байт

Сохранено 2 байта благодаря 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);

будет отображать все целые числа, учитывая бесконечное время и память.

> <> , 19 15 байт

1::1$-naonao1+!

Это печатает следующее:

0
1
-1
2
-2
3
-3

... и так далее. Разделитель - это новая строка.

Переписано после прочтения ответа @ xnor, чтобы использовать версию этого алгоритма. Начиная с n=1, программа печатает 1-nи n, после каждого, следует за новой строкой, а затем увеличивает ее n. После превышения максимального значения программа завершится с ошибкой something smells fishy.... Как именно это произойдет, зависит от реализации интерпретатора.

Предыдущая версия:

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

Начиная с 0, программа зацикливается бесконечно. В каждом цикле текущее значение печатается вместе с новой строкой. Затем он отрицается и увеличивается, если положительный.

Утилиты Bash + GNU, 26

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

до н.э., 17 16 байт

Изменить: на 1 байт меньше благодаря Digital Trauma .

В дополнение к разнообразию языков, используемых до сих пор, я представляю решение bc, которое работает с целыми числами произвольного размера . После кода требуется новая строка, которая считается в байтах.

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

На первой итерации iне определено, но печать дает 0, к моему удивлению.

Лабиринт , 9 байт

!`
\:"
 (

Попробуйте онлайн!

Это также работает и по сути то же самое:

 "
`:(
\!

объяснение

Поток управления в этом коде довольно забавный. Помните, что указатель инструкций (IP) в программе Labyrinth следует по пути непробельных символов и проверяет вершину стека в любом соединении, чтобы решить, какой путь выбрать:

• Если вершина стека положительна, поверните направо.
• Если вершина стека равна нулю, продолжайте двигаться прямо вперед.
• Если вершина стека отрицательна, поверните налево.

Когда IP попадает в тупик, он оборачивается (выполняя команду в конце только один раз). И IP начинается в левом верхнем углу, двигаясь на восток. Также обратите внимание, что для начала стек неявно заполнен бесконечным количеством нулей.

Программа начинается с этого короткого бита:

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

Теперь IP находится на соответствующем соединении и движется прямо на то, (что уменьшает вершину стека до -1. IP попадает в тупик и оборачивается. :дублирует вершину стека еще раз. Теперь вершина стека отрицательна, а IP поворачивается влево (запад). Теперь выполним еще одну итерацию основного цикла:

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

На этот раз вершина стека положительна, поэтому IP поворачивается направо (запад) и немедленно выполняет еще одну итерацию основного цикла, которая печатает 1. Затем после того , как отрицается мы снова попали в :с -1в стеке.

На этот раз IP поворачивает налево (восток). Это "просто не работает, и IP поворачивается в тупик. :делает еще одну копию, и на этот раз IP поворачивает на юг. (уменьшает значение до -2IP снова поворачивается. Поскольку вершина стека по- прежнему отрицательна, IP теперь поворачивается на запад :и выполняет следующую итерацию основного цикла.

Таким образом, IP теперь будет выполнять итерацию между итерацией в узком цикле, печатью положительного числа и итерацией, которая проходит через оба тупика, чтобы уменьшить значение перед печатью отрицательного числа.

Вы можете спросить себя, почему "во второй строке есть :знак, если он на самом деле ничего не делает: без него, когда IP достигает отрицательного значения, он не может повернуть налево (восток), поэтому вместо этого он повернет направо (запад) (Как правило, если обычное направление на перекрестке недоступно, IP будет принимать противоположное направление). Это означает, что IP также никогда не достигнет (дна, и мы не могли отличить положительные и отрицательные итерации.

JavaScript (ES5), 32 31 30 29 байт

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

Печать 0 -1 1 -2 2 -3 3 -4 4 -5 5 ...

Сохранено 1 байт благодаря Патрику Робертсу! Сохранено 2 байта благодаря Конору О'Брайену!

Java, 65 54 байта

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

Тестовый код

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

    r.accept(0);
}

C #, 83 байта

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

Выходы:

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

C # 86 66 байт

Новый ответ:

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

Чистый:

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

Старый ответ (86 байт):

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

Ungolfed:

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

J, 25 байт

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

Работает на сайте , но пока не могу проверить это на компьютере. Печатает номера как:

0
1
_1
2
_2
3
_3
4

и т.п.

Powershell, 20 19 18 байт

Улучшено, бесстыдно крадя из ответа TimmyD

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

Выход:

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

Старая версия:

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

Не уверен, почему переменная tbh, но - undeclared (или - $ null) оценивается как 0, что позволило нам сэкономить 2 байта в этой версии ...

Пайк , 7 2 байта

~I

Попробуй это здесь!

7 байт

oDID_)r

Попробуй это здесь!

Если печать + -0 в порядке, oD_r

Брахилог , 2 байта

ẉ⊥

Попробуйте онлайн!

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

Поскольку программе не дается никаких входных данных, входная переменная основного предиката остается неограниченной. Сначала предполагается, что оно равно 0, но при выполнении выполнения ⊥оно возвращается к единственно возможной точке отказа: выбору значения для входной переменной. Затем он пробует 1, -1 и любое другое целое число, печатая каждое, отделенное символами новой строки, навсегда, потому что ⊥всегда ẉвызывает возврат, и эффект выполняется немедленно.