เป็นที่รู้จักกันดี ,

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 / Jelly ,  14  13 ไบต์

-1 ไบต์ต้องขอบคุณ Adnan (หลีกเลี่ยงการเพิ่มขึ้นสามเท่าด้วยการพิมพ์ที่ไม่ปรากฏ)

ไบต์ดิบ (เลขฐานสิบหก):

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

ใน05AB1E 's รหัสหน้า :

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

Jellyโปรแกรมพิมพ์นับย้อนกลับไปกับแต่ละรายการคั่นด้วยการขึ้นบรรทัดใหม่

parser จะปฏิบัติตามตัวอักษรที่ถูกต้องระหว่าง[และ]เป็นตัวอักษรที่ถูกปิดล้อมมิฉะนั้นไบต์เหล่านี้เป็นโทเค็นที่ไม่ได้กำหนดและเป็นเช่นนี้กลายเป็นเทียบเท่ากับโทเค็นแยกรหัสออกเป็นบรรทัด ==>ไม่แยกวิเคราะห์ตามตัวอักษรดังนั้นรหัสจึงมีประสิทธิภาพ:

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

Jelly / Pyth ขนาด 15 ไบต์

.V1_`b;"1üÉÉ$

Unprintables ถูกสร้างโดยซอฟต์แวร์ SE ดังนั้นนี่คือ hexdump:

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

ทำงานด้วยjelly f fileและpyth fileตามลำดับ

คำอธิบาย

มาก่อนส่วน Pyth .Vวิ่งห่วงอนันต์มากกว่าลำดับที่เพิ่มขึ้นเริ่มต้นจากการป้อนข้อมูลของ บริษัท 1ซึ่งอยู่ที่นี่ จากนั้นเราจะย้อนกลับ ( _) ดัชนีสตริง( ) ที่ทำให้เป็นสตริง`( b) และส่งออกโดยปริยาย ;จะมีการสิ้นสุดการวนรอบและ"เป็นสิ่งที่จำเป็นในการรักษาส่วนที่เหลือของโปรแกรมที่เป็นสตริงตัวอักษรเพื่อให้ parser ไม่สำลักกับมัน

ส่วนของเยลลี่จะได้รับการอธิบายโดยการแปลส่วนที่เหลือของโปรแกรมจากหน้าจอของเจลลี่:

¶1‘ṄṄ$¿

¶ทำหน้าที่เป็นอาหารเส้นได้อย่างมีประสิทธิภาพโดยไม่สนใจส่วนแรกของโปรแกรมด้วยการทำให้การเชื่อมโยงที่ไม่เคยเรียกว่า จากนั้นเราเริ่มต้น1และเรียกใช้ a while loop ( ¿) ที่ใช้ṄṄ$(พิมพ์สองครั้ง) เป็นเงื่อนไขและเพิ่มค่า ( ‘) เป็น body loop

อนึ่งการแทนที่ส่วนPyth ด้วย1[DR,>] จะสร้างการส่ง Jelly / 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.$/))}

กลไกที่ผมเคยใช้มากใน polyglots JS / Perl คือการละเมิดความจริงที่ว่าเปลี่ยนตัวสามารถยอมรับสวยมากคั่นใด ๆ โดยใช้=วิธีการที่ฉันสามารถใช้แทนไม่มีจุดหมายครั้งแรก (ครั้งแรกแทนที่0;printด้วยconsole.log;mธงของ/sใน$_ซึ่งขณะนี้undef) แล้วตั้งค่า$_เพื่อผลของการแทนที่sด้วยsในโหมดหลาย ( /m) 0ซึ่งเป็น ตอนนี้$_เป็น0และฉันเริ่มต้นวงนี้แล้วเพิ่มขึ้นwhile $_ต่อไปฉันเรียกใช้printส่งผ่านนิพจน์ทั่วไปที่ตรงกับ (เนื่องจาก||ท้ายที่ตรงกับสตริงว่าง) และใช้&&โอเปอเรเตอร์เพื่อส่งการ$_เรียงกลับของการเชื่อมโยงกับ newline ($/ถูกกำหนดค่าเริ่มต้นล่วงหน้าเป็น"\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และเริ่มต้นwhileincrementing ห่วง$_โทร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 จะถูกตัดหลังจาก 128KB

V / Brain-flak Classic , 27 , 26 bytes

(()){[[({}())[]]]}é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
}

Retina / Python 2, 61 ไบต์

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

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

Retina | Python 2

R / Octave , 83 80 78 71 ไบต์

-3 ไบต์ขอบคุณ Luis Mendo

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

#{ }#เป็นความคิดเห็นแบบบล็อกคู่และ#เกิดขึ้นเป็นความคิดเห็นของล่าม The R เท่านั้นเห็นบรรทัดถัดไปเป็นเนื้อความของwhileลูปและล่ามระดับแปดเสียงจะข้ามไปข้างหน้ารหัสคู่

ส่วน R พิมพ์ตัวเลขจำนวนคู่เริ่มต้นที่ 1 และส่วนคู่พิมพ์ออกตัวเลขย้อนหลังเริ่มต้นที่ 0

ฉันคาดหวังอย่างเต็มที่ที่จะได้รับผลตอบแทนที่ดี (แม้จะใช้ภาษาเดียวกัน) ฉันเพิ่งเขียน Matlab และ R code มากเมื่อเร็ว ๆ นี้ที่ฉันคิดว่าฉันจะให้มันยิง

ลองออนไลน์! - ลิงค์คู่

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}}"

pputsเป็นชวเลข loopสร้างการวนซ้ำไม่สิ้นสุด

ถัดไปคือexecสิ่ง แต่ไม่เคยได้รับการประเมินเนื่องจากลูปอนันต์คือโดยนิยามไม่ จำกัด จำเป็นexecที่จะไม่ให้ผลผลิตไวยากรณ์ผิดพลาดด้วยรหัสหลาม

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

#เปลี่ยน 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: ลองออนไลน์!

คำอธิบาย

สิ่งนี้เป็นการละเมิดความจริงที่ว่า//มีการลงโทษทางวินัยในRöda แต่เป็นการแสดงความคิดเห็นในบรรทัด C

ในทั้งสองภาษาmain(){}หมายถึงโปรแกรมหลักและพวกเขาฟังก์ชั่นการโทรทั้งที่มีการโต้แย้งของหุ่นf0

ในRöda, a=1//1ไม่แบ่ง int และกำหนดผลการ1 aC เห็นa=1และทำสิ่งเดียวกัน แต่ทุกอย่างหลังจากการมอบหมายนั้นเป็นความเห็นสำหรับ C. จากที่นั่นภาษาทั้งสองแตกแขนงออกไป

Röda

เรามีวงวนไม่สิ้นสุดด้วยwhile[]( เงื่อนไขว่างคือความจริง ) ภายในนั้น` $a`แปลงจำนวนเต็มaเป็นสตริง (พร้อมช่องว่างนำหน้า) หลังจากนั้น[::-1]ย้อนกลับ (และส่งออกด้วยพื้นที่ต่อท้าย) จากนั้นค่าของaจะเพิ่มขึ้นทีละหนึ่ง

นอกเหนือจาก while loop ความคิดเห็นหลายบรรทัดจะเริ่มต้น/*และสิ้นสุดก่อนหน้าที่จะสิ้นสุด

C

หลังจากละเว้นบรรทัดที่เหลือโปรแกรมจะไปที่บรรทัดที่สอง เราเริ่มต้นด้วยเครื่องหมายอัฒภาคเพราะa=1คำสั่งจะต้องถูกยกเลิก หลังจากนั้นเราพบกับการวนรอบที่พิมพ์ตัวแปรการวนซ้ำaสองครั้งในการวนซ้ำแต่ละครั้ง

ด้านนอกของ for loop นั้น/*อยู่ตรงนั้นเพื่อเพิกเฉยต่อ*/ความคิดเห็นสุดท้ายของRöda

QBIC / QBasic 4.5 , 58 ไบต์

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

สิ่งนี้เป็นการละเมิดความจริงที่ว่าตัวอักษรตัวเล็กทั้งหมดถูกมองว่าเป็นตัวอักษร QBasic ตัวแปลโดยล่าม QBIC และจะส่งผ่านไปยังเลเยอร์ 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
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/

การดำเนินการเริ่มต้นที่!จะถูกละเว้นอย่างสมบูรณ์ จากนั้นก็มาถึง\และเริ่มเดินทางผ่านอักขระหลายตัวที่ไม่สนใจอย่างสมบูรณ์ ในที่สุดมันก็มาถึงที่อื่น\และความสนุกก็เริ่มขึ้น โดยทั่วไปฉันใช้แนวคิดเบื้องหลัง "Hello, World!" วนรอบและควบแน่นเหมือนที่ฉันทำได้ มันเป็นความท้าทายเล็กน้อยที่เกี่ยวข้องกับข้อเท็จจริงที่ว่า 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

ลองออนไลน์!

และค่อนข้างเรียบง่าย รับความยาวของสแต็กพิมพ์สองครั้งด้วยการขึ้นบรรทัดใหม่และเก็บสำเนาความยาวไว้บนสแต็กสำหรับลูปถัดไป

ทับทิม / เรียงซ้อน , 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เป็นการลดความตื่นเต้น) จากนั้น0จะถูกส่งไปยังสแต็ก หลังจากนั้นฟังก์ชัน[1+:tostr rev out]จะถูกส่งไปยังสแต็ก loopดึงฟังก์ชั่นนี้และเรียกใช้งานมันอย่างไม่ จำกัด

ด้านในของฟังก์ชั่นเพิ่มขึ้นด้านบนของสแต็ก ( 1+) ซ้ำมัน ( :) แปลงเป็นสตริง ( tostr) กลับรายการ ( rev) และส่งออกมัน ( out) กระบวนการนี้เกิดขึ้นซ้ำ ๆ อย่างไม่สิ้นสุด เนื่องจากการวนซ้ำนั้นไม่มีที่สิ้นสุดสิ่งใดที่เกิดขึ้นหลังจากนั้นโทเค็นจะถูกละเว้นโดยล่ามเป็นหลัก

> <> / เจลลี่ , 37 ไบต์ (25 ในเพจรหัสของเจลลี่)

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

ลอง> <> ออนไลน์!

ลองเยลลี่ออนไลน์!

> <>พิมพ์ลำดับไปที่อินฟินิตี้สองครั้งนับJellyย้อนหลัง

> <>เกี่ยวกับบรรทัดบนสุดเท่านั้น:

และขอขอบคุณ @ Challenger5 สำหรับการบันทึกไบต์บางส่วนที่นี่ใน linefeed

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.

เจลลี่เรียกใช้โค้ดจากล่างขึ้นบน เฉพาะ 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

ใน C #สิ่งที่เป็นตัวประมวลผลล่วงหน้าของฟอร์ม ฉันไม่ค่อยรู้อะไรเกี่ยวกับ C มากนัก แต่มันก็ไม่บ่นเมื่อมีบรรทัดว่างสำหรับสิ่งนี้ //รูปแบบสายความคิดเห็น \ที่ท้ายบรรทัดที่เป็นหลัก "หลบหนี" ขึ้นบรรทัดใหม่และทำให้ทั้งสองสายจะถือว่าเป็นหนึ่งใน นอกจากนี้ยังใช้งานได้กับความคิดเห็นของบรรทัดดังนั้นบรรทัดที่สองจึงถูกมองว่าเป็นความคิดเห็นใน C. บรรทัดที่สามทำงานของการแสดงผลตัวเลขด้วยการวนรอบอย่างง่าย หลังจากนั้นมีเพียงความคิดเห็น

PHP

ใน PHP จัด#รูปแบบความคิดเห็นของบรรทัดดังนั้นบรรทัดแรกจะถูกละเว้นทั้งหมด บรรทัดที่สองพิมพ์ตัวเลขที่ย้อนกลับด้วยห่วงสำหรับและแยกพวกเขาด้วย\nint main(i){for(;;i++)printf("%d %d ",i,i);}//(รหัส C ห่อในสตริง)