Come è noto ,

Chuck Norris contava all'infinito. Due volte

Inoltre ,

Chuck Norris può contare all'infinito all'indietro.

Inoltre, anche se forse meno conosciuto, Chuck Norris può parlare un po 'di spagnolo oltre all'inglese.

La sfida

Scrivi un programma (o una funzione) che può essere eseguito in due lingue diverse. In una lingua il programma dovrebbe generare la sequenza

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

e nell'altra lingua dovrebbe produrre la sequenza (inclusi gli zeri iniziali)

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

Regole

• Programmi o funzioni sono consentiti, in qualsiasi linguaggio di programmazione . Sono vietate le scappatoie standard .
• Versioni diverse della stessa lingua (come Python 2/3) non contano come lingue diverse. Le lingue correlate (come C / C ++ o Matlab / Octave) contano come diverse.
• Nessun input verrà preso.
• Il programma dovrebbe continuare a emettere i termini della sequenza fino a quando non viene interrotto dall'utente. Poiché il programma non si arresterà da solo, alla fine non sarà possibile produrre output. Deve essere prodotto mentre il programma è in esecuzione, in modo continuo o in batch.
• L'output può utilizzare STDOUT o equivalente o può essere visualizzato in una finestra grafica. È consentito qualsiasi separatore non numerico tra termini di sequenza, purché ogni termine possa essere chiaramente distinto dai termini adiacenti. È anche accettabile se lo schermo viene cancellato tra i termini.
• Entrambe le sequenze possono iniziare 0invece di 1. In tal caso, nella sequenza "due volte" 0dovrebbe essere ripetuto, proprio come gli altri numeri.
• Gli zeri iniziali sono significativi nella sequenza "indietro". Ad esempio, il decimo termine è 01; né 1né 001sono accettabili.
• Se le due lingue usano codifiche di caratteri diverse, il programma è definito dai suoi byte , non dai suoi caratteri. Cioè, i byte dovrebbero essere gli stessi nelle due lingue.
• Vince il codice più breve in byte.

05AB1E / Jelly ,  14  13 byte

-1 byte grazie ad Adnan (evita di triplicare con la stampa non popping)

Byte non elaborati (esadecimali):

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

In 05AB1E 's code-page :

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

Provalo online!

In Jelly 's code-page :

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

Provalo online!

Come?

Il programma 05AB1E stampa il doppio conteggio con ogni voce separata da newline:

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

Il programma Jelly stampa il conteggio inverso con ogni voce separata da newline.

Il parser tratterà un valore letterale valido tra [e ]come valore letterale racchiuso, altrimenti questi byte sono token indefiniti e come tali diventano equivalenti ai token che separano il codice in righe. ==>non analizza come letterale, quindi il codice è effettivamente:

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 byte

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

Python: provalo online!

C: Provalo online!

La L nel codice Python fa parte del delimitatore.

Spiegazione:

Nel codice C, imposta prima i su 0. Quindi, inizia un commento ( #è un codice valido in C per le #includeistruzioni) dove va il codice Python. Alla fine del commento, definisce una funzione che incrementa per sempre una variabile e la stampa due volte, delimitata da spazi. Quindi inizia un commento.

Nel codice Python, i=0;imposta i su zero. Python ignora la riga successiva perché #avvia un commento a riga singola. Quindi lo incrementa per sempre e lo trasforma in un numero lungo e stampa la sua rappresentazione di stringa invertita. La "L" dal lungo fa parte del delimitatore. Successivamente, avvia una stringa multilinea per commentare il codice C, che termina in seguito.

-2 byte grazie a @LuisMendo. -7 byte grazie a @ZacharyT. -6 più byte grazie a @ZacharyT. +11 byte per correggere un bug grazie a @ mbomb007. -7 byte grazie a @Doorknob. +1 byte per correggere un bug grazie a @Doorknob. -1 byte grazie a @yoann. -1 byte in più grazie a @yoann. -3 byte grazie a @Cyoce.

Jelly / Pyth, 15 byte

.V1_`b;"1üÉÉ$

Gli stampabili non sono manipolati dal software SE, quindi ecco un hexdump:

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

Esegui con jelly f filee pyth filerispettivamente.

Spiegazione

Prima arriva la parte Pyth. .Vesegue un ciclo infinito sulla sequenza incrementale a partire dal suo input, che è qui 1. Quindi invertiamo ( _) l' `indice di ciclo stringified ( ) ( b) e lo produciamo implicitamente. L' ;è lì per terminare il ciclo, e il "è necessario trattare il resto del programma come una stringa letterale in modo che il parser non soffocare su di esso.

La parte Jelly verrà spiegata traducendo prima il resto del programma dalla tabella codici Jelly:

¶1‘ṄṄ$¿

La ¶agisce come un avanzamento di riga, ignorando efficacemente la prima parte del programma, rendendo un collegamento che non viene mai chiamato. Quindi iniziamo da 1ed eseguiamo un ciclo while ( ¿) che utilizza ṄṄ$(stampa due volte) come condizione e incrementa ( ‘) il valore come corpo del ciclo.

Per inciso, sostituendo la parte Pyth con 1[DR,>] sarebbe creare un valido mezzo gelatina / 05AB1E a 14 byte, ma l'interpeter corrente contiene un errore che impedisce questo.

Perl / JavaScript, 87 byte

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

Un meccanismo che ho usato molto in poliglotti JS / Perl è quello di abusare del fatto che la sostituzione può accettare praticamente qualsiasi delimitatore, utilizzando =mezzi posso usare le sostituzioni inutili iniziali (prima sostituzione 0;printcon console.log;mcon una bandiera di /sa $_, che è attualmente undef) , quindi impostando $_il risultato della sostituzione scon sin modalità multilinea ( /m), ovvero 0. Ora $_è 0e inizio il whileciclo, questo poi aumenta $_. Successivamente chiamo print, passando un'espressione regolare che corrisponde (dovuta alla ||fine che corrisponde a una stringa vuota) e utilizzo l' &&operatore per inviare il retro di $_concatenato con una nuova riga ($/è pre-inizializzato a "\n"). Questo conta all'infinito all'indietro.

JavaScript

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

Molte assegnazioni di variabili qui, mascherate nelle s///chiamate Perl . Ho messo su variabili se mcome 0, alias console.loga print, corro qualche divisione inutile, insieme $_al 0e iniziare il whileciclo di incremento $_, chiamata printpassando 0( m/s, questo inizia la chiamata a min Perl, ma viene trattato come divisione standard JS) e la nostra stringa di destinazione ( $_+"\n"+$_) tramite l'operatore virgola, che restituisce l'ultimo elemento nell'elenco. Evito l'ultimo pezzo del codice Perl ( &&reverse.$/) perché $_+"\n"+$_sarà veritiero e quindi posso usare ||per produrre un RegExpoggetto contenente la fine del codice Perl che non viene mai valutato.

Testato utilizzando Perl 5 e Nodo 6.

NodoJS / PHP, 131 106 byte

-25 byte grazie a @Titus

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

Utilizzo di NodeJS anziché del browser JS per una migliore formattazione dell'output e una migliore gestione dei loop infiniti.

Prova il JavaScript online
Prova il PHP online

Si noti che l'uscita TIO viene interrotta dopo 128 KB.

V / Brain-flak Classic , 27 , 26 byte

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

hexdump:

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

Provalo online! in V (modificato leggermente in modo da terminare in modo da poter vedere l'output. Su TIO, V viene emesso solo se il programma termina)

Provalo online! in Brain-flak Classic

Questo non è il più interessante dei poliglotti, dal momento che il codice V non ha alcun effetto sul classico brain-flak e viceversa, tuttavia è davvero divertente usare entrambi i miei linguaggi su una sfida, e le due soluzioni sono piuttosto interessanti da soli.

V Spiegazione:

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

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

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

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

Retina | Python 2

R / Ottava , 83 80 78 71 byte

-3 byte grazie a Luis Mendo

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

#{ }#è un commento a blocchi di Ottava e #proprio per questo è il commento di R. L'interprete R vede solo la riga successiva come il corpo del whileloop e l'interprete Octave salta proprio davanti al codice Octave

La parte R stampa coppie di numeri che iniziano da 1 e la parte Octave stampa i numeri all'indietro che iniziano da 0.

Mi aspetto pienamente di essere superato (anche con la stessa combinazione di lingue); Ho appena scritto così tanto codice Matlab e R di recente che ho pensato di provarlo.

Provalo online! - Collegamento all'ottava

Ruby / Python2: 68 64 byte

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

Prospettiva rubino

semplice init di variabile:

i = 0

"#{}"è la sintassi per l'interpolazione di stringhe. Lo uso invece per exec expression.

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

pè una scorciatoia per puts. loopcrea un ciclo infinito.

Successivamente c'è la execcosa, ma non viene mai valutata, poiché il ciclo infinito è per definizione infinito. Necessario execnon produrre errore di sintassi con il codice Python.

Prospettiva Python

Dal punto di vista di Python, c'è un comune i=0. Successivamente, Python ha una sintassi diversa per l'interpolazione delle stringhe, quindi questa riga viene semplicemente scartata. Successivamente c'è un ciclo infinito simile a quello pubblicato dagli altri.

Bash / Check , 50 28 byte

^{Grazie a @Doorknob per aver salvato un sacco di byte passando da Python a Bash}

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

Colpire:

#>
#v
 #p<p<)#

Questi sono solo alcuni commenti, che vengono ignorati.

seq 1 inf|rev

Inizia una sequenza che va da 1 a infinito, quindi reindirizza il risultato a rev.

Controllare:

#>

Questo passa immediatamente alla modalità 2D, andando a destra. >dirige l'IP right, che non ha alcun effetto. Si avvolge all'inizio della linea e colpisce di #nuovo, il che passa dalla modalità 2D. Quindi colpisce >in modalità 1D, che spinge 0 nello stack. Poiché è in modalità 1D, l'IP passa alla riga successiva.

#v

#commuta nuovamente l'IP in modalità 2D e lo vdirige verso il basso.

 #p<p<)#

Il primo #torna di nuovo alla modalità 1D. pgenera il TOS come numero (ma non lo pop), quindi <stampa una nuova riga. Questo viene fatto due volte, quindi il numero viene incrementato con ). #passa di nuovo alla modalità 2D, quindi l'IP si sposta all'inizio della riga, preme #per passare alla modalità 1D, ecc.

CJam /> <>, 27 23 byte

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

Per CJam:

Provalo online! - nota che devi aspettare fino al limite di 60 secondi per vedere l'output, ma funziona offline.

"la,:naonao
"

Questo definisce un valore letterale a più righe che non viene mai utilizzato.

 1{_sW%n)}h

La seconda riga va così:

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

A> <>:

"

Inizia una stringa letterale.

 la,:naonao

Contenuto della stringa letterale. Ciascuno dei codici carattere viene inserito individualmente nello stack.

"

L'IP si avvolge per raggiungere di "nuovo, il che termina la modalità stringa.

 la,

lprende la lunghezza della pila, aspinge 10 e si ,divide. Questo ci dà la lunghezza della pila / 10.

    :nao

:duplica, nstampa come un numero, aspinge 10 e ostampa come un codice carattere (una nuova riga).

        nao

Stessa cosa. Stampa il numero seguito da una nuova riga. Lo stack ora ha di nuovo la lunghezza 10 (il contenuto del letterale stringa originale è nello stack).

L'IP quindi si avvolge di "nuovo, portando ad altri 10 elementi da spingere. La prossima volta,l restituisce 20, quindi viene stampato 2, ecc.

La seconda riga non viene mai toccata dall'IP.

Röda / C (gcc) , 90 byte

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

Röda: provalo online!

C: Provalo online!

Spiegazione

Ciò abusa del fatto che //è divison in Röda ma un commento di riga in C.

In entrambe le lingue, main(){}indica il programma principale ed entrambi chiamano funzione fcon un argomento fittizio di 0.

In Röda, a=1//1esegue la divisione int e assegna il risultato 1a a. C vedea=1 e fa la stessa cosa, ma tutto dopo quell'assegnazione è un commento per C. Da lì, le due lingue si diramano.

Röda

Abbiamo un ciclo infinito con while[]( una condizione vuota è verità ). Al suo interno, ` $a`converte l'intero ain una stringa (con uno spazio iniziale) dopo di che lo [::-1]inverte (e viene emesso con uno spazio finale). Quindi il valore di aviene incrementato di uno.

Al di fuori del ciclo while, un commento su più righe inizia /*e termina poco prima della fine della funzione.

C

Dopo aver ignorato il resto della riga, il programma passa alla seconda riga. Iniziamo con un punto e virgola perché l' a=1istruzione deve essere terminata. Successivamente, incontriamo un semplice ciclo per che stampa la variabile iterante,a , due volte per ogni iterazione.

Al di fuori del ciclo for, /*è lì solo per ignorare il */commento finale di Röda .

QBIC / QBasic 4.5 , 58 byte

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

Ciò abusa gravemente del fatto che tutte le lettere minuscole sono viste come un codice QBasic letterale dall'interprete QBIC e sono quindi passate allo strato QBasic di QBIC. Come entrambe le lingue vedono questo codice, fianco a fianco:

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 byte

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

Giocare a golf per la prima volta, quindi è un po 'più grande di quanto potrebbe essere. Volevo usare> <>, ma poiché alcune persone l'hanno già usato per creare la seconda sequenza, ho deciso di provare a creare la prima sequenza.

Prova> <> online!
Per laserLANG, è necessario un interprete offline per provarlo. Può essere trovato qui .

laserLANG

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

l'esecuzione inizia alla !quale viene completamente ignorata. poi raggiunge il \e inizia a viaggiare oltre diversi personaggi che ignora completamente. Finalmente ne raggiunge un altro \e inizia il divertimento. Praticamente ho preso l'idea dietro il "Ciao, mondo!" loop e condensato nel miglior modo possibile. È stato un po 'una sfida affrontare il fatto che laserLANG sta per decrementare / incrementare il contatore di memoria quando il contatore del programma sta andando rispettivamente a sinistra / a destra. Sento che la maggior parte dei byte potrebbe essere salvata qui facendo alcuni trucchi a cui non ho pensato.

> <>

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

L'esecuzione inizia da !quale causa salta il \. Quindi continua come se il codice laserLANG non fosse presente. Non avevo realizzato che <> aveva solo il supporto per la divisione float, quindi un troncamento breve e semplice all'inizio era un po 'confuso.

Befunge-98 / > <> , 32 byte

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

Ho scritto questo prima che vedessi quante ><>risposte ci fossero. Alcuni retroscena: \è un operatore che cambia direzione in> <>, in questo caso lo spinge verso il basso, mentre in Befunge scambia i primi due oggetti in pila. Il codice Befunge è simile a:

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

Provalo online!

Stampa i numeri all'indietro separati da nuove righe. Befunge stampa automaticamente uno spazio dopo ogni numero, quindi ogni cifra è separata da spazi. Riceve ripetutamente l'ultima cifra, la stampa e divide il numero per 10 fino a quando non è 0. Quindi incrementare e ripetere.

Il codice> <> scende immediatamente alla seconda riga.

>l::naonao

Provalo online!

Ed è piuttosto semplice. Ottieni la lunghezza della pila, stampa due volte con le nuove righe e lascia una copia della lunghezza nella pila per il ciclo successivo.

Rubino / Stacked , 37 byte

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

Provalo online!

Questo stampa 1 1 2 2 ... in Ruby e 1 2 3 ... 01 11 21...in Stacked.

Spiegazione

In Ruby:

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

Dopo aver rimosso il commento, questo diventa:

0
loop{p p$.+=1}

L'unica linea rilevante qui è l'ultima. prestituisce il suo argomento, quindi p pstampa il suo argomento due volte. $.inizia da 0, quindi $.+=1incrementi $., restituendo il valore incrementato. Pertanto, questo stampa ogni numero da1 due volte.

In pila:

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

Ciò equivale ai seguenti token:

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

I primi due non sono rilevanti (fondamentalmente, trasformandosi 0in una Unzione ridotta). Quindi, 0viene inserito nello stack. Successivamente, la funzione [1+:tostr rev out]viene spostata nello stack.loopapre questa funzione e la esegue all'infinito.

L'interno della funzione incrementa la parte superiore dello stack ( 1+), la duplica ( :), la converte in una stringa ( tostr), la inverte ( rev) e la genera ( out). Questo processo si ripete all'infinito. Poiché il ciclo è infinito, tutto ciò che segue quel token viene sostanzialmente ignorato dall'interprete.

> <> / Jelly , 37 byte (25 nella tabella codici di Jelly)

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

Prova> <> online!

Prova Jelly online!

> <> stampa la sequenza all'infinito due volte, Jelly conta all'indietro.

> <> riguarda solo la riga superiore:

E grazie a @ Challenger5 per aver salvato alcuni byte qui sul feed di linea

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 esegue il suo codice dal basso verso l'alto. Sono rilevanti solo le ultime 2 righe.

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

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

Emette la doppia sequenza in C e la sequenza inversa in PHP.

Provalo in C!

Provalo in PHP!

spiegazioni

C

In C, la #roba del preprocessore delle forme. Non so molto di C ma non mi lamento quando c'è una linea vuota per questa roba. Si //forma un commento di linea. UN\ alla fine di una linea sta essenzialmente "sfuggendo" alla nuova linea e facendo in modo che le due linee vengano trattate come una sola. Questo funziona anche per i commenti di linea, quindi la seconda riga è vista come un commento in C. La terza riga fa il lavoro di emettere i numeri con un semplice ciclo per. Successivamente, c'è semplicemente un commento.

PHP

In PHP, #forma un commento di riga, quindi la prima riga viene completamente ignorata. La seconda riga stampa i numeri invertiti con un ciclo for e li separa con\nint main(i){for(;;i++)printf("%d %d ",i,i);}// (il codice C racchiuso in una stringa).