Як відомо ,

Чак Норіс рахував до нескінченності. Двічі

Крім того ,

Чак Норіс може зараховувати до нескінченності назад.

Крім того, хоча можливо менш відомий, Чак Норіс може трохи розмовляти іспанською мовою на додаток до англійської.

Змагання

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

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

Пітон: Спробуйте в Інтернеті!

C: Спробуйте в Інтернеті!

L у коді Python є частиною роздільника.

Пояснення:

У коді С спочатку встановлюється i до 0. Потім він починає коментар ( #дійсний код у С для #includeвисловлювань), куди йде код Python. В кінці коментаря він визначає функцію, яка назавжди збільшує змінну і друкує її двічі, обмеженою простором. Потім починається коментар.

У коді Python i=0;встановлюємо i до нуля. Python ігнорує наступний рядок, оскільки #починає однорядковий коментар. Потім він назавжди збільшує його і перетворює його на довге число і друкує його перевернене подання рядків. 'L' від довгого є частиною роздільника. Після цього він починає багаторядковий рядок для коментування коду С, який закінчується пізніше.

-2 байти завдяки @LuisMendo. -7 байт завдяки @ZacharyT. -6 більше байтів завдяки @ZacharyT. +11 байт, щоб виправити помилку завдяки @ mbomb007. -7 байт завдяки @Doorknob. +1 байт, щоб виправити помилку завдяки @Doorknob. -1 байт завдяки @yoann. Ще 1 байт завдяки @yoann. -3 байти завдяки @Cyoce.

Желе / ​​Піт, 15 байт

.V1_`b;"1üÉÉ$

Недруковані файли керуються програмним забезпеченням SE, тож ось шістнадцятковий набір:

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

Виконати з jelly f fileі pyth fileвідповідно.

Пояснення

Спочатку йде частина Pyth. .Vзапускає нескінченну петлю над приростаючою послідовністю, починаючи з її введення, що знаходиться тут 1. Потім повертаємо ( _) `індекс циклічного ( ) циклу ( 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 виводить тільки, якщо програма припиняється)

Спробуйте в Інтернеті! в Brain-flak Classic

Це не найцікавіший поліглот, оскільки 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
}

Сітківка / Python 2, 61 байт

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

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

Сітківка | Пітон 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')

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

простий init змінної:

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

Röda: Спробуйте в Інтернеті!

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заяву потрібно припинити. Після цього ми стикаємося з простою для циклу, яка друкує ітераційну змінну 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

Виконання починається з того, !що змушує його пропустити \. Потім він продовжується так, як ніби код лазерної локальної мережі там не був. Я не усвідомлював, що <<> мав підтримку тільки поплавкового поділу, тому коротке і просте усічення спочатку було дещо заплутаним.

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). Цей процес повторюється нескінченно. Оскільки цикл нескінченний, інтерпретатор по суті ігнорує все, що виникає після цього маркера.

> <> / Jelly , 37 байт (25 у кодовій сторінці Jelly)

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

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

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

> <> друкує послідовність до нескінченності двічі, Jelly рахує назад.

> <> стосується лише верхнього рядка:

І завдяки @ 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);}//';

Виводить подвійну послідовність у С та зворотну послідовність у PHP.

Спробуйте це на C!

Спробуйте в PHP!

Пояснення

С

В C #формує препроцесорний матеріал. Я насправді мало знаю про C, але він не скаржиться, коли для цього матеріалу є порожній рядок. В //утворює лінія коментар. А \в кінці рядка по суті "ухиляється" від нового рядка і змушує обидві лінії розглядатися як одна. Це також працює для коментарів до рядків, тому другий рядок розглядається як коментар у C. Третій рядок виконує роботу з виведення чисел простим циклом. Після цього є просто коментар.

PHP

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