Как известно ,

Чак Норрис считал до бесконечности. Дважды

Кроме того ,

Чак Норрис может считать до бесконечности задом наперед.

Кроме того, хотя, возможно, менее известный, Чак Норрис может говорить немного по-испански в дополнение к английскому.

Соревнование

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

1, 1, 2, 2, 3, 3, 4, 4, ...

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

1, 2, ..., 9, 01, 11, 21, 31, ..., 89, 99, 001, 101, 201, ...

правила

• Программы или функции разрешены на любом языке программирования . Стандартные лазейки запрещены.
• Разные версии одного и того же языка (например, Python 2/3) не считаются разными языками. Связанные языки (такие как C / C ++ или Matlab / Octave) считаются разными.
• Вход не будет принят.
• Программа должна продолжать выводить условия последовательности, пока пользователь не остановит ее. Поскольку программа не остановится сама по себе, вывод не может быть произведен в конце. Он должен создаваться во время работы программы, либо непрерывно, либо партиями.
• Вывод может использовать STDOUT или эквивалентный, или может отображаться в графическом окне. Разрешается использовать любой нечисловой разделитель между членами последовательности, если каждый член может быть четко отделен от соседних терминов. Также допустимо, если экран очищается между терминами.
• Любая последовательность может начинаться 0вместо 1. В этом случае в последовательности «дважды» 0следует повторить, как и другие числа.
• Ведущие нули значимы в последовательности «назад». Так , например, термин десятый 01; ни то, 1ни другое не 001приемлемо.
• Если два языка используют разные кодировки символов, программа определяется ее байтами , а не символами. То есть байты должны быть одинаковыми на двух языках.
• Самый короткий код в байтах побеждает.

05AB1E / Желе ,  14  13 байт

-1 байт благодаря Аднану (избегайте трехкратного дублирования с не всплывающей печатью)

Необработанные байты (шестнадцатеричные):

31 5b 3d 3d 3e 5d fc 06 b6 3b 87 08 15

В 05AB1E «S кода-странице :

1[==>]üε¶;‡ηΩ

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

В Jelly «S кода-странице :

1[==>]‘©Ṛ;⁷®ß

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

Как?

Программа 05AB1E печатает двойной счет с каждой записью, разделенной новыми строками :

1[==>]üε¶;‡ηΩ
1             - push 1 onto the stack
 [            - start infinite loop:
  =           - print top of stack
   =          - print top of stack
    >         -   increment the top of the stack (pop(1), x+=1, push)
     ]        - end the infinite loop
      üε¶;‡ηΩ - this code is never executed nor is it parsed

Программа Jelly печатает обратный счет с каждой записью, разделенной новыми строками.

Парсер будет обрабатывать действительный литерал между [и ]как вложенный литерал, в противном случае эти байты являются неопределенными токенами и, как таковые, становятся эквивалентными токенам, разделяющим код на строки. ==>не анализируется как литерал, поэтому код эффективен:

1 - link 1 (not executed but parsed)
1 - literal 1

==> - link 2 (not executed but parsed)
=   - left equals right? (vectorises)
 =  - left equals right? (vectorises)
  > - is greater than the right argument? (vectorises)

‘©Ṛ;⁷®ß - Main link: no arguments
‘       - increment (implicit 0 on left increments to 1 on the first pass)
 ©      - copy the result to the register and yield it
  Ṛ     - reverse, this has an implicit decimal list build, e.g. 142 -> [2,4,1]
    ⁷   - a newline character
   ;    - concatenate, e.g. [2,4,1] -> [2,4,1,'\n']
     ®  - recall the number from the register, e.g. 142
        - The chain has reduced to one item of arity 0, causing a pre-evaluation print:
        -     ...and since the list contains a character it gets smashed together
        -     e.g. [2,4,1,'\n'] prints 241 followed by a newline character
      ß - call this link with the same arity, e.g. as a monad with left = 142

Python 2 / C (лязг) , 109 107 100 84 95 88 89 88 87 84 байта

i=0;
#/*
while 1:i+=1L;print`i`[::-1]
'''*/
a(){for(;;)printf("%i %1$i ",++i);}//'''

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

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

L в коде Python является частью разделителя.

Объяснение:

В коде C сначала устанавливается значение i, равное 0. Затем начинается комментарий ( #это допустимый код в C для #includeоператоров), куда идет код Python. В конце комментария он определяет функцию, которая навсегда увеличивает переменную и печатает ее дважды, разделив пробелом. Затем начинается комментарий.

В коде Python i=0;устанавливает i в ноль. Python игнорирует следующую строку, потому что #начинает однострочный комментарий. Затем он всегда увеличивает его на единицу, превращает в длинное число и печатает его перевернутое строковое представление. «L» от длинного является частью разделителя. После этого он запускает многострочную строку для комментария к коду C, который заканчивается позже.

-2 байта благодаря @LuisMendo. -7 байт благодаря @ZacharyT. -6 больше байтов благодаря @ZacharyT. +11 байт, чтобы исправить ошибку благодаря @ mbomb007. -7 байт благодаря @ Doorknob. +1 байт, чтобы исправить ошибку благодаря @ Doorknob. -1 байт благодаря @yoann. -1 байт благодаря @yoann. -3 байта благодаря @Cyoce.

Желе / ​​пит, 15 байт

.V1_`b;"1üÉÉ$

Непечатные файлы искажаются программным обеспечением SE, поэтому вот hexdump:

00000000: 2e56 315f 6062 3b22 7f31 fcc9 c924 0b    .V1_`b;".1...$.

Беги с jelly f fileи pyth fileсоответственно.

объяснение

Сначала идет часть Pyth. .Vзапускает бесконечный цикл по возрастающей последовательности, начиная со своего входа, который здесь 1. Затем мы обращаемся ( _) к `циклу stringified ( ) index ( b) и неявно выводим его. Он ;предназначен для завершения цикла, и "он необходим для обработки остальной части программы как строкового литерала, чтобы синтаксический анализатор не подавился им.

Часть Jelly будет объяснена первым переводом оставшейся части программы с кодовой страницы Jelly:

¶1‘ṄṄ$¿

¶Выступает в качестве корма линии, эффективно игнорируя первую часть программы, сделав его ссылку , которая никогда не называется. Затем мы запускаем 1и запускаем цикл while ( ¿), который использует ṄṄ$(печатает дважды) в качестве условия и увеличивает ( ‘) значение в качестве тела цикла.

Кстати, заменив часть Pyth с 1[DR,>] бы создать действительное представление Желе / 05AB1E в 14 байт, но в настоящее время interpeter содержит ошибку , которая предотвращает это.

Perl / JavaScript, 87 байт

s=0;print=console.log;m=s;$_=s=s=s=m;while(++$_){print((m/s,$_+`
`+$_||/&&reverse.$/))}

Perl

s/0;print/console.log;m/s;$_=s/s/s/m;while(++$_){print((/s,$_+`
`+$_||/&&reverse.$/))}

Механизм Я использовал много полиглотов JS / Perl является злоупотребление тот факт , что замена может принимать почти любой разделитель, с помощью =средства можно использовать начальные бессмысленные замены (первый замена 0;printс console.log;mс флагом /sв $_, который в настоящее время undef) , то установка $_в результате замены sс sв режиме многострочного ( /m), который является 0. Теперь $_есть 0и я начинаю whileцикл, это те приращения $_. Затем я вызываю print, передавая соответствующее регулярное выражение (из-за того, что ||в конце совпадает с пустой строкой), и использую &&оператор, чтобы затем отправить обратную $_конкатенацию с символом новой строки ($/предварительно инициализирован в "\n"). Это считается до бесконечности в обратном направлении.

JavaScript

s=0;print=console.log;m=s;$_=s=s=s=m;while(++$_){print((m/s,$_+`
`+$_||/&&reverse.$/))}

Здесь много переменных назначений, замаскированных в s///вызовах Perl . Я создал переменные sи , mкак 0, псевдоним console.logдля print, запустить некоторое бессмысленное деление, набор $_для 0и начать whileцикл увеличивающийся $_, вызов printпроходит в 0( m/sэто запускает вызов mв Perl, но рассматриваются как стандартное разделение в JS) , и наша целевая строку ( $_+"\n"+$_) через оператор запятой, который возвращает последний элемент в списке. Я избегаю последнего фрагмента кода Perl ( &&reverse.$/), потому что $_+"\n"+$_он будет правдивым, и поэтому я могу использовать его ||для создания RegExpобъекта, содержащего конец кода Perl, который никогда не обрабатывается.

Протестировано с использованием Perl 5 и Node 6.

NodeJS / PHP, 131 106 байт

-25 байт благодаря @Titus

<!--
printf=(_,i)=>process.stdout.write(i+i),strrev=i=>i+" "//--><?
for($i=0;;)printf("%s ",strrev($i++));

Использование NodeJS вместо браузера JS для лучшего форматирования вывода и лучшей обработки бесконечного цикла.

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

Обратите внимание, что выход TIO обрезается после 128 КБ.

V / Brain-flak Classic , 27 , 26 байтов

(()){[[({}())[]]]}é1òÙæ_æ

HexDump:

00000000: 2828 2929 7b5b 5b28 7b7d 2829 295b 5d5d  (()){[[({}())[]]
00000010: 5d7d e931 f2d9 e65f 01e6                 ]}.1..._..

Попробуйте онлайн! в V (слегка изменено, чтобы завершить его, чтобы вы могли видеть выходные данные. На TIO V выводит только в случае завершения программы)

Попробуйте онлайн! в классическом стиле

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

V Объяснение:

é1              " Insert a '1'
  ò             "   Recursively:
   Ù            "   Duplicate this number
    æ_          "   Flip this line
      <C-a>     "   Increment the number on this line
           æ    "   Flip it back (the '_' is implicit because it's at the end of the program)

Объяснение BFC:

#Push a one onto the main stack
(())

#Forever:
{

  #Print twice:
  [[

    #Increment the top of the stack.
    #Evaluates to *i + 1*
    ({}())

    #Minus one
    []
  ]]

#Endwhile
}

Retina / Python 2, 61 байт

#{*M`
#*M`
"""

}`$
1
""";i=1
while 1:print str(i)[::-1];i+=1

Сетчатка | Python 2

R / Octave , 83 80 78 71 байт

-3 байта благодаря Луису Мендо

i=0;
while(1)
#{
print(c(i<-i+1,i))
#}
disp(flip(num2str(i)))
i+=1;
end

#{ }#является комментарием к блоку Octave, и #именно так происходит с комментарием для R. Интерпретатор R видит следующую строку только как тело whileцикла, а интерпретатор Octave пропускает код Octave прямо вперед.

Часть R печатает пары чисел, начинающихся с 1, а часть Octave печатает обратные числа, начинающиеся с 0.

Я полностью ожидаю, что меня обойдут (даже при той же комбинации языков); Я недавно написал так много кода Matlab и R, что решил попробовать.

Попробуйте онлайн! - Октавная ссылка

Ruby / Python2: 68 64 байта

i=0
"#{loop{p i+=1,i}}"
exec('while 1:print str(i)[::-1];i+=1')

Рубиновая перспектива

простая инициализация переменной:

i = 0

"#{}"синтаксис для интерполяции строк Я использую его для выполнения выражения вместо.

"#{loop{p i+=1,i}}"

pэто сокращение для puts. loopсоздает бесконечный цикл.

Затем есть execвещь, но она никогда не оценивается, поскольку бесконечный цикл по определению бесконечен. Необходимо execне поддаться синтаксической ошибкой с кодом Python.

Перспектива Python

С точки зрения Python, есть общее i=0. Далее, Python имеет другой синтаксис для интерполяции строк, поэтому эта строка просто отбрасывается. Далее идет бесконечный цикл, аналогичный тому, что опубликовали другие.

Bash / Check , 50 28 байт

^{Спасибо @Doorknob за сохранение нескольких байтов при переходе с Python на Bash}

#>
#v
 #p<p<)#
seq 1 inf|rev

Чтобы Bash:

#>
#v
 #p<p<)#

Это всего лишь некоторые комментарии, которые игнорируются.

seq 1 inf|rev

Начните последовательность, идущую от 1 до бесконечности, затем передайте результат в rev.

Проверять:

#>

Это сразу переключается в 2D режим, идем направо. >направляет права IP, что не имеет никакого эффекта. Он переносится к началу строки и #снова попадает в режим 2D. Затем он попадает >в 1D режим, который толкает 0 в стек. Поскольку он находится в режиме 1D, IP переносится на следующую строку.

#v

#снова переключает IP в режим 2D и vнаправляет его вниз.

 #p<p<)#

Первый #снова переключается в режим 1D. pвыводит TOS как число (но не выдает его), а затем <печатает новую строку. Это делается дважды, а затем число увеличивается на ). #снова переключается в режим 2D, поэтому IP переносится в начало строки, нажимается #для переключения в режим 1D и т. д.

CJam /> <>, 27 23 байта

"la,:naonao
"1{_sW%n)}h

Для CJam:

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

"la,:naonao
"

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

 1{_sW%n)}h

Вторая строка выглядит так:

1     e# Push 1:               | 1 
{     e# Forever:              | 1
  _   e#   Duplicate:          | 1 1
  s   e#   Convert to string:  | 1 "1"
  W%  e#   Reverse:            | 1 "1"
  n   e#   Print with newline: | 1
  )   e#   Increment:          | 2
}h    e# End loop

К> <>:

"

Начинается строковый литерал.

 la,:naonao

Содержимое строкового литерала. Каждый из кодов символов индивидуально помещается в стек.

"

IP оборачивается, чтобы достичь "снова, что завершает строковый режим.

 la,

lберет длину стека, aтолкает 10 и ,делит. Это дает нам длину стека / 10.

    :nao

:дублирует, nпечатает как число, aнажимает 10, и oпечатает как код символа (новая строка).

        nao

То же самое. Напечатайте число, сопровождаемое новой строкой. Стек снова теперь имеет длину 10 (содержимое исходного строкового литерала находится в стеке).

Затем IP оборачивается "снова, что приводит к добавлению еще 10 элементов. В следующий раз lвозвращает 20, поэтому печатается 2 и т. Д.

Вторая строка никогда не затрагивается IP.

Röda / C (gcc) , 90 байт

main(){f(0);}f(a){a=1//1{[` $a`[::-1]];a++}while[]/*
;for(;;a++)printf("%d %d ",a,a);/**/}

Рёда: Попробуйте онлайн!

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

объяснение

Это злоупотребляет тем фактом, что //int divison в Röda, но строчный комментарий в C.

На обоих языках main(){}обозначает основную программу, и они оба вызывают функцию fс фиктивным аргументом 0.

Роды, a=1//1делает Int деления и присваивает результат 1к a. C видит a=1и делает то же самое, но все после этого присваивания является комментарием для C. Оттуда два языка разветвляются.

Röda

У нас есть бесконечный цикл с while[]( пустое условие верно ). Внутри этого ` $a`преобразует целое число aв строку (с начальным пробелом), после чего [::-1]переворачивает его (и выводит с завершающим пробелом). Затем значение aувеличивается на единицу.

Вне цикла while многострочный комментарий начинается /*и заканчивается непосредственно перед концом функции.

С

Игнорируя оставшуюся часть строки, программа переходит ко второй строке. Мы начинаем с точки с запятой, потому что a=1оператор должен быть завершен. После этого мы сталкиваемся с простым циклом for, который печатает итерационную переменную a, дважды на каждую итерацию.

Вне цикла for, /*он просто игнорирует заключительный */комментарий Röda .

QBIC / QBasic 4.5 , 58 байт

do
p=p+1
if q then
'?`_f!p$|
else
?p,p,
end if
loop

Это сильно нарушает тот факт, что все строчные буквы воспринимаются интерпретатором QBIC как буквальный код QBasic и поэтому просто передаются на уровень QBasic QBIC. Как оба языка видят этот код рядом:

LOC         QBasic                    QBIC
-------------------------------------------------------
do                   Start an infinite loop
p=p+1                Increment p, starts off as 0
if q then    q = 0, goto ELSE         q = 1, execute IF
'?`_f!p$|    ' = comment, invalid     '?` is a 'code literal', passing PRINT to QBASIC
             syntax is ignored        followed by QBIC code to flip p cast as string.
else         q=0, execute             q=1, so ignored
?p,p,        PRINT p twice,
             separated by tab
end if               End of the branching logic
loop                 Wrap around for the next pass

laserLANG / > <> , 163 байта

!\0 \
/:+1/!   ]oo\
\:a( ?\:a%$a ,!
/r[-1l//" ,"/
/!n-%1:\?(1l
 \ --\/ <<---\
/----/'
\----  v
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/

В первый раз играю в гольф, поэтому она немного больше, чем могла бы быть. Я хотел использовать> <>, но так как несколько человек уже использовали его для создания второй последовательности, я решил, что хочу попробовать создать первую последовательность.

Попробуйте> <> онлайн!
Для LaserLANG, чтобы попробовать его, нужен автономный переводчик. Это можно найти здесь .

laserLANG

!\
 \ --\/ <<---\
/----/'
\----  v
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/

выполнение начинается с !которого полностью игнорируется. затем он достигает \и начинает проходить мимо нескольких символов, которые он полностью игнорирует. Наконец-то доходит до другого \и начинается самое интересное. Я в основном взял идею за "Привет, мир!" зацикливаться и сгущать это как мог. Это была небольшая проблема, связанная с тем фактом, что LaserLANG только собирается уменьшить / увеличить счетчик памяти, когда счетчик программ перемещается влево / вправо соответственно. Я чувствую, что большинство байтов можно сохранить, выполнив некоторые трюки, о которых я даже не думал.

> <>

!\0 \
/:+1/!   ]oo\
\:a( ?\:a%$a ,!
/r[-1l//" ,"/
/!n-%1:\?(1l

Выполнение начинается с того, !что заставляет его пропустить \. Затем он продолжается, как будто кода LaserLANG там не было. Я не знал, что> <> имел поддержку только для деления с плавающей запятой, поэтому короткое и простое усечение поначалу немного сбивало с толку.

Befunge-98 / > <> , 32 байта

\r.#%a/# :_::p#+a#1,#
>l::naonao

Написал это до того, как увидел, сколько ><>ответов было. Немного предыстории: \это оператор изменения направления в> <>, в данном случае это нажатие вниз, в то время как в Befunge это меняет два верхних элемента в стеке. Код Befunge выглядит так:

\r.#%a/# :_::p#+a#1,#

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

Распечатывает обратные числа, разделенные переводом строки. Befunge печатает пробел автоматически после каждого числа, поэтому каждая цифра разделяется пробелами. Повторно получает последнюю цифру, печатает ее и делит число на 10, пока не станет 0. Затем увеличьте и повторите.

Код> <> сразу переходит ко второй строке.

>l::naonao

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

И это довольно просто. Получите длину стека, напечатайте дважды с новыми строками и оставьте копию длины в стеке для следующего цикла.

Ruby / Stacked , 37 байтов

0#/0[1+:tostr rev out]
loop{p p$.+=1}

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

Это печатает 1 1 2 2... в Ruby и 1 2 3 ... 01 11 21...в Stacked.

объяснение

В рубине:

0#/0[1+:tostr rev out]
loop{p p$.+=1}

После удаления комментария это становится:

0
loop{p p$.+=1}

Единственная соответствующая строка здесь - последняя. pвозвращает аргумент, поэтому p pпечатает аргумент дважды. $.начинается с 0, поэтому $.+=1увеличивается $., возвращая увеличенное значение. Следовательно, каждый номер печатается 1дважды.

В сложенном:

0#/0[1+:tostr rev out]
loop{p p$.+=1}

Это эквивалентно следующим токенам:

0 #/ 0 [ 1 + : tostr rev out ] loop { p p $ . + = 1 }

Первые два не имеют отношения (в основном, преобразование 0в сокращение f Unction). Затем 0помещается в стек. После этого функция [1+:tostr rev out]помещается в стек. loopвыскакивает эту функцию и выполняет ее бесконечно.

Внутренняя часть функции увеличивает вершину стека ( 1+), дублирует ее ( :), преобразует в строку ( tostr), инвертирует ( rev) и выводит ( out). Этот процесс повторяется бесконечно. Поскольку цикл бесконечен, все, что идет после этого токена, по существу игнорируется интерпретатором.

> <> / Желе , 37 байт (25 в кодовой странице желе)

01+:nao:nao!
DU;⁷Ṙ€
®‘©Çß

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

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

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

> <> касается только верхней строки:

И спасибо @ Challenger5 за сохранение некоторых байтов здесь, в переводе строки

01+:nao:nao!                           Stack at: 1st run   2nd run ...
0                 Push a 0             0         -
 1                Push a 1             0,1       1,1   
  +               Pop 2, add them      1         2 
   :              Duplicate top item   1, 1      2, 2
    n             Pop top, show as num 1         2
     a            Push the number 10   1, 10     2, 10
      o           Pop and show 10 as an ACII char (ie '\lf')
                                       1         2
         :nao     And again, for repetition
             !    ><> wraps around; this skips pushing a 0 again.

Jelly выполняет свой код снизу вверх. Только последние 2 строки актуальны.

®‘©Çß       main link, keeps track of the current number

®           Get a number from the register (0 on first run)
 ‘          Increment that by 1
  ©         Store in register
   Ç        Call helper (printer) link
    ß       Call this link again

DU;⁷Ṙ€      Printer

            (Say we are at number 21)
D           Break into digits         [2, 1]
 U          Reverse array             [1, 2]
  ;⁷        Append a line break       [1, 2, \n]
    Ṙ€      Print each char in array

C (gcc) / PHP , 102 86 80 байт

#//\
for(;;)echo strrev(++$i).'
int main(i){for(;;i++)printf("%d %d ",i,i);}//';

Выводит двойную последовательность в C и обратную последовательность в PHP.

Попробуйте это в C!

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

Пояснения

С

В C #формы препроцессора вещи. Я не очень много знаю о Си, но он не жалуется, когда есть пустая строка для этого материала. //Формирует линию комментария. A \в конце строки, по сути, "экранирует" новую строку и делает две строки обработанными как одну. Это также работает для комментариев к строке, поэтому вторая строка рассматривается как комментарий на языке C. Третья строка выполняет вывод чисел с помощью простого цикла for. После этого есть просто комментарий.

PHP

В PHP #формирует строковый комментарий, поэтому первая строка полностью игнорируется. Во второй строке выводятся числа, поменяемые местами в цикле for, и разделяются ими с помощью \nint main(i){for(;;i++)printf("%d %d ",i,i);}//(код C, заключенный в строку).