像查克·诺里斯一样计数


58

正如众所周知的

查克·诺里斯(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; 既不1001也不可接受。
  • 如果两种语言使用不同的字符编码,则程序由其字节定义而不是其字符。也就是说,两种语言中的字节应该相同。
  • 以字节为单位的最短代码获胜。

8
拒绝投票的人,有什么改善的建议吗?
Luis Mendo

29
查克·诺里斯(Chuck Norris)太强大了,无法计数,如果他这样做的话,他要计数的第一个数字将超过无穷大,并打破已知数学的领域。因此,我拒绝竞争。
Magic Octopus Urn

11
@carusocomputing,鉴于Chuck Norris都做俯卧撑,这在全世界范围内都很有限,因此非常明智。
Wossname

33
Chuck Norris可以用0个字节完成挑战。他只要看一下计算机,计算机就可以完成他想要的任何事情。
科多斯·约翰逊,

17
查克·诺里斯(Chuck Norris)并没有试图赢得这场挑战,他只是让你输了。
2017年

Answers:


18

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

我尚未检查它是否适用于Jelly,但如果它适用,则可以替换Ð,,==
阿德南(Adnan)

那应该在果冻中解析。我在info.txt中查找了非弹出式打印文件,但没有看到。谢谢。
乔纳森·艾伦,

26

蟒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。


嗯,我认为您可以在C代码中使用递归a(i){printf("%i %i ",i,i);a(i+1)}
enedil

为什么不对whileC代码使用循环?
埃德尼尔2015年

@enedil需要更多字节。
“ SparklePony同志”于

我想你可以使用`i`,而不是str(i)
Cyoce

您可以for(;;)printf("%i %1$i ",i++);用来保存一个字节。的1$是一个位置参数,告诉printf显示第一参数(格式字符串之后)。
yoann

12

果冻/ Pyth,15个字节

.V1_`b;"1üÉÉ$

SE软件会打乱无法打印的内容,因此这是一个十六进制转储:

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

jelly f filepyth file分别运行。

说明

首先是Pyth部分。.V从其输入(此处为)开始对递增序列运行无限循环1。然后我们反转(_)字符串化(`)循环索引(b)并隐式输出。在;那里结束了循环,并且"必需将程序的其余部分当作字符串文字处理,以使解析器不会阻塞它。

首先通过翻译Jelly代码页中程序的其余部分来解释Jelly部分:

¶1‘ṄṄ$¿

作为一个换行符,有效地使其成为是从来没有所谓的链接忽略了程序的第一部分。然后,我们开始1并运行一个while循环(¿),该循环使用ṄṄ$(打印两次)作为其条件,并递增()该值作为循环主体。


顺便说一句,用Pyth替换Pyth部分1[DR,>] 创建14字节的有效Jelly / 05AB1E提交,但是当前的插入内容包含一个阻止此问题的错误


1
@JonathanAllan是的,那是我的文本编辑器添加的结尾换行符。
门把手

11

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并设置m0,别名console.logprint,运行一些无意义的除法,设置$_0并开始while循环递增$_,调用print传入0m/s,这m在Perl中开始调用to ,但是在JS中被视为标准除法)和目标字符串($_+"\n"+$_)通过逗号运算符返回列表中的最后一项。我避免使用Perl代码的最后一部分(&&reverse.$/),因为$_+"\n"+$_这是真实的,因此我可以||用来生成一个RegExp对象,其中包含从未评估过的Perl代码的结尾。

使用Perl 5和Node 6进行了测试。


8

的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之后被切断。


1
从0:开始的102个字节<!--←printf=(_,i)=>process.stdout.write(i),strrev=i=i>>1//--><?←for($i=0;;)printf("%s ",strrev($i++));。84个字节(但不是您的方法的一半):<!--←for(i=1;;)process.stdout.write(i+" "+i+++" ")//--><?for(;;)echo strrev(++$i),_;<!--←for(i=1;;)process.stdout.write((++i>>1)++" ")//--><?for(;;)echo strrev(++$i),_;
泰特斯(Titus),

@Titus的好主意是i>>1重复数字,但是我不得不更改,write(i)以使其包含空格,并且因为write()不接受数字。并且您有一个错字(strrev=i=i>>1-> strrev=i=>i>>1),它添加了另一个字节。结束了短做write(i+i)strrev=i=>i+" "
贾斯汀·马里纳

7

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
}

3
一看到语言,我就知道您发布了这一语言。
莱利

为什么是“脑筋经典”?是否有不同的Brain-flak?
nmjcman101

@ nmjcman101 Brain-flak classic是Brain-flak的原始版本。在这里更详细地解释了这种差异,但是我之所以选择它,是因为它具有显式的输出,而现代的Flak则没有。(允许无限输出)
DJMcMayhem

4

视网膜/ Python 2,61字节

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

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

视网膜 | Python 2


我尝试用str()`` 代替,但显然干扰了视网膜代码。不知道为什么
Officialaimm

反正你不能那样做。如果要使其大量运行并且可以正常工作,则必须为str,否则您将获得L结果。但实际上在视网膜上确实有效。您所做的改变必须比您说的要多,例如将某些内容移到另一行。
mbomb007 '17

3

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代码,以至于我想尝试一下。

在线尝试!-八度链接


是否需要排名第一i=i+1
扎卡里

1
不幸的是,@ ZacharyT +=在R中不起作用,是的,它确实必须像那样。
朱塞佩

end必要吗?
BLT

1
@BLT,是的,它标志着八度的while循环的结束。
朱塞佩

好,谢谢。我当时在想,因为它永远也不会结束(while(1)),所以您可以保存这些字节。
BLT

3

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是的简写putsloop创建一个无限循环。

接下来是exec事情,但是它永远都不会被评估,因为无限循环在定义上是无限的。不需要exec使用Python代码产生语法错误。

Python观点

从Python的角度来看,有一个共同点i=0。接下来,Python具有不同的字符串插值语法,因此该行将被简单丢弃。接下来是一个无限循环,类似于其他人发布的循环。


3

Bash / Check50 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模式,依此类推。


1
Bash #用于注释,可以很容易地执行“倒数”任务:seq 1 inf|rev
门把手

Ruby代码i=1;loop{puts i.to_s.reverse;i+=1}短了一个字节
dkudriavtsev

3

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永远不会触及第二行。


2

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除法并将结果分配1a。C看到a=1并执行相同的操作,但是分配后的所有内容都是对C的注释。从那里开始,两种语言分叉起来。

罗达

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

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

C

忽略其余部分后,程序转到第二行。我们从分号开始,因为该a=1语句需要终止。之后,我们遇到了一个简单的for循环,该循环显示了迭代变量,a在每次迭代两次。

在for循环之外,/*只是忽略Röda的结尾*/注释。


2

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

2

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代码。我没有意识到> <> 支持浮点除法,因此一开始的简短截断有点让人困惑。


2

Befunge-98 / > <>,32字节

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

在我看到><>有多少答案之前写了这个。一些背景:\是> <>中的换向运算符,在这种情况下将其向下推,而在Befunge中,它交换堆栈中的前两项。Befunge代码如下所示:

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

在线尝试!

打印出用换行符分隔的向后数字。Befunge在每个数字之后自动打印一个空格,因此每个数字都由空格分隔。重复获取最后一个数字,将其打印出来,然后将数字除以10,直到它为0。然后递增并重复。

> <>代码立即下降到第二行。

>l::naonao

在线尝试!

而且很简单。获取堆栈长度,用换行符打印两次,并在堆栈上保留该长度的副本,以进行下一个循环。


1

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)。无限重复此过程。由于循环是无限的,因此解释器将忽略该令牌之后的所有内容。


1

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

@LuisMendo此><>代码中使用的字符具有与“果冻代码页”相对应的ASCII代码点。我对这个代码页业务不太了解,但是我认为这将导致用于表示代码的字节相同。下一行的字符被忽略,><>因此在代码页之间它们是否完全相同并不重要。字节数取自><>TIO链接。
steenbergh

这些不是在> <>中没有分隔符的情况下打印的吗?
硕果累累

@ Challenger5你是对的;固定。
steenbergh

鱼没有字符类型;","只是将ASCII值压,入堆栈,因此您可以将其a用作换行符。
硕果累累

看起来逗号仍然在> <>解释的第一行。
硕果累累

1

C(gcc) / PHP102 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代码包装在字符串中)分隔。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.