Gibi iyi bilinen ,

Chuck Norris sonsuzluğa sayıldı. İki defa

Ayrıca ,

Chuck Norris, sonsuzluğa geriye doğru sayabilir.

Ayrıca, belki de daha az bilinmesine rağmen, Chuck Norris İngilizce'ye ek olarak biraz İspanyolca konuşabilir .

Meydan okuma

İki farklı dilde çalıştırılabilecek bir program (veya işlev) yazın. Bir dilde program dizisi vermelidir

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

ve diğer dilde diziyi üretmelidir (baştaki sıfırlar dahil)

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

kurallar

• Herhangi bir programlama dilinde programlara veya fonksiyonlara izin verilir . Standart boşluklar yasaktır.
• Aynı dilin farklı sürümleri (Python 2/3 gibi) farklı diller olarak sayılmaz. İlgili diller (C / C ++ veya Matlab / Octave gibi) farklı sayılır.
• Giriş alınmayacak.
• Program, kullanıcı tarafından durdurulana kadar dizinin koşullarını çıkarmaya devam etmelidir. Program kendiliğinden durmayacağından, sonuçta çıktı üretilemiyor. Program sürekli veya gruplar halinde çalışırken üretilmelidir.
• Çıktı, STDOUT veya eşdeğerini kullanabilir veya bir grafik penceresinde görüntülenebilir. Her bir terim komşu terimlerden açıkça ayırt edilebildiği sürece, dizi terimleri arasındaki sayısal olmayan herhangi bir ayırıcıya izin verilir. Ekranın terimler arasında silinmesi de kabul edilebilir.
• Her iki sıra 0yerine de başlayabilir 1. Bu durumda, "iki kez" sekansta 0, diğer numaralar gibi tekrarlanmalıdır.
• Öndeki sıfırlar "geriye" sırayla önemlidir. Örneğin, onuncu terim 01; ne 1de ne 001kabul edilebilir.
• İki dil farklı karakter kodlamaları kullanıyorsa, program karakterleri değil baytlarıyla tanımlanır . Diğer bir deyişle, bayt iki dilde aynı olmalıdır.
• Bayt cinsinden en kısa kod kazanır.

05AB1E / Jelly ,  14  13 bayt

Adnan sayesinde -1 byte (haşhaş olmayan baskılarla üç kopya yapmaktan kaçının)

Ham bayt (onaltılık):

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

In 05AB1E 'nin kod sayfası :

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

Çevrimiçi deneyin!

In Jelly 'nin kod sayfası :

1[==>]‘©Ṛ;⁷®ß

Çevrimiçi deneyin!

Nasıl?

05AB1E programı satırbaşıyla ayrılmış her bir giriş ile çift sayılmasını yazdırır:

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

Jöle programı satırbaşıyla ayrılmış her bir giriş ile ters sayımı basar.

Ayrıştırıcı , eklenmiş değişmezlerin arasında [ve arasında geçerli bir değişmezi ele alır ], aksi takdirde bu baytlar tanımsız belirteçlerdir ve bu şekilde kodu satırlara ayıran belirteçlere eşdeğer olur. ==>değişmez olarak ayrıştırmaz, bu nedenle kod etkilidir:

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 (klan) , 109 107 100 84 95 88 89 88 87 84 bayt

i=0;
#/*
while 1:i+=1L;print`i`[::-1]
'''*/
a(){for(;;)printf("%i %1$i ",++i);}//'''

Python: Çevrimiçi deneyin!

C: Çevrimiçi deneyin!

Python kodundaki L, sınırlayıcının bir parçasıdır.

Açıklama:

C kodunda, ilk önce i'yi 0'a ayarlar. Daha sonra, Python kodunun gittiği bir yorum başlatır ( #C #includeifadesinde geçerli olan koddur ). Yorumun sonunda, bir değişkeni sonsuza dek artıran ve onu iki kez alandan ayrılmış bir şekilde basan bir işlev tanımlar. Daha sonra bir yorum başlar.

Python kodunda, i=0;i sıfıra ayarlar. Python bir sonraki satırı yok sayar çünkü #tek satırlı bir yorum başlatır. Daha sonra sonsuza dek artırır ve uzun bir sayıya dönüşür ve ters dize gösterimini yazdırır. Uzun olan 'L' sınırlayıcının bir parçasıdır. Bundan sonra, daha sonra sona erecek olan C kodunu yorumlamak için çok satırlı bir dize başlar.

@LuisMendo sayesinde -2 bayt. -ZacharyT sayesinde -7 bayt. -ZacharyT sayesinde 6 bayt daha. @ Mbomb007 sayesinde bir hatayı düzeltmek için +11 bayt. @Doorknob sayesinde -7 bayt. @Doorknob sayesinde bir hatayı düzeltmek için +1 bayt. @Yoann sayesinde -1 bayt. @Yoann sayesinde -1 bayt daha. @Cyoce sayesinde -3 bayt.

Jelly / Pyth, 15 bayt

.V1_`b;"1üÉÉ$

Yazdırılamayanlar SE yazılımı tarafından yönetiliyor, bu yüzden burada bir hexdump:

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

Sırasıyla jelly f fileve ile çalıştırın pyth file.

açıklama

İlk önce Pyth kısmı geliyor. .VBuradaki girişinden başlayarak artan dizilim üzerinde sonsuz bir döngü çalıştırır 1. Daha sonra _stringified ( `) loop index ( b) 'i tersine çevirir ve örtük olarak çıkarırız . ;Döngü sona erdirmek için orada ve "ayrıştırıcı buna boğulursun kalmaması değişmez bir dize olarak programın geri kalanını tedavi etmek gereklidir.

Jelly kısmı, ilk önce programın kalanını Jelly kod sayfasından çevirerek açıklanacaktır:

¶1‘ṄṄ$¿

¶Bir satır besleme görevi görür etkin bunu asla denir bir bağlantı yaparak programın ilk bölümünü yok sayarak. Daha sonra , koşulu olarak kullanan (iki kez yazdır) kullanan 1bir while döngüsünde ( ) başlar ve değeri döngü gövdesi olarak artırır ( ).¿ṄṄ$‘

Bu arada, ile Pyth kısmını yerine 1[DR,>] ediyorum 14 bayt geçerli Jöle / 05AB1E gönderi oluşturma, ancak mevcut yorumlayıcı içeren bir hata bunu engeller.

Perl / JavaScript, 87 bayt

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 Polyglots bir çok kullandım bir mekanizma kullanılarak, ikame hemen hemen herhangi bir ayırıcı kabul edilmesine kötüye için =(ilk yerine başlangıç anlamsız ikameleri kullanarak aracı 0;printile console.log;mbir bayrak /solarak $_şu anda, undef) , daha sonra olduğu gibi multiline modunda ( ) ile $_değiştirmenin sonucuna ayarlanması . Şimdi ise ve ben başlamak döngü, bu daha sonra artırır . Sonra , ( boş bir dize ile eşleşen sonuçtan dolayı) eşleşen düzenli bir ifadeden geçerek çağrı yapıyorum ve operatörü daha sonra yeni satır ile birleştirilmiş satırın tersini göndermek için kullanıyorum (ss/m0$_0while$_print||&&$_$/önceden başlatıldı "\n"). Bu geriye doğru sonsuza kadar sayılır.

JavaScript

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

Perl s///aramalarında maskelenmiş birçok değişken ataması var . Ben değişkenleri kurmak sve molarak 0takma, console.logiçin print, set, bazı anlamsız bölümündeyim $_için 0ve başlamak whiledöngü artımlı sayı $_diyoruz, printgeçen 0( m/sbu aramayı başlatır mPerl, ancak standart JS bölünme olarak kabul edilir) ve hedef dize ( $_+"\n"+$_) listedeki son öğeyi döndüren virgül operatörü aracılığıyla. Son parça Perl kodundan ( &&reverse.$/) kaçınıyorum, çünkü gerçek $_+"\n"+$_olacak ve bu yüzden asla değerlendirilmeyen Perl kodunun sonunu içeren ||bir RegExpnesne üretmek için kullanabilirim .

Perl 5 ve Node 6 kullanılarak test edildi.

DüğümJS / PHP, 131 106 bayt

@Titus sayesinde -25 bayt

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

Daha iyi çıktı formatlama ve daha iyi sonsuz döngü işleme için tarayıcı JS yerine NodeJS kullanma.

JavaScript'i çevrimiçi
deneyin PHP'yi çevrimiçi deneyin

TIO çıkışının 128KB'den sonra kesildiğine dikkat edin.

V / Brain-flak Classic , 27 , 26 bayt

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

HexDump:

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

Çevrimiçi deneyin! V (biraz değiştirildi, böylece sonlandırılacak, böylece çıktıyı görebilirsiniz.) TIO'da, V yalnızca program sonlandığında çıkar.)

Çevrimiçi deneyin! Brain-flak Klasik'te

Bu, çok uçlu olanların en ilginci değil, çünkü V kodu, beyin-flak klasiğine etki etmiyor, ve bunun tersi, ancak kendi dillerimi zorlamak için kullanmam çok eğlenceli ve iki çözüm de oldukça ilginç. kendi başlarına.

V açıklama:

é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 açıklaması:

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

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

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

Retina | Python 2

R / Octave , 83 80 78 71 bayt

Luis Mendo sayesinde -3 bayt

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

#{ }#bir Octave bloğu yorumu ve #sadece R'nin yorumu olur. R tercümanı sadece bir sonraki satırı whiledöngünün gövdesi olarak görür ve Octave tercümanı Octave kodunun tam önüne atlar.

R bölümü 1'den başlayan sayı çiftlerini yazdırır ve Octave bölümü 0'dan başlayan geri sayıları yazdırır.

Ben tamamen aşılmayı bekliyorum (aynı dil kombinasyonuyla bile); Son zamanlarda çok fazla Matlab ve R kodu yazıyorum, bir şans vereceğimi düşündüm.

Çevrimiçi deneyin! - Octave bağlantısı

Ruby / Python2: 68 64 bayt

i=0
"#{loop{p i+=1,i}}"
exec('while 1:print str(i)[::-1];i+=1')

Yakut perspektif

değişken basit init:

i = 0

"#{}"dize enterpolasyonu için sözdizimidir. Bunun yerine ifadeyi yürütmek için kullanıyorum.

"#{loop{p i+=1,i}}"

piçin bir steno puts. loopsonsuz bir döngü oluşturur.

Sonra bir execşey var, ama sonsuz döngü tanım olarak sonsuz olduğundan, asla değerlendirilmez. Gereken execPython kodu ile sözdizimi hatası verecek şekilde değil.

Python perspektifi

Python açısından bakıldığında, ortak bir var i=0. Daha sonra, Python'un dize enterpolasyonu için farklı bir sözdizimi vardır, bu yüzden bu satır atılır. Daha sonra, diğerlerinin gönderdiklerine benzer sonsuz bir döngü var.

Bash / Check , 50 28 bayt

^{Python'dan Bash'e geçerek bir grup baytı kurtardığı için @Doorknob'a teşekkürler}

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

Bash'e:

#>
#v
 #p<p<)#

Bunlar göz ardı edilen bazı yorumlar.

seq 1 inf|rev

1'den sonsuza kadar giden bir dizi başlatın, ardından sonucu kesin rev.

Kontrol etmek:

#>

Bu hemen 2D moduna geçer ve sağa döner. >etkisi olmayan IP hakkını yönlendirir. Çizginin başına dolanır ve #2B modundan çıkan tekrar vurur . Daha sonra >1D modundayken, 0'ı yığına iter. 1D modunda olduğundan, IP bir sonraki satıra kaydırılır.

#v

#IP'yi tekrar 2D moduna vgeçirir ve aşağı doğru yönlendirir.

 #p<p<)#

İlki #tekrar 1D moduna geçer. pTOS'u bir sayı olarak çıkarır (ancak açmaz) ve sonra <yeni bir satır yazdırır. Bu iki kez yapılır ve sonra sayı ile artırılır ). #tekrar 2D moduna geçer, böylece IP satırın başına #kaydırılır, 1D moduna geçmek için vurur .

CJam /> <>, 27 23 bayt

"la,:naonao
"1{_sW%n)}h

CJam’e:

Çevrimiçi deneyin! - Çıktıyı görmek için 60 saniye sınırına kadar beklemeniz gerektiğini unutmayın, ancak çevrimdışı çalışıyor.

"la,:naonao
"

Bu, hiç kullanılmamış çok satırlı bir dizgi değişmezini tanımlar.

 1{_sW%n)}h

İkinci satır şöyle gider:

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

Kime> <>:

"

Bir dize değişkeni başlar.

 la,:naonao

Dize değişmezinin içeriği. Karakter kodlarının her biri ayrı ayrı yığına itilir.

"

IP "tekrar ulaşmak için etrafa sarılır ve bu da string modunu sonlandırır.

 la,

lyığının uzunluğunu alır, a10'a basar ve ,böler. Bu bize yığının / 10 uzunluğunu verir.

    :nao

:çoğaltır, nsayı olarak basar, a10'a obasar ve karakter kodu olarak basar (yeni satır).

        nao

Aynı şey. Numarayı ardından yeni bir satır yazdırın. Yığın şimdi tekrar 10 uzunluğuna sahip (orijinal dize değişmezinin içeriği yığında.)

IP daha sonra "tekrar etrafına sarılır ve itilmesi gereken 10 element daha bulunur. Bir dahaki sefere, l20 döndürür, böylece 2 yazdırılır vb.

İkinci satıra hiçbir zaman IP tarafından dokunulmaz.

Röda / C (gcc) , 90 bayt

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

Röda: Çevrimiçi deneyin!

C: Çevrimiçi deneyin!

açıklama

Bu //Röda’daki int bölücü, ancak C’deki bir satır yorumunu kötüye kullanıyor .

Her iki dilde main(){}de ana programı belirtir ve her ikisi de işlevini fkukla bir argümanla çağırır 0.

Roda, a=1//1int bölümü yapar ve sonucu atar 1için a. C a=1aynı şeyi görür ve yapar, ancak bu ödevden sonraki her şey C için bir yorumdur. Oradan iki dil ayrılır.

Röda

Sonsuz bir döngümüz var while[]( boş bir şart truthy ). Bunun içinde ` $a`, tamsayıyı abir dizgeye dönüştürür [::-1](baştaki boşlukla), sonra onu tersine çevirir (ve sonunda boşlukla çıkar). Sonra değeri abir artar.

While döngüsünün dışında, çok satırlı bir yorum başlar /*ve fonksiyonun sonundan hemen önce sona erer.

C

Satırın kalanını yoksaydıktan sonra, program ikinci satıra gider. Bir noktalı virgül ile başlıyoruz çünkü a=1ifadenin sonlandırılması gerekiyor. Ondan sonra, yineleme değişkenini aher yinelemede iki kez basan basit bir döngü için karşılaşıyoruz .

For döngüsünün dışında, /*Röda'nın son */yorumunu görmezden gelmek için orada .

QBIC / QBasic 4.5 , 58 bayt

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

Bu, tüm küçük harflerin QBIC yorumlayıcısı tarafından gerçek bir QBasic kodu olarak görülmesi ve QBIC'in QBIC katmanına henüz iletilmesi gerçeğini kötüye kullanır. Her iki dil de bu kodu yan yana nasıl görür:

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 bayt

!\0 \
/:+1/!   ]oo\
\:a( ?\:a%$a ,!
/r[-1l//" ,"/
/!n-%1:\?(1l
 \ --\/ <<---\
/----/'
\----  v
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/

İlk kez golf oynamanın sebebi muhtemelen olabileceğinden biraz daha büyük. > <> Kullanmak istedim, ancak birkaç kişi onu ikinci diziyi oluşturmak için kullandığından beri, ilk diziyi oluşturmaya başlamaya karar verdim.

> <> Çevrimiçi deneyin!
LaserLANG için, denemek için çevrimdışı bir tercüman gerekir. Bu bulunabilir burada .

laserLANG

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

yürütme !tamamen göz ardı edilir. daha sonra ulaşır \ve tamamen görmezden geldiği birkaç karakteri geçmeye başlar. Sonunda başka bir şeye uzanıyor \ve eğlence başlıyor. Temelde "Merhaba Dünya!" Nın arkasındaki fikri aldım. Döndüm ve elimden geldiğince yoğunlaştırdım. LaserLANG'nin yalnızca program sayacı sola / sağa giderken yalnızca bellek sayacını azaltmak / artırmak üzere olduğu gerçeğiyle ilgilenmek biraz zordu. Hiç düşünmedim püf noktaları yaparak en fazla baytın kurtarılabileceğini hissediyorum.

> <>

!\0 \
/:+1/!   ]oo\
\:a( ?\:a%$a ,!
/r[-1l//" ,"/
/!n-%1:\?(1l

Yürütme işlemi !atlamasına neden olarak başlar \. LaserLANG kodu orada yokmuş gibi devam eder. Sadece yüzdürme bölümünü desteklediğinin farkında değildim , bu yüzden kısa ve basit bir kesilme başlangıçta biraz kafa karıştırıcıydı.

Befunge-98 / > <> , 32 bayt

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

Kaç tane ><>cevap olduğunu görmeden önce bunu yazdım . Bazı arkaplanlar: \> <> yön değiştiren bir operatördür, bu durumda aşağı bastırırken, Befunge'de yığındaki en üstteki iki öğeyi değiştirir. Befunge kodu şöyle görünür:

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

Çevrimiçi deneyin!

Yeni satırlarla ayrılmış geriye doğru sayıları yazdırır. Befunge, her sayıdan sonra otomatik olarak bir boşluk yazdırır, böylece her basamak boşluklarla ayrılır. Arka arkaya son basamağı alır, yazdırır ve sayıyı 0 olana kadar 10'a böler. Ardından, artırın ve tekrarlayın.

> <> Kodu hemen ikinci satıra iner.

>l::naonao

Çevrimiçi deneyin!

Ve oldukça basittir. Yığın uzunluğunu alın, yeni satırlarla iki kez yazdırın ve sonraki döngünün uzunluğunun bir kopyasını yığınta bırakın.

Yakut / Yığın , 37 bayt

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

Çevrimiçi deneyin!

Bu baskılar 1 1 2 2... Ruby'de ve 1 2 3 ... 01 11 21...Stacked'de.

açıklama

Ruby'de:

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

Yorumu kaldırdıktan sonra, bu olur:

0
loop{p p$.+=1}

Buradaki tek ilgili çizgi sonuncusu. pargümanını döndürür, bu nedenle p pargümanını iki kez yazdırır. $.başlar 0, böylece $.+=1artışlarla $.arttırılmış değerini geri. Bu nedenle, bu her numarayı ikiden yazdırır 1.

Yığılmış:

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

Bu, aşağıdaki belirteçlere eşdeğerdir:

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

İlk ikisi 0anlamsızdır (temel olarak, azaltılmamış bir Unction'a dönüşme ). Sonra 0yığına itilir. Ardından, işlev [1+:tostr rev out]yığına itilir. loopbu işlevi açar ve sonsuz şekilde çalıştırır.

İşlevin içi yığının ( 1+) değerini artırır , çoğaltır ( :), onu bir dizgeye ( tostr) dönüştürür , tersine çevirir ( rev) ve çıkar ( out). Bu işlem sonsuz tekrarlanır. Döngü sonsuz olduğundan, belirteçten sonra gelen herhangi bir şey tercüman tarafından göz ardı edilir.

> <> / Jelly , 37 bayt (Jelly'in kod sayfasında 25)

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

> <> Çevrimiçi deneyin!

Jelly'i çevrimiçi deneyin!

> <> sekansı iki defa sonsuzluğa basar, Jelly geriye doğru sayar.

> <> yalnızca üst satırla ilgilidir:

Ve burada bazı baytları hat akışına kaydettiği için @ Challenger5'e teşekkürler

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 kodunu aşağıdan yukarıya doğru yürütür. Sadece son 2 satır ilgili.

®‘©Çß       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 bayt

#//\
for(;;)echo strrev(++$i).'
int main(i){for(;;i++)printf("%d %d ",i,i);}//';

C'deki çift diziyi ve PHP'deki ters diziyi çıkarır.

C de dene!

PHP'de deneyin!

açıklamalar

C

C, #formları önişlemci şeyler. C hakkında pek bir şey bilmiyorum ama bu iş için herhangi bir boş satır olduğunda şikayetçi değil. //Formları bir çizgi açıklama. Bir \çizginin sonundaki A , esasen yeni çizgiden "kaçar" ve iki çizgiyi bir olarak ele alır. Bu aynı zamanda satır yorumları için de işe yarar, bu nedenle ikinci satır C'de bir yorum olarak görülür. Üçüncü satır, sayıları basit bir döngü ile basma işlemini yapar. Daha sonra, sadece bir yorum var.

PHP

PHP'de #bir satır yorumu oluşturur, bu nedenle ilk satır tamamen göz ardı edilir. İkinci satır, for döngüsü ile ters çevrilmiş sayıları yazdırır ve birbiriyle ayırır \nint main(i){for(;;i++)printf("%d %d ",i,i);}//(bir dizeye sarılı C kodu).