바와 같이 잘 알려진 ,

척 노리스는 무한대로 계산했습니다. 두번

게다가 ,

척 노리스는 거꾸로 무한대로 계산할 수 있습니다.

또한 아마도 덜 알려져 있지만 척 노리스는 영어 외에도 약간의 스페인어 를 할 수 있습니다 .

도전

두 가지 다른 언어로 실행할 수있는 프로그램 (또는 기능)을 작성하십시오. 한 언어에서 프로그램은 시퀀스를 출력해야합니다

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

다른 언어에서는 시퀀스를 생성해야합니다 (선행 0 포함)

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

규칙

• 모든 프로그래밍 언어의 프로그램 또는 기능 이 허용 됩니다 . 표준 허점 은 금지되어 있습니다.
• 동일한 언어의 다른 버전 (예 : Python 2/3)은 다른 언어로 계산되지 않습니다. 관련 언어 (예 : C / C ++ 또는 Matlab / Octave)는 다르게 계산됩니다.
• 입력이 없습니다.
• 프로그램은 사용자가 중지 할 때까지 시퀀스의 조건을 계속 출력해야합니다. 프로그램 자체가 멈추지 않으므로 결국에는 출력을 생성 할 수 없습니다. 프로그램이 지속적으로 또는 배치로 실행되는 동안 생성되어야합니다.
• 출력은 STDOUT 또는 이와 동등한 것을 사용하거나 그래픽 창에 표시 될 수 있습니다. 각 항이 이웃 항과 명확하게 구별 될 수있는 한, 서열 항 사이의 숫자가 아닌 분리자가 허용됩니다. 용어간에 화면이 지워진 경우에도 허용됩니다.
• 둘 중 하나에서 0대신 시퀀스를 시작할 수 있습니다 1. 이 경우 "두 번"순서로 0다른 숫자와 마찬가지로 반복해야합니다.
• 선행 0은 "뒤로"순서에서 중요합니다. 예를 들어, 열 번째 항은 01; 허용 되지 1도 않습니다 001.
• 두 언어가 다른 문자 인코딩을 사용하는 경우 프로그램은 문자가 아닌 바이트 로 정의됩니다 . 즉, 두 언어에서 바이트가 동일해야합니다.
• 바이트 단위의 최단 코드가 이깁니다.

05AB1E / 젤리 ,  14  13 바이트

Adnan 덕분에 -1 바이트 (팝핑이 아닌 인쇄로 3 회 피)

원시 바이트 (16 진수) :

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

에서 05AB1E 의 코드 페이지 :

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

온라인으로 사용해보십시오!

에서 젤리 의 코드 페이지 :

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 : 온라인으로 해보십시오!

파이썬 코드에서 L은 분리 문자의 일부입니다.

설명:

C 코드에서는 먼저 i를 0으로 설정합니다. 그런 다음 Python 코드가 있는 주석 ( 문의 경우 #C의 유효한 코드 임 #include)을 시작합니다. 주석의 끝에 변수를 영원히 증가시키고 공백으로 구분하여 두 번 인쇄하는 함수를 정의합니다. 그런 다음 주석을 시작합니다.

파이썬 코드에서 i=0;i를 0으로 설정합니다. 파이썬은 한 #줄 주석을 시작 하기 때문에 다음 줄을 무시합니다 . 그런 다음 영원히 증가시키고 긴 숫자로 바꾸고 뒤집은 문자열 표현을 인쇄합니다. 긴 부분의 'L'은 구분 기호의 일부입니다. 그런 다음 C 코드를 주석 처리하기 위해 여러 줄 문자열을 시작하여 나중에 끝납니다.

@LuisMendo 덕분에 -2 바이트. @ZacharyT 덕분에 -7 바이트 @ZacharyT 덕분에 -6 바이트 더. @ mbomb007 덕분에 버그를 수정하려면 +11 바이트. @Doorknob 덕분에 -7 바이트 @Doorknob 덕분에 버그를 수정하기 위해 +1 바이트. @yoann 덕분에 -1 바이트. @yoann 덕분에 -1 바이트 더. @Cyoce 덕분에 -3 바이트.

젤리 / 피쓰, 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) 을 반전 시키고 ( ) 암시 적으로 출력합니다. 은 ;루프를 종료 할 수있다, 그리고는 "파서가 질식하지 않도록 리터럴 문자열로 프로그램의 나머지 부분을 치료하는 것이 필요하다.

젤리 부분은 먼저 젤리 코드 페이지에서 프로그램의 나머지 부분을 번역하여 설명됩니다.

¶1‘ṄṄ$¿

이 프로그램 ¶은 라인 피드 역할을하며 절대 호출되지 않는 링크를 만들어 프로그램의 첫 번째 부분을 무시합니다. 그런 다음 조건을 시작으로 두 번 인쇄 1하는 while 루프 ( ¿)를 시작 하고 실행 하여 루프 본문으로 값을 ṄṄ$증가시킵니다 ( ‘).

덧붙여서, Pyth 부분을 교체하면 14 바이트의 유효한 Jelly / 05AB1E 제출 1[DR,>] 이 생성되지만 현재 인터 턴은 이것을 막는 버그 를 포함 합니다 .

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 / 펄 polyglots에서 많이 사용했습니다 메커니즘을 사용하여 대체 거의 모든 구분 기호를 수용 할 수 있다는 사실을 악용하는 것입니다 =내가 (첫번째 교체 초기 무의미 대체를 사용할 수있는 수단을 0;print함께 console.log;m하는 플래그 /s의 $_현재, undef) 다음 설정 $_대체의 결과 s로 s여러 모드 (에 /m있다) 0. 이제 $_이며 0내가 시작 while루프를,이 후 증가 $_. 다음으로 나는 빈 문자열과 일치하는 끝에 print정규 표현식을 전달 ||하고 &&연산자를 사용하여 $_줄 바꿈 으로 연결된 역을 보냅니다 ($/)으로 사전 초기화되었습니다 "\n". 이것은 거꾸로 무한대로 계산됩니다.

자바 스크립트

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펄을하지만, 표준 JS의 부문으로 처리) 및 목표 문자열 ( $_+"\n"+$_)는 쉼표 연산자를 통해 목록의 마지막 항목을 반환합니다. 펄 코드 ( &&reverse.$/) 의 마지막 부분은 피하기 때문에 피할 $_+"\n"+$_수 없기 때문에 결코 평가되지 않는 펄 코드의 끝을 포함 ||하는 RegExp객체 를 생성하는 데 사용할 수 있습니다 .

Perl 5 및 Node 6을 사용하여 테스트했습니다.

NodeJS / PHP, 131 106 바이트

@Titus 덕분에 -25 바이트

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

더 나은 출력 형식과 더 나은 무한 루프 처리를 위해 브라우저 JS 대신 NodeJS를 사용하십시오.

온라인 자바 스크립트를
사용해보십시오. 온라인 PHP를 사용해보십시오.

TIO 출력은 128KB 후에 잘립니다.

V / Brain-flak Classic , 27 , 26 바이트

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

16 진 덤프 :

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

온라인으로 사용해보십시오! in V (출력을 볼 수 있도록 약간 수정되었습니다. TIO에서는 프로그램이 종료 된 경우에만 V가 출력됩니다)

온라인으로 사용해보십시오! Brain-flak Classic에서

V 코드는 brain-flak classic에 영향을 미치지 않으며 그 반대도 마찬가지이기 때문에 이것은 폴리 글 로트에서 가장 흥미롭지는 않습니다. 자신에.

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
}

레티 나 / 파이썬 2, 61 바이트

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

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

망막 | 파이썬 2

R / 옥타브 , 83 80 78 71 바이트

Luis Mendo 덕분에 -3 바이트

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

#{ }#옥타브 블록 주석이며 #너무 R.는 R 인터프리터에 대한 코멘트 될 일이 단지의 몸으로 다음 줄보고 while루프를하고, 옥타브 인터프리터는 옥타브 코드에 바로 앞서 건너 뜁니다

R 부분은 1부터 시작하여 숫자 쌍을 인쇄하고 옥타브 부분은 0부터 시작하는 역 숫자를 인쇄합니다.

나는 (같은 언어 조합으로도) 외향적 일 것으로 기대한다. 최근에 Matlab과 R 코드를 너무 많이 작성하여 촬영할 것이라고 생각했습니다.

온라인으로 사용해보십시오! -옥타브 링크

루비 / 파이썬 2 : 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파이썬 코드 구문 오류를 생성 할 수 없습니다.

파이썬 관점

파이썬의 관점에서 볼 때 공통점이 i=0있습니다. 다음으로, 파이썬은 문자열 보간에 대해 다른 구문을 가지므로이 줄은 단순히 폐기됩니다. 다음으로 다른 사람들이 게시 한 것과 비슷한 무한 루프가 있습니다.

Bash / Check , 50 28 바이트

^{Python에서 Bash로 전환하여 많은 바이트를 절약 한 @Doorknob 덕분에}

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

배쉬하기 :

#>
#v
 #p<p<)#

이들은 일부 주석이며 무시됩니다.

seq 1 inf|rev

1에서 무한대로 시퀀스를 시작한 다음 결과를로 파이프하십시오 rev.

확인하다:

#>

이것은 바로 2D 모드로 전환하고 오른쪽으로 이동합니다. >IP를 올바르게 지시하지만 아무런 효과가 없습니다. 그것은 줄의 시작 부분을 감싸고 #다시 쳐서 2D 모드에서 전환됩니다. 그런 다음 >1D 모드에서 0을 스택으로 푸시합니다. 1D 모드이므로 IP는 다음 줄로 줄 바꿈됩니다.

#v

#IP를 다시 2D 모드로 전환하고 v아래쪽으로 향하게합니다.

 #p<p<)#

첫 번째는 #다시 1D 모드로 다시 전환됩니다. pTOS를 숫자로 출력하고 (팝하지는 않음) <줄 바꿈 을 인쇄합니다. 이 작업은 두 번 수행 된 다음 숫자가로 증가합니다 ). #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스택의 길이를 취하고 a10을 밀고 ,나눕니다. 이것은 우리에게 스택 / 10의 길이를 제공합니다.

    :nao

:복제하고, n숫자로 인쇄하고, a10을 누른 o다음 문자 코드 (줄 바꿈)로 인쇄합니다.

        nao

같은 것. 줄 바꿈 다음에 숫자를 인쇄하십시오. 이제 스택의 길이는 10입니다 (원래 문자열 리터럴의 내용이 스택에 있음).

그런 다음 IP가 "다시 둘러싸여 10 개의 요소를 더 밀어 붙입니다. 다음에 l는 20을 반환하므로 2가 인쇄됩니다.

두 번째 줄은 IP에 의해 절대 손대지 않습니다.

로다 / C (gcc) , 90 바이트

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

로다 : 온라인으로 해보십시오!

C : 온라인으로 해보십시오!

설명

이것은 //Röda에서 int divison이지만 C에서 줄 주석 이라는 사실을 남용합니다 .

두 언어 모두 main(){}기본 프로그램을 나타내며 둘 다 f더미 인수로 함수 를 호출합니다 0.

Röda a=1//1에서는 int 나누기를 수행하고 결과 1를에 할당합니다 a. C는 a=1똑같은 것을 보고 수행하지만, 그 할당 이후의 모든 것은 C에 대한 주석입니다. 거기에서 두 언어는 분기됩니다.

로다

우리는 무한 루프를 가지고 있습니다 while[]( 빈 상태는 진실입니다 ). 그 안에 ` $a`정수 a를 문자열 (앞 공백이있는)로 변환 한 후 [::-1]반전하고 후행 공백으로 출력합니다. 그런 다음의 값이 a1 씩 증가합니다.

while 루프 외부에서 여러 줄 주석은 /*함수가 끝나기 직전에 시작 하고 끝납니다.

씨

나머지 줄을 무시한 후 프로그램은 두 번째 줄로갑니다. a=1명령문을 종료해야 하므로 세미콜론으로 시작 합니다. 그 후에 반복 변수 a를 각 반복마다 두 번 인쇄하는 간단한 for 루프가 발생합니다 .

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 코드가없는 것처럼 계속 진행됩니다. > <> 는 float 나누기 만 지원 한다는 것을 알지 못했기 때문에 처음에는 짧고 간단한 잘림이 약간 혼란 스러웠습니다.

Befunge-98 / > <> , 32 바이트

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

나는 ><>거기에 얼마나 많은 답이 있는지보기 전에 이것을 썼다 . 일부 배경 : \> <>의 방향 변경 연산자입니다.이 경우 아래로 밀어 내고 Befunge에서는 스택의 상위 두 항목을 바꿉니다. Befunge 코드는 다음과 같습니다.

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

온라인으로 사용해보십시오!

줄 바꿈으로 구분 된 역 숫자를 인쇄합니다. Befunge는 각 숫자 다음에 공백을 자동으로 인쇄하므로 각 숫자는 공백으로 구분됩니다. 마지막 숫자를 반복해서 가져 와서 인쇄하고 0이 될 때까지 숫자를 10으로 나눕니다. 그런 다음 증가하고 반복하십시오.

> <> 코드는 즉시 두 번째 줄로 내려갑니다.

>l::naonao

온라인으로 사용해보십시오!

그리고 매우 간단합니다. 스택 길이를 가져와 줄 바꿈으로 두 번 인쇄 한 후 다음 루프를 위해 스택에 길이의 복사본을 남겨 둡니다.

루비 / 스택 , 37 바이트

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

온라인으로 사용해보십시오!

1 1 2 2루비와 1 2 3 ... 01 11 21...스택으로 인쇄 됩니다.

설명

루비에서 :

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 바이트 (Jelly의 코드 페이지에서 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.

젤리 는 코드를 아래에서 위로 실행합니다. 마지막 두 줄만 관련이 있습니다.

®‘©Çß       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에서는 #양식 프리 프로세서입니다. 나는 C에 대해 많이 알지 못하지만이 물건에 빈 줄이있을 때 불평하지 않습니다. //형태의 라인 주석. \줄 끝의 A 는 본질적으로 줄 바꿈을 "이스케이프"하고 두 줄을 하나로 취급합니다. 이것은 라인 주석에도 적용되므로 두 번째 라인은 C에서 주석으로 표시됩니다. 세 번째 라인은 간단한 for 루프로 숫자를 출력하는 작업을 수행합니다. 그 후, 단순히 의견이 있습니다.

PHP

PHP에서는 #줄 설명을 구성하므로 첫 줄은 완전히 무시됩니다. 두 번째 줄은 for 루프와 반대로 숫자를 인쇄하고 \nint main(i){for(;;i++)printf("%d %d ",i,i);}//(문자열로 싸인 C 코드)로 구분합니다 .