正如众所周知的，

查克·诺里斯（Chuck Norris）数到无限。两次

此外，

查克·诺里斯（Chuck Norris）可以倒数到无限远。

另外，尽管可能不为人所知，查克·诺里斯（Chuck Norris）除了英语之外还能说一点西班牙语。

挑战

编写可以用两种不同语言运行的程序（或函数）。程序应以一种语言输出序列

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字节归功于Adnan（避免一式三份显示非弹出式图片）

原始字节（十六进制）：

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

在05AB1E的代码页中：

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

在线尝试！

在Jelly的代码页中：

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

该果冻程序打印与换行符分隔每个条目反向计数。

解析器将把[和之间的有效文字]视为封闭的文字，否则这些字节是未定义的标记，因此等同于将代码分成几行的标记。==>不会解析为文字，因此代码是有效的：

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

蟒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：在线尝试！

Python代码中的L是分隔符的一部分。

说明：

在C代码中，它首先将i设置为0。然后，它开始一个注释（#在C中对于#include在Python代码所在的地方语句）。在注释的末尾，它定义了一个函数，该函数将永远递增一个变量并将其打印两次，以空格分隔。然后开始发表评论。

在Python代码中，i=0;将i设置为零。Python忽略下一行，因为#开始单行注释。然后，它将永远递增它并将其变成一个长数字，并打印其反转的字符串表示形式。长整数中的“ L”是定界符的一部分。之后，它将启动一个多行字符串以注释C代码，此字符串随后结束。

-2个字节感谢@LuisMendo。-7个字节感谢@ZacharyT。@ZacharyT多了-6个字节。@ mbomb007 +11字节修复错误。-7个字节，感谢@Doorknob。感谢@ Doorknob，+ 1个字节可修复错误。-1个字节感谢@yoann。多了-1个字节，感谢@yoann。-3个字节，感谢@Cyoce。

果冻/ Pyth，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替换Pyth部分1[DR,>] 将创建14字节的有效Jelly / 05AB1E提交，但是当前的插入内容包含一个阻止此问题的错误。

Perl / JavaScript，87个字节

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

佩尔

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

我在JS / Perl多元语言中使用很多的机制是滥用替换可以接受几乎任何定界符这一事实，即=我可以使用初始的无意义替换（首先用in 的标志替换0;print，目前是） ，然后设置到替换的结果与在多模式（），这是。现在是，我开始循环，然后递增。接下来，我调用，传入匹配的正则表达式（由于末尾匹配空字符串），然后使用运算符发送与换行符串联的反向字符（console.log;m/s$_undef$_ss/m0$_0while$_print||&&$_$/已预先初始化为"\n"）。倒数到无穷大。

的JavaScript

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

Perl s///调用中掩盖了很多变量分配。我设置了变量，s并设置m为0，别名console.log为print，运行一些无意义的除法，设置$_为0并开始while循环递增$_，调用print传入0（m/s，这m在Perl中开始调用to ，但是在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输出在128KB之后被切断。

V / 经典经典，27，26个字节

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

十六进制转储：

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
}

视网膜/ Python 2，61字节

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

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

视网膜 | Python 2

R / 八度，83 80 78 71字节

-3个字节感谢Luis Mendo

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

要重击：

#>
#v
 #p<p<)#

这些只是一些评论，将被忽略。

seq 1 inf|rev

开始一个从1到无穷大的序列，然后将结果传递给rev。

去检查：

#>

这将立即切换到2D模式，向右移动。>指导IP权限，该操作无效。它回绕到行的开头并#再次命中，从而切换出2D模式。然后>以1D模式命中，将0压入堆栈。由于处于1D模式，因此IP换行到下一行。

#v

#再次v将IP切换为2D模式并向下定向。

 #p<p<)#

第一个#再次切换回一维模式。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：在线尝试！

说明

这滥用了//Röda中的int divison却在C中的一行注释的事实。

在这两种语言中，都main(){}表示主程序，并且都f用的伪参数调用函数0。

在Röda中，进行a=1//1int除法并将结果分配1给a。C看到a=1并执行相同的操作，但是分配后的所有内容都是对C的注释。从那里开始，两种语言分叉起来。

罗达

我们有一个无限循环while[]（空条件为true）。在其中，` $a`将整数a转换为字符串（带前导空格），然后[::-1]将其反转（并以尾随空格输出）。然后的值a增加1。

在while循环之外，多行注释/*在函数结束之前开始和结束。

C

忽略其余部分后，程序转到第二行。我们从分号开始，因为该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代码，并因此被传递给QBIC的QBasic层。两种语言如何并行查看此代码：

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，需要使用离线解释器来进行尝试。可以在这里找到。

雷射朗

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

执行开始于此位置!，将被完全忽略。然后到达\并开始向下移动经过几个完全忽略的字符。终于，它到达另一个\了，乐趣开始了。我基本上是在“ Hello，World！”背后提出这个想法的。循环并尽可能地压缩它。在程序计数器分别向左/向右移动时，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 / 堆叠式，37个字节

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

在线尝试！

这会1 1 2 2在Ruby和1 2 3 ... 01 11 21...Stacked中打印。

说明

在Ruby中：

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为归约函数）。然后，0被推入堆栈。之后，该函数[1+:tostr rev out]被推入堆栈。loop弹出此函数并无限执行。

函数内部递增堆栈的顶部（1+），对其进行复制（:），将其转换为字符串（tostr），对其进行反转（rev），然后输出（out）。无限重复此过程。由于循环是无限的，因此解释器将忽略该令牌之后的所有内容。

> <> / Jelly，37个字节（Jelly代码页中的25个字节）

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

在线尝试> <>！

在线尝试果冻！

> <>将序列打印到无穷大两次，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自下而上执行其代码。仅最后两行是相关的。

®‘©Çß       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中输出double序列，在PHP中输出反向序列。

在C中尝试！

在PHP中尝试！

说明

C

在C语言中，#表单是预处理器。我对C的了解并不多，但是当这些东西有空行时，它不会抱怨。该//形式的一个行注释。一种\在一行的末尾是基本上“逃逸”换行符，使这两条线可以看作一个。这也适用于行注释，因此第二行被视为C语言中的注释。第三行完成了使用简单的for循环输出数字的工作。之后，只剩下一条评论。

的PHP

在PHP中，#形成一行注释，因此第一行被完全忽略。第二行显示用for循环反转的数字，并用\nint main(i){for(;;i++)printf("%d %d ",i,i);}//（将C代码包装在字符串中）分隔。