Como es bien sabido ,

Chuck Norris contó hasta el infinito. Dos veces

Además ,

Chuck Norris puede contar hasta el infinito al revés.

Además, aunque quizás sea menos conocido, Chuck Norris puede hablar un poco de español además del inglés.

El reto

Escriba un programa (o función) que se pueda ejecutar en dos idiomas diferentes. En un idioma, el programa debería generar la secuencia

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

y en el otro idioma debe producir la secuencia (incluidos los ceros a la izquierda)

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

Reglas

• Se permiten programas o funciones , en cualquier lenguaje de programación . Las lagunas estándar están prohibidas.
• Las diferentes versiones del mismo idioma (como Python 2/3) no cuentan como idiomas diferentes. Los lenguajes relacionados (como C / C ++ o Matlab / Octave) cuentan como diferentes.
• No se tomará ninguna entrada.
• El programa debe continuar emitiendo términos de la secuencia hasta que el usuario lo detenga. Como el programa no se detendrá solo, la salida no se puede producir al final. Debe producirse mientras se ejecuta el programa, ya sea de forma continua o en lotes.
• La salida puede usar STDOUT o equivalente, o puede mostrarse en una ventana gráfica. Se permite cualquier separador no numérico entre términos de secuencia, siempre que cada término pueda distinguirse claramente de sus términos vecinos. También es aceptable si la pantalla se borra entre los términos.
• Cualquiera de las secuencias puede comenzar en 0lugar de 1. En ese caso, en la secuencia "dos veces" se 0debe repetir, al igual que los otros números.
• Los ceros iniciales son significativos en la secuencia "hacia atrás". Por ejemplo, el décimo término es 01; Ni 1ni 001son aceptables.
• Si los dos idiomas usan codificaciones de caracteres diferentes, el programa se define por sus bytes , no por sus caracteres. Es decir, los bytes deben ser los mismos en los dos idiomas.
• El código más corto en bytes gana.

05AB1E / Jelly ,  14  13 bytes

-1 byte gracias a Adnan (evite triplicar con una impresión no emergente)

Bytes sin formato (hexadecimal):

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

En la página de códigos de 05AB1E :

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

Pruébalo en línea!

En la página de códigos de Jelly :

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

Pruébalo en línea!

¿Cómo?

El programa 05AB1E imprime la cuenta doble con cada entrada separada por líneas nuevas:

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

El programa Jelly imprime el recuento inverso con cada entrada separada por nuevas líneas.

El analizador tratará un literal válido entre [y ]como el literal adjunto, de lo contrario, estos bytes son tokens indefinidos y, como tales, se convierten en tokens que separan el código en líneas. ==>no se analiza como un literal, por lo que el código es efectivamente:

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 (sonido metálico) , 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: ¡ Pruébalo en línea!

C: ¡ Pruébelo en línea!

La L en el código de Python es parte del delimitador.

Explicación:

En el código C, primero establece i en 0. Luego, comienza un comentario ( #es un código válido en C para las #includedeclaraciones) donde va el código Python. Al final del comentario, define una función que incrementa para siempre una variable y la imprime dos veces, delimitada por espacios. Entonces comienza un comentario.

En el código de Python, i=0;establece i en cero. Python ignora la siguiente línea porque #comienza un comentario de una sola línea. Luego lo incrementa para siempre y lo convierte en un número largo e imprime su representación de cadena invertida. La 'L' del largo es parte del delimitador. Después de eso, comienza una cadena de varias líneas para comentar el código C, que termina más tarde.

-2 bytes gracias a @LuisMendo. -7 bytes gracias a @ZacharyT. -6 bytes más gracias a @ZacharyT. +11 bytes para corregir un error gracias a @ mbomb007. -7 bytes gracias a @Doorknob. +1 byte para corregir un error gracias a @Doorknob. -1 byte gracias a @yoann. -1 byte más gracias a @yoann. -3 bytes gracias a @Cyoce.

Jalea / Pyth, 15 bytes

.V1_`b;"1üÉÉ$

El software SE destruye las no imprimibles, así que aquí hay un hexdump:

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

Ejecutar con jelly f filey pyth filerespectivamente.

Explicación

Primero viene la parte Pyth. .Vejecuta un bucle infinito sobre la secuencia incremental a partir de su entrada, que está aquí 1. Luego _revertimos ( `) el índice de bucle stringified ( ) ( b) y lo sacamos implícitamente. El ;está allí para finalizar el ciclo, y "es necesario para tratar el resto del programa como un literal de cadena para que el analizador no se atragante.

La parte de Jelly se explicará traduciendo primero el resto del programa desde la página de códigos de Jelly:

¶1‘ṄṄ$¿

El ¶actúa como un avance de línea, haciendo caso omiso de manera efectiva la primera parte del programa por lo que es un vínculo que nunca se llama. Luego comenzamos en 1y ejecutamos un bucle while ( ¿) que usa ṄṄ$(imprimir dos veces) como su condición, e incrementa ( ‘) el valor como el cuerpo del bucle.

Por cierto, en sustitución de la parte Pyth con 1[DR,>] sería crear una presentación jalea / 05AB1E válido en 14 bytes, pero el interpeter actual contiene un error que impide esto.

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

Un mecanismo que he usado mucho en políglotas JS / Perl es abusar del hecho de que la sustitución puede aceptar casi cualquier delimitador, el uso de =medios puedo utilizar las sustituciones insustanciales iniciales (primera sustitución 0;printcon console.log;muna bandera de /sen $_, que se encuentra actualmente undef) , a continuación, establecer $_para el resultado de reemplazar scon sen modo multilínea ( /m), que es 0. Ahora $_es 0y comienzo el whileciclo, esto luego se incrementa $_. A continuación, llamo print, pasando una expresión regular que coincide (debido al ||final que coincide con una cadena vacía) y uso el &&operador para luego enviar el reverso de $_concatenado con una nueva línea ($/está preinicializado a "\n"). Esto cuenta hasta el infinito al revés.

JavaScript

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

Muchas asignaciones variables aquí, enmascaradas en las s///llamadas de Perl . He definido las variables sy mque 0, alias console.loga print, corro alguna división sin sentido, conjunto $_a 0e iniciar el whilebucle de incremento $_, la llamada printpasa en 0( m/s, esto comienza la llamada a men Perl, pero es tratada como la división estándar en JS) y nuestra cadena de destino ( $_+"\n"+$_) a través del operador de coma, que devuelve el último elemento de la lista. Evito la última parte del código Perl ( &&reverse.$/) porque $_+"\n"+$_será veraz y, por lo tanto, puedo usar ||para producir un RegExpobjeto que contenga el final del código Perl que nunca se evalúa.

Probado con Perl 5 y Nodo 6.

Nodejs / PHP, 131 106 bytes

-25 bytes gracias a @Titus

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

Usar NodeJS en lugar del navegador JS para un mejor formato de salida y un mejor manejo de bucle infinito

Pruebe el JavaScript en línea
Pruebe el PHP en línea

Tenga en cuenta que la salida TIO se corta después de 128 KB.

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

Pruébalo en línea! en V (modificado ligeramente para que termine de modo que pueda ver la salida. En TIO, V solo sale si el programa termina)

Pruébalo en línea! en Brain-flak Classic

Este no es el más interesante de los políglotas, ya que el código V no tiene ningún efecto en el clásico Brain-Flak, y viceversa, sin embargo, es muy divertido usar mis dos idiomas en un desafío, y las dos soluciones son bastante interesantes. en su propia.

V Explicación:

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

Explicación de 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 bytes

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

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

Retina | Python 2

R / Octava , 83 80 78 71 bytes

-3 bytes gracias a Luis Mendo

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

#{ }#es un comentario de bloque de octava y #resulta ser el comentario de R. El intérprete R solo ve la siguiente línea como el cuerpo del whilebucle, y el intérprete de octava salta directamente al código de octava

La parte R imprime pares de números que comienzan en 1, y la parte de octava imprime los números hacia atrás que comienzan en 0.

Espero ser superado (incluso por la misma combinación de idiomas); Acabo de escribir tanto código Matlab y R recientemente que pensé en intentarlo.

Pruébalo en línea! - Enlace de octava

Ruby / Python2: 68 64 bytes

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

Perspectiva de rubí

inicio simple de variable:

i = 0

"#{}"es la sintaxis para la interpolación de cadenas. Lo uso para exec expresión en su lugar.

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

pes una abreviatura de puts. loopcrea un bucle infinito.

Luego está la execcosa, pero nunca se evalúa, ya que el bucle infinito es infinito por definición. execNo es necesario que produzca un error de sintaxis con el código Python.

Perspectiva Python

Desde la perspectiva de Python, hay un común i=0. A continuación, Python tiene una sintaxis diferente para la interpolación de cadenas, por lo que esta línea simplemente se descarta. A continuación hay un bucle infinito similar a lo que otros publicaron.

Bash / Check , 50 28 bytes

^{Gracias a @Doorknob por guardar un montón de bytes al cambiar de Python a Bash}

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

Para golpear:

#>
#v
 #p<p<)#

Estos son solo algunos comentarios, que se ignoran.

seq 1 inf|rev

Comience una secuencia que va del 1 al infinito, luego canalice el resultado a rev.

Verificar, checar, comprobar:

#>

Esto cambia inmediatamente al modo 2D, yendo hacia la derecha. >dirige el derecho de propiedad intelectual, que no tiene ningún efecto. Se ajusta al comienzo de la línea y golpea# vuelve a , lo que cambia del modo 2D. Luego golpea >en modo 1D, que empuja 0 a la pila. Debido a que está en modo 1D, la IP pasa a la siguiente línea.

#v

# cambia la IP al modo 2D nuevamente y v dirige hacia abajo.

 #p<p<)#

El primero #vuelve al modo 1D nuevamente. pgenera el TOS como un número (pero no lo muestra) y luego <imprime una nueva línea. Esto se hace dos veces, y luego el número se incrementa con ). #cambia al modo 2D nuevamente, por lo que la IP se ajusta al comienzo de la línea, pulsa #para cambiar al modo 1D, etc.

CJam /> <>, 27 23 bytes

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

A CJam:

Pruébalo en línea! - tenga en cuenta que tiene que esperar hasta el límite de 60 segundos para ver la salida, pero funciona sin conexión.

"la,:naonao
"

Esto define un literal de cadena de varias líneas que nunca se usa.

 1{_sW%n)}h

La segunda línea es así:

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

Para> <>:

"

Comienza una cadena literal.

 la,:naonao

Contenido de la cadena literal. Cada uno de los códigos de caracteres se empuja individualmente a la pila.

"

La IP se ajusta para alcanzar "nuevamente, lo que finaliza el modo de cadena.

 la,

ltoma la longitud de la pila, aempuja 10 y ,divide. Esto nos da la longitud de la pila / 10.

    :nao

:duplica, nimprime como un número, aempuja 10 e oimprime como un código de caracteres (una nueva línea).

        nao

La misma cosa. Imprima el número seguido de una nueva línea. La pila ahora tiene una longitud 10 nuevamente (el contenido del literal de cadena original está en la pila).

La IP luego se envuelve "nuevamente, lo que lleva a 10 elementos más para ser empujados. La próxima vez,l devuelve 20, por lo que se imprime 2, etc.

La segunda línea nunca es tocada por la IP.

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: ¡Pruébalo en línea!

C: ¡Pruébelo en línea!

Explicación

Esto abusa del hecho de que // es una división interna en Röda pero un comentario de línea en C.

En ambos idiomas, main(){}denota el programa principal, y ambos llaman a la función fcon un argumento ficticio de0 .

En Röda, a=1//1hace la división int y asigna el resultado 1a a. C vea=1 y hace lo mismo, pero todo después de esa tarea es un comentario para C. A partir de ahí, los dos idiomas se ramifican.

Röda

Tenemos un bucle infinito con while[]( una condición vacía es verdadera ). Dentro de eso, ` $a`convierte el entero aen una cadena (con un espacio inicial) después de lo cual lo [::-1]invierte (y sale con un espacio final). Entonces el valor de ase incrementa en uno.

Fuera del ciclo while, comienza un comentario multilínea /* y termina justo antes del final de la función.

C

Después de haber ignorado el resto de la línea, el programa pasa a la segunda línea. Comenzamos con un punto y coma porque la a=1declaración debe terminarse. Después de eso, encontramos un bucle for simple que imprime la variable iterativa,a , dos veces en cada iteración.

Fuera del ciclo for, /*está ahí para ignorar el */comentario final de Röda .

QBIC / QBasic 4.5 , 58 bytes

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

Esto abusa mucho del hecho de que todas las letras minúsculas son vistas como código QBasic literal por el intérprete QBIC y, por lo tanto, simplemente se pasan a la capa QBasic de QBIC. Cómo ambos idiomas ven este código, uno al lado del otro:

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
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/

Golf por primera vez, por lo que es un poco más grande de lo que probablemente podría ser. Quería usar> <>, pero dado que algunas personas ya lo usaban para crear la segunda secuencia, decidí que quería dar la oportunidad de crear la primera secuencia.

Prueba> <> en línea!
Para laserLANG, se necesita un intérprete fuera de línea para probarlo. Se puede encontrar aquí. .

laserLANG

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

comienza la ejecución en la !que se ignora por completo. luego alcanza el \y comienza a viajar más allá de varios personajes que ignora por completo. Finalmente llega a otro \y comienza la diversión. Básicamente tomé la idea detrás del "¡Hola Mundo!" bucle y condensó lo mejor que pude. Fue un poco difícil lidiar con el hecho de que laserLANG solo está a punto de disminuir / incrementar el contador de memoria cuando el contador del programa va hacia la izquierda / derecha respectivamente. Siento que la mayoría de los bytes podrían guardarse aquí haciendo algunos trucos en los que no he pensado.

> <>

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

La ejecución comienza en lo !que hace que omita el \. Luego continúa como si el código laserLANG no estuviera allí. No me di cuenta de que> <> solo tenía soporte para la división de flotación, por lo que un truncamiento corto y simple fue un poco confuso al principio.

Befunge-98 / > <> , 32 bytes

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

Escribí esto antes de ver cuántas ><>respuestas había. Algunos antecedentes: \es un operador de cambio de dirección en> <>, en este caso empujándolo hacia abajo, mientras que en Befunge intercambia los dos primeros elementos de la pila. El código Befunge se ve así:

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

Pruébalo en línea!

Imprime los números hacia atrás separados por nuevas líneas. Befunge imprime un espacio automáticamente después de cada número, por lo que cada dígito está separado por espacios. Repetidamente obtiene el último dígito, lo imprime y divide el número por 10 hasta que sea 0. Luego incremente y repita.

El código> <> baja inmediatamente a la segunda línea.

>l::naonao

Pruébalo en línea!

Y es bastante simple. Obtenga la longitud de la pila, imprima dos veces con líneas nuevas y deje una copia de la longitud en la pila para el siguiente ciclo.

Rubí / Apilado , 37 bytes

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

Pruébalo en línea!

Esto imprime 1 1 2 2... en Ruby y1 2 3 ... 01 11 21... en Stacked.

Explicación

En rubí:

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

Después de eliminar el comentario, esto se convierte en:

0
loop{p p$.+=1}

La única línea relevante aquí es la última. pdevuelve su argumento, por lo que p pimprime su argumento dos veces. $.comienza en 0, por lo tanto $.+=1incrementos $., devolviendo el valor incrementado. Por lo tanto, esto imprime cada número de1 dos veces.

En apilado:

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

Esto es equivalente a los siguientes tokens:

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

Los dos primeros no son relevantes (básicamente, se transforman 0en una reducción de la función). Luego, 0se empuja a la pila. Después, la función [1+:tostr rev out]se empuja a la pila.loopabre esta función y la ejecuta infinitamente.

El interior de la función incrementa la parte superior de la pila ( 1+), la duplica ( :), la convierte en una cadena ( tostr), la invierte ( rev) y la genera ( out). Este proceso se repite infinitamente. Como el ciclo es infinito, el intérprete ignora todo lo que viene después de ese token.

> <> / Jelly , 37 bytes (25 en la página de códigos de Jelly)

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

Prueba> <> en línea!

¡Prueba Jelly en línea!

> <> imprime la secuencia al infinito dos veces, Jelly cuenta hacia atrás.

> <> solo se refiere a la línea superior:

Y gracias a @ Challenger5 por guardar algunos bytes aquí en el salto de línea

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 ejecuta su código de abajo hacia arriba. Solo las últimas 2 líneas son relevantes.

®‘©Çß       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);}//';

Emite la secuencia doble en C y la secuencia inversa en PHP.

Pruébalo en C!

Pruébalo en PHP!

Explicaciones

C

En C, las #formas preprocesador de cosas. Realmente no sé mucho sobre C, pero no se queja cuando hay una línea vacía para estas cosas. El //forma un comentario de línea. UNA\ al final de una línea está esencialmente "escapando" de la nueva línea y haciendo que las dos líneas sean tratadas como una. Esto también funciona para comentarios de línea, por lo que la segunda línea se ve como un comentario en C. La tercera línea hace el trabajo de generar los números con un bucle for simple. Después, simplemente hay un comentario.

PHP

En PHP, #forma un comentario de línea, por lo que la primera línea se ignora por completo. La segunda línea imprime los números invertidos con un bucle for, y los separa con \nint main(i){for(;;i++)printf("%d %d ",i,i);}//(el código C envuelto en una cadena).