Wie allgemein bekannt ,

Chuck Norris zählte bis unendlich. Zweimal

Außerdem ,

Chuck Norris kann rückwärts bis unendlich zählen.

Auch wenn Chuck Norris vielleicht weniger bekannt ist, kann er neben Englisch auch ein wenig Spanisch .

Die Herausforderung

Schreiben Sie ein Programm (oder eine Funktion), das bzw. die in zwei verschiedenen Sprachen ausgeführt werden kann. In einer Sprache sollte das Programm die Sequenz ausgeben

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

und in der anderen Sprache sollte es die Sequenz erzeugen (einschließlich führender Nullen)

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

Regeln

• Programme oder Funktionen sind in jeder Programmiersprache zulässig . Standardlücken sind verboten.
• Verschiedene Versionen derselben Sprache (wie Python 2/3) zählen nicht als verschiedene Sprachen. Verwandte Sprachen (wie C / C ++ oder Matlab / Octave) gelten als unterschiedlich.
• Es werden keine Eingaben gemacht.
• Das Programm sollte weiterhin Terme der Sequenz ausgeben, bis es vom Benutzer gestoppt wird. Da das Programm nicht von selbst stoppt, kann am Ende keine Ausgabe erzeugt werden. Es muss entweder kontinuierlich oder stapelweise im laufenden Programm produziert werden.
• Die Ausgabe kann über STDOUT oder ein Äquivalent erfolgen oder in einem Grafikfenster angezeigt werden. Jedes nicht-numerische Trennzeichen zwischen Sequenztermen ist zulässig, sofern jedes Term klar von seinen Nachbartermen unterschieden werden kann. Es ist auch akzeptabel, wenn der Bildschirm zwischen den Begriffen gelöscht wird.
• Jede Sequenz kann bei 0anstelle von beginnen 1. In diesem Fall sollte in der Sequenz "zweimal" das 0genau wie bei den anderen Zahlen wiederholt werden.
• Führende Nullen sind in der Reihenfolge "rückwärts" von Bedeutung. Zum Beispiel ist der zehnte Ausdruck 01; Weder sind 1noch 001akzeptabel.
• Wenn die beiden Sprachen unterschiedliche Zeichenkodierungen verwenden, wird das Programm durch seine Bytes und nicht durch seine Zeichen definiert. Das heißt, die Bytes sollten in beiden Sprachen gleich sein.
• Kürzester Code in Bytes gewinnt.

05AB1E / Jelly ,  14  13 Bytes

-1 Byte dank Adnan (Vermeiden Sie Triplicate mit nicht knallendem Druck)

Rohbytes (hexadezimal):

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

In 05AB1E ‚s Code-Seite :

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

Probieren Sie es online!

In Jelly ‚s Code-Seite :

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

Probieren Sie es online!

Wie?

Das Programm 05AB1E druckt die Doppelzählung mit jedem Eintrag, der durch Zeilenumbrüche getrennt ist:

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

Das Jelly- Programm gibt die umgekehrte Anzahl aus, wobei jeder Eintrag durch Zeilenumbrüche getrennt ist.

Der Parser behandelt ein gültiges Literal zwischen [und ]als das eingeschlossene Literal, andernfalls sind diese Bytes undefinierte Token und werden als solche zu Token, die den Code in Zeilen unterteilen. ==>Wird nicht als Literal analysiert, daher lautet der Code effektiv:

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

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

Python: Probieren Sie es online!

C: Probieren Sie es online!

Das L im Python-Code ist Teil des Begrenzers.

Erläuterung:

Im C-Code setzt es zuerst i auf 0. Dann startet es einen Kommentar ( #ist gültiger Code in C für #includeAnweisungen), wohin der Python-Code geht. Am Ende des Kommentars wird eine Funktion definiert, die eine Variable für immer inkrementiert und durch Leerzeichen getrennt zweimal ausgibt. Es beginnt dann ein Kommentar.

i=0;Setzt i im Python-Code auf Null. Python ignoriert die nächste Zeile, da #ein einzeiliger Kommentar beginnt. Dann wird es für immer inkrementiert, in eine lange Zahl umgewandelt und die umgekehrte Zeichenfolgendarstellung gedruckt. Das "L" vom langen ist ein Teil des Begrenzers. Danach wird eine mehrzeilige Zeichenfolge gestartet, um den C-Code zu kommentieren, der später endet.

-2 Bytes dank @LuisMendo. -7 Bytes dank @ZacharyT. -6 weitere Bytes dank @ZacharyT. +11 Bytes, um einen Fehler zu beheben, dank @ mbomb007. -7 Bytes dank @Doorknob. +1 Byte, um einen Fehler zu beheben, dank @Doorknob. -1 Byte danke an @yoann. -1 weiteres Byte dank @yoann. -3 Bytes dank @Cyoce.

Jelly / Pyth, 15 Bytes

.V1_`b;"1üÉÉ$

Nicht druckbare Dateien werden von der SE-Software entstellt. Hier ist ein Hexdump:

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

Führen Sie mit jelly f fileund pyth filejeweils.

Erläuterung

Zuerst kommt der Pyth-Teil. .VLäuft eine Endlosschleife über die inkrementierende Sequenz, beginnend mit ihrer Eingabe, die hier ist 1. Dann kehren wir _den stringified ( `) - Schleifenindex ( b) um ( ) und geben ihn implizit aus. Das ;ist da, um die Schleife zu beenden, und das "ist notwendig, um den Rest des Programms als String-Literal zu behandeln, damit der Parser nicht daran erstickt.

Der Jelly-Teil wird erklärt, indem zuerst der Rest des Programms von der Jelly-Codepage übersetzt wird:

¶1‘ṄṄ$¿

Das ¶fungiert als Zeilenvorschub und ignoriert den ersten Teil des Programms, indem es eine Verknüpfung herstellt, die niemals aufgerufen wird. Dann beginnen wir mit 1und führen eine while-Schleife ( ¿) aus, die ṄṄ$zweimal als Bedingung (print) verwendet und ‘den Wert als Schleifenkörper inkrementiert ( ).

Das Ersetzen des Pyth-Teils durch 1[DR,>] würde übrigens eine gültige Jelly / 05AB1E-Übermittlung in 14 Bytes erzeugen, aber der aktuelle Interpeter enthält einen Fehler , der dies verhindert.

Perl / JavaScript, 87 Bytes

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.$/))}

Ein Mechanismus ich eine Menge in JS / Perl Polyglotten verwendet habe , ist die Tatsache zu missbrauchen , dass die Substitution ziemlich jeden delimiter annehmen kann, unter Verwendung von =Mitteln I die anfänglichen sinnlosen Substitutionen kann (erstes Ersetzen 0;printmit console.log;meiner Flagge /sin $_, das derzeit undef) und dann $_auf das Ergebnis des Ersetzens sdurch sim Mehrzeilenmodus ( /m) einstellen , d. h 0. Jetzt $_ist 0und ich starte die whileSchleife, diese erhöht sich dann $_. Als nächstes rufe ich auf print, gebe einen regulären Ausdruck ein, der passt (weil ||am Ende ein leerer String passt) und benutze den &&Operator, um dann die Umkehrung der $_Verkettung mit einer neuen Zeile zu senden ($/ist vorinitialisiert auf "\n"). Das zählt bis unendlich rückwärts.

JavaScript

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

Viele Variablenzuweisungen hier, maskiert in den Perl- s///Aufrufen. Ich habe Variablen auf sund mwie 0alias console.logzu print, etwas sinnlos Division ausgeführt wird , stellen $_auf 0und beginnen whileSchleife Inkrementieren $_, rufen Sie printvorbei in 0( m/sdies den Aufruf beginnt min Perl, sondern als Standard Division in JS) behandelt und unser Ziel string ( $_+"\n"+$_) über den Komma-Operator, der das letzte Element in der Liste zurückgibt. Ich vermeide das letzte Stück Perl-Code ( &&reverse.$/), weil $_+"\n"+$_es der Wahrheit entspricht und ich damit ||ein RegExpObjekt erzeugen kann, das das Ende des Perl-Codes enthält, das niemals ausgewertet wird.

Getestet mit Perl 5 und Node 6.

NodeJS / PHP, 131 106 Bytes

-25 Bytes dank @Titus

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

Verwenden von NodeJS anstelle von Browser-JS für eine bessere Ausgabeformatierung und eine bessere Endlosschleifenbehandlung.

Probieren Sie das JavaScript online aus
Probieren Sie das PHP online aus

Beachten Sie, dass der TIO-Ausgang nach 128 KB abgeschnitten wird.

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

Probieren Sie es online! in V (geringfügig geändert, damit die Ausgabe beendet wird. In TIO wird V nur ausgegeben, wenn das Programm beendet wird.)

Probieren Sie es online! in Brain-Flak Classic

Dies ist nicht die interessanteste von Polyglots, da der V-Code keine Auswirkungen auf Brain-Flak-Klassiker hat und umgekehrt. Es macht jedoch wirklich Spaß, bei einer Herausforderung beide meiner eigenen Sprachen zu verwenden, und die beiden Lösungen sind ziemlich interessant alleine.

V Erklärung:

é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 Erklärung:

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

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

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

Retina | Python 2

R / Octave , 83 80 78 71 Bytes

-3 Bytes dank Luis Mendo

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

#{ }#ist ein Octave-Blockkommentar und ist #zufällig der Kommentar für R. Der R-Interpreter sieht nur die nächste Zeile als den Hauptteil der whileSchleife, und der Octave-Interpreter springt direkt vor dem Octave-Code

Der R-Teil gibt Zahlenpaare aus, die bei 1 beginnen, und der Oktavteil gibt die Rückwärtszahlen aus, die bei 0 beginnen.

Ich erwarte voll und ganz, dass ich überfordert bin (auch durch die gleiche Kombination von Sprachen); Ich habe kürzlich so viel Matlab- und R-Code geschrieben, dass ich dachte, ich würde es versuchen.

Probieren Sie es online! - Oktavverbindung

Ruby / Python2: 68 64 Bytes

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

Ruby Perspektive

einfaches Init der Variablen:

i = 0

"#{}"ist die Syntax für die String-Interpolation. Ich verwende es stattdessen, um einen Ausdruck auszuführen.

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

pist eine Abkürzung für puts. looperstellt eine Endlosschleife.

Weiter gibt es das execDing, aber es wird nie ausgewertet, da die Endlosschleife per Definition unendlich ist. Muss execkeinen Syntaxfehler mit Python-Code ergeben.

Python-Perspektive

Aus Sicht von Python gibt es eine gemeinsame i=0. Als nächstes hat Python eine andere Syntax für die String-Interpolation, sodass diese Zeile einfach verworfen wird. Als nächstes gibt es eine Endlosschleife, ähnlich wie bei anderen.

Bash / Check , 50 28 Bytes

^{Vielen Dank an @Doorknob für das Speichern einiger Bytes durch den Wechsel von Python zu Bash}

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

Zu Bash:

#>
#v
 #p<p<)#

Dies sind nur einige Kommentare, die ignoriert werden.

seq 1 inf|rev

Starten Sie eine Sequenz von 1 bis unendlich und leiten Sie das Ergebnis an weiter rev.

Überprüfen:

#>

Dies schaltet sofort nach rechts in den 2D-Modus. >Lenkt das IP-Recht, was keine Auswirkung hat. Es springt zum Zeilenanfang und schlägt #erneut zu, wodurch der 2D-Modus beendet wird. Es trifft dann >im 1D-Modus, der 0 auf den Stapel schiebt. Da es sich im 1D-Modus befindet, wird die IP in die nächste Zeile umgebrochen.

#v

#schaltet die IP wieder in den 2D-Modus und vlenkt sie nach unten.

 #p<p<)#

Der erste #schaltet wieder in den 1D-Modus zurück. pgibt den TOS als Zahl aus (ohne ihn zu platzieren) und <druckt dann eine neue Zeile. Dies geschieht zweimal und dann wird die Nummer mit erhöht ). #wechselt wieder in den 2D-Modus, sodass die IP an den Zeilenanfang springt, trifft #, um in den 1D-Modus zu wechseln, usw.

CJam /> <>, 27 23 Bytes

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

An CJam:

Probieren Sie es online! - Beachten Sie, dass Sie bis zur 60-Sekunden-Grenze warten müssen, um die Ausgabe zu sehen, diese jedoch offline funktioniert.

"la,:naonao
"

Dies definiert ein mehrzeiliges String-Literal, das niemals verwendet wird.

 1{_sW%n)}h

Die zweite Zeile lautet wie folgt:

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

An> <>:

"

Beginnt ein String-Literal.

 la,:naonao

Inhalt des String-Literal. Jeder der Zeichencodes wird einzeln auf den Stapel geschoben.

"

Die IP wickelt sich um, um "wieder zu erreichen , was den String-Modus beendet.

 la,

lNimmt die Länge des Stapels, adrückt 10 und ,teilt. Dies gibt uns die Länge des Stapels / 10.

    :nao

:dupliziert, ndruckt als Zahl, adrückt 10 und odruckt als Zeichencode (eine neue Zeile).

        nao

Gleiche Sache. Geben Sie die Nummer gefolgt von einer neuen Zeile ein. Der Stack hat jetzt wieder die Länge 10 (der Inhalt des ursprünglichen String-Literal befindet sich auf dem Stack).

Die IP wandelt sich dann "wieder um, was dazu führt, dass 10 weitere Elemente gepusht werden müssen. Beim nächsten Mal wird l20 zurückgegeben, sodass 2 gedruckt wird usw.

Die zweite Zeile wird von der IP nie berührt.

Röda / C (gcc) , 90 Bytes

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

Röda: Online ausprobieren!

C: Probieren Sie es online!

Erläuterung

Dies missbraucht die Tatsache, dass //es sich bei Röda um eine int-Spaltung handelt, bei C jedoch um einen Zeilenkommentar.

main(){}Bezeichnet in beiden Sprachen das Hauptprogramm und ruft beide Funktionen fmit einem Dummy-Argument von auf 0.

In Röda a=1//1macht Int Division und ordnet das Ergebnis 1zu a. C sieht a=1und tut dasselbe, aber alles nach dieser Zuordnung ist ein Kommentar für C. Von dort zweigen die beiden Sprachen ab.

Röda

Wir haben eine Endlosschleife mit while[]( eine leere Bedingung ist wahr ). Innerhalb daß, ` $a`wandelt die ganze Zahl ain eine Zeichenfolge (mit einem führenden Raum) , nach der [::-1]es umkehrt (und gibt sie mit einem Leerzeichen). Dann wird der Wert von aum eins erhöht.

Außerhalb der while-Schleife beginnt /*und endet ein mehrzeiliger Kommentar kurz vor dem Ende der Funktion.

C

Nachdem der Rest der Zeile ignoriert wurde, wechselt das Programm in die zweite Zeile. Wir beginnen mit einem Semikolon, da die a=1Anweisung beendet werden muss. Danach stoßen wir auf eine einfache for-Schleife, die die iterierende Variable azweimal bei jeder Iteration ausgibt.

Außerhalb der for-Schleife können Sie den /*Endkommentar von Röda einfach ignorieren */.

QBIC / QBasic 4.5 , 58 Byte

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

Dies missbraucht in hohem Maße die Tatsache, dass alle Kleinbuchstaben vom QBIC-Interpreter als wörtlicher QBasic-Code angesehen und daher nur an die QBasic-Schicht von QBIC weitergeleitet werden. So sehen beide Sprachen diesen Code nebeneinander:

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 Bytes

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

Zum ersten Mal Golf spielen, also ist es etwas größer, als es wahrscheinlich sein könnte. Ich wollte> <> verwenden, aber da einige Leute es bereits zum Erstellen der zweiten Sequenz verwendeten, beschloss ich, das Erstellen der ersten Sequenz zu probieren.

Versuchen Sie> <> online!
Für laserLANG wird ein Offline-Interpreter benötigt, um es auszuprobieren. Es kann hier gefunden werden .

laserLANG

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

Ausführung beginnt, bei !der vollständig ignoriert wird. Es erreicht dann die \und beginnt, an mehreren Zeichen vorbeizufahren, die es vollständig ignoriert. Endlich kommt es zu einem anderen \und der Spaß beginnt. Ich habe im Grunde genommen die Idee hinter dem "Hallo, Welt!" Schleife und verdichtete es so gut ich konnte. Es war eine Herausforderung, sich mit der Tatsache auseinanderzusetzen, dass laserLANG den Speicherzähler nur dekrementieren / inkrementieren will, wenn der Programmzähler nach links / rechts läuft. Ich habe das Gefühl, dass die meisten Bytes hier durch einige Tricks gespeichert werden könnten, an die ich nicht gedacht habe.

> <>

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

Die Ausführung beginnt, !wodurch der Befehl übersprungen wird \. Dann geht es weiter, als ob der laserLANG-Code nicht da wäre. Mir war nicht klar, dass> <> nur die Float-Division unterstützt, daher war ein kurzes und einfaches Abschneiden zunächst etwas verwirrend.

Befunge-98 / > <> , 32 Bytes

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

Schrieb dies, bevor ich sah, wie viele ><>Antworten es gab. Hintergrund: \Ist ein Richtungsänderungsoperator in> <>, der es in diesem Fall nach unten drückt, während er in Befunge die beiden obersten Elemente auf dem Stapel vertauscht. Der Befunge-Code sieht folgendermaßen aus:

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

Probieren Sie es online!

Gibt die durch Zeilenumbrüche getrennten Rückwärtszahlen aus. Befunge druckt nach jeder Zahl automatisch ein Leerzeichen, sodass jede Ziffer durch Leerzeichen getrennt ist. Ruft wiederholt die letzte Ziffer ab, druckt sie aus und teilt die Zahl durch 10, bis sie 0 ist. Dann inkrementieren und wiederholen.

Der Code> <> wechselt sofort in die zweite Zeile.

>l::naonao

Probieren Sie es online!

Und ist ziemlich einfach. Holen Sie sich die Länge des Stapels, drucken Sie zweimal mit Zeilenumbrüchen und belassen Sie eine Kopie der Länge auf dem Stapel für die nächste Schleife.

Ruby / Stacked , 37 Bytes

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

Probieren Sie es online!

Dies druckt 1 1 2 2... in Ruby und 1 2 3 ... 01 11 21...in Stacked.

Erläuterung

In Ruby:

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

Nach dem Entfernen des Kommentars wird dies:

0
loop{p p$.+=1}

Die einzig relevante Zeile ist hier die letzte. pGibt sein Argument zurück, p pdruckt es also zweimal aus. $.beginnt bei 0, $.+=1erhöht sich also $.und gibt den erhöhten Wert zurück. Daher druckt dies jede Zahl 1zweimal aus.

In gestapelten:

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

Dies entspricht den folgenden Token:

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

Die ersten beiden sind nicht relevant (Umwandlung 0in eine Reduktionsfunktion). Dann 0wird auf den Stapel geschoben. Danach wird die Funktion [1+:tostr rev out]auf den Stapel geschoben. loopöffnet diese Funktion und führt sie unbegrenzt aus.

Das Innere der Funktion erhöht den oberen Rand des Stapels ( 1+), dupliziert ihn ( :), konvertiert ihn in einen String ( tostr), kehrt ihn um ( rev) und gibt ihn aus ( out). Dieser Vorgang wird unendlich oft wiederholt. Da die Schleife unendlich ist, wird alles, was nach diesem Token kommt, vom Interpreter im Wesentlichen ignoriert.

> <> / Jelly , 37 Bytes (25 in Jellys Codepage)

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

Versuchen Sie> <> online!

Probieren Sie Jelly online aus!

> <> druckt die Sequenz zweimal bis unendlich, Jelly zählt rückwärts.

> <> befasst sich nur mit der obersten Zeile:

Und danke an @ Challenger5 für das Speichern einiger Bytes hier im Zeilenvorschub

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 führt seinen Code von unten nach oben aus. Nur die letzten beiden Zeilen sind relevant.

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

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

Gibt die doppelte Sequenz in C und die umgekehrte Sequenz in PHP aus.

Probieren Sie es in C!

Probieren Sie es in PHP!

Erklärungen

C

In C das #Formular-Präprozessor-Zeug. Ich weiß nicht viel über C, aber es beklagt sich nicht, wenn es für dieses Zeug eine leere Zeile gibt. Das //bildet einen Zeilenkommentar. Ein \am Ende einer Zeile bedeutet im Wesentlichen, die neue Zeile zu "maskieren" und die beiden Zeilen als eine zu behandeln. Dies funktioniert auch für Zeilenkommentare, sodass die zweite Zeile als Kommentar in C angesehen wird. In der dritten Zeile werden die Zahlen mit einer einfachen for-Schleife ausgegeben. Danach gibt es einfach einen Kommentar.

PHP

Bildet in PHP #einen Zeilenkommentar, sodass die erste Zeile vollständig ignoriert wird. Die zweite Zeile gibt die mit einer for-Schleife umgekehrten Zahlen aus und trennt sie mit \nint main(i){for(;;i++)printf("%d %d ",i,i);}//(dem in eine Zeichenfolge eingeschlossenen C-Code).