Este es un desafío de encadenamiento de respuestas relacionado con el OEIS.

Ah, la justificación de esto es porque una empresa necesita un programa para imprimir sus secuencias OEIS realmente malas y tienen todos los idiomas.

El formato de encadenamiento de respuestas funciona de la siguiente manera:

Alguien publica la primera respuesta, de donde surgen todas las soluciones adicionales. Esta respuesta es un programa que, dado un número N, ingresa el enésimo número en la secuencia OEIS de cualquier índice que elijan (lo llamaremos secuencia 1), en el idioma que elijan (idioma 1)

Alguien más viene y elige su propia secuencia (que tiene que ser diferente de la anterior y de todas las secuencias anteriores). Hacen un programa, en otro idioma (que tiene que ser diferente de todos los idiomas anteriores), que dado un número N en el idioma 1 da como resultado el enésimo número de secuencia 1 y, dado un número en el idioma 2 da como resultado el enésimo número de secuencia 2)

Este proceso continúa hasta el infinito.

El enésimo término de una secuencia es el término que viene n veces después del primero, trabajando desde el primer elemento. ¡Aquí usamos indexación 0 y 1, para ser fácil con los codificadores!

Sin lenguaje o secuencia de reutilización.

La entrada debe ser un entero o una representación de cadena de un entero y la salida debe ser el valor correcto de la secuencia. El manejo de errores (entrada no int) no es necesario.

No debe publicar dos veces seguidas.

Debe esperar una hora o más antes de publicar nuevamente.

Quien sea el SEGUNDO-a-último en publicar después de una semana sin respuestas (la persona que no rompió la cadena) gana, aunque el concurso puede continuar indefinidamente. Si eres el último y puedes demostrar que puedes agregarle un idioma más, continúas el desafío hasta el próximo ganador.

Puede suponer que la entrada o la salida no estarán fuera del rango numérico de su idioma (por ejemplo, suponiendo que el límite de IEEE no será superado por ninguna secuencia), pero no sea un tramposo y abuse de esto usando un idioma que solo tiene 1.

Se puede elegir cualquier secuencia, siempre que no se haya usado antes.

La entrada no puede estar fuera de los límites de la secuencia que está utilizando.

Dos versiones de idiomas diferentes son idiomas diferentes (Python 2 y Python 3 se consideran idiomas diferentes). Esto no es rígido, pero como regla general, si está separado de otra versión del mismo idioma en TIO, es diferente.

Esto no está prohibido, pero trata una vez de no usar la fórmula que ofrece OEIS.

Si su código resultante tiene más de 65536 caracteres, proporcione un enlace para acceder a él (por ejemplo, Pastebin).

Eso es todo y eso es todo. Listo? ¿Conjunto? ¡DIVERTIDO!

Sí, esto es "un OEIS tras otro", pero en modo multijugador. Pensé que sería genial.

15. Comentarista , A020739

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0#
/*	
박망희		   		0#
;*/	
 	

n=>5/2>2?1:40-n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Pruébalo en línea!

C #
Brainfuck
Runic encantamientos
jalea
de Gol> <>
Javascript (Node.js) (Todo 1s)
parentético
Los espacios en blanco (Todo 3s)
05AB12 (Todo 0s)
ilegible
Hierba
Ancho
Alphabeta
Aheui (Todos los 2s)

Tenía algunos planes con el comentarista, pero solo uno sobrevivió al contacto con todos los demás idiomas. Uno causó errores en Jelly (iirc) y no pude resolverlo porque no sé por qué Jelly interpretó los bytes de la manera en que lo hizo.

4. Jalea , A000312

n=>40-n//
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
       //ip@
       //
;/**/

C # (compilador interactivo de Visual C #)
brainfuck
Runic Enchantments
Jelly

Explicación:

Solo tenemos en cuenta la última línea, todas las demás líneas se ignoran.

;/**/ Argument: z
;/    Reduce z by ; (concatenation) [1]
      z is an integer, so this just returns z itself.
   */ Reduce z by * (exponentiation) [2]
      Again, this returns z itself.
  *   Exponentiation: return [1] ** [2]
      This resolves to (z ** z).

Para hacer que C # ignore el código, estamos tratando de ponerlo en un comentario. Sin embargo, una línea que comienza con /no es válida en Jelly, porque /necesita un operando. El operando que estamos usando aquí es ;, ya que también encaja perfectamente como punto y coma en C #. De hecho, el punto y coma y el comentario de varias líneas vacías juntos forman un enlace que calcula 2 z = z z . Tenga en cuenta que el envío de la función en C # sigue siendo válido, ya que no existe un consenso general que rechace varias declaraciones en un envío de función anónimo (por ejemplo, importaciones).$^2z=z^z$

16. Java 8 , A000290

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0e#'
/*  
박망희             0#
;*/ 
    //\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

¡Nunca pensé que vería el día en que podría agregar una respuesta Java como la 16ª respuesta en una cadena políglota! :RE

1. Pruébalo en C #: $a(n)=40-n$
2. Pruébalo en brainfuck: $a(n)=1+n\text{ mod }2$
3. Pruébalo en encantamientos rúnicos: $a(n)=4^n$
4. Prueba en Jelly: $a(n)=n^n$
5. Pruébalo en Gol> <>: $a(n)=-n$
6. Pruébalo en JavaScript: $a(n)=1$
7. Pruébelo en paréntesis: $a(n)=1\text{ if }x^n+y^n=z^n\text{ has a nontrivial solution in integers, otherwise }a(n)=0$
8. Pruébelo en espacios en blanco: $a(n)=3$
9 Pruébelo en 05AB1E: $a(n)=0$
10. Pruébelo en No legible: $a(n)=n$
11. Pruébelo en Grass: $a(n) = \lfloor n/10^\left(\lfloor log_{10}(n)\rfloor\right)\rfloor$
12. Pruébelo en Ancho: $a(n)=n+1\text{ with }n\geq2$
13. Pruébelo en AlphaBeta: $a(n)=1\Vert n$
14. Pruébalo en Aheui: $a(n)=2$
15. Pruébalo en el comentarista. $a(n)=2n+6$
$a(n)=n^2$

Explicación:

Permítanme comenzar diciendo que aunque he escuchado de cada uno de estos idiomas antes aquí en CGCC, solo soy experto en Java, C #, 05AB1E y Whitespace, y aparte de eso, puedo leer la parte de JavaScript del código. Los otros lenguajes no me son familiares, así que esperaba que después de los cambios que tenía en mente hacer que Java interactuara con C # / JavaScript, la mayoría de los otros lenguajes seguirían funcionando.

Lo primero que se enfrentó fue Java n->vs C # / JavaScript n=>. Java admite valores unicode como parte del código, por lo que se utiliza lo siguiente:

//\u000A\u002F\u002A
n=>//\u002A\u002Fn->

Se interpretará como esto en C # / JavaScript:

//\u000A\u002F\u002A
n=>//\u002A\u002Fn->

Pero como esto en Java:

//
/*
n=>//*/n->

Esto se debe a que \u000Aes un salto de línea, \u002Festá /y \u002Aestá *en Java.

Luego, para diferenciar la secuencia entre Java y C # / JavaScript, agregué lo siguiente:

""+n==""+n?...:n*n

...5/2>2?1:40-nn*n$a(n)=n^2$

¿Por qué funciona esto? En Java, las cadenas son objetos, donde ==se usa para verificar si las referencias de los objetos apuntan al mismo lugar (o para verificar si las primitivas son iguales), y el real Object.equals(Object)debe usarse para verificar si los valores de estos objetos son los mismos. Así ""+n==""+nserá falsey en Java, pero sinceramente en C # / JavaScript.

Después de que se abordó (reutilizando las nuevas líneas existentes para no romper el programa de espacios en blanco), algunas cosas tuvieron que repararse. Cuatro de los programas existentes estaban fallando ahora: encantamientos rúnicos, gelatina, ilegible y comentarista.

La solución para Unreadable fue fácil. Añadimos cuatro """"antes del primero ', por lo que simplemente colocamos el 'lugar antes (lo coloqué al final de la primera línea) y '""""eliminamos el inicio de la parte Ilegible del código en la parte inferior.

Después de eso vino Jelly, que estaba dando un IndexError: pop from empty list. No soy muy hábil en Jelly, así que no sé exactamente por qué dio este error. Si recuerdo correctamente, la última línea será el enlace principal de un programa Jelly, y debido a que el código en esa última línea no usa ninguno de los otros enlaces, todo lo demás debería ignorarse. Pero de alguna manera la parte ""+n==""+ntodavía dio algunos problemas. Pude arreglar esto agregando /**/delante de esa línea.

En cuanto a los encantamientos rúnicos, ya no generaba nada. @ Draco18s me señaló que los encantamientos rúnicos comienzan de manera >simultánea, pero solo los >2?1:40-n/y /ip@eran relevantes. Esta fue una gran ayuda para entender el flujo del programa Runic encantamientos, y yo era capaz de corregir la trayectoria mediante la adición de una /**/a >2?1:40-/**/n:n*n, y el cambio de las posiciones de la //ip@, //y el espacio en la última línea.

Todo lo que quedaba era comentarista. En ese momento, me di cuenta de que mis soluciones anteriores de agregar /**/no eran una buena idea después de todo, ya que generaría un montón de basura adicional debido a las funciones integradas /*(convertir activo a carácter y salida unicode) y */(salida activa como número) ..>.> Después de jugar un poco y probar algunas cosas, la solución resultó ser muy fácil: he agregado un eantes #en la primera línea. e#es el incorporado para negar un activo, solucionando los problemas causados ​​por el código que agregué (aparentemente).

6. JavaScript (Node.js) , A000012

//
n=>5/2>2?1:40-n//
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/**/

C # (A022996) : dado que 5/2==2la función regresa 40-n(Línea 2)

BF (A000034) : la parte agregada solo empuja toda la cinta una celda hacia la derecha, otras sin cambios (Línea 2-3)

Rúnico (A000302) : El ?después 2omite el 1:, y otras operaciones se siguen de 4(Línea 2)

Jalea (A000312) : última línea sin cambios

Gol> <> (A001489) : primera columna sin cambios

JS (ES6) (A000012) : dado que 5/2>2la función devuelve 1(Línea 2)

Mete el ternario 5/2>2?1:40-na escondidas en la parte C #. En C # ya que 5/2==2la función regresa 40-n, mientras que en JS 5/2>2la función retorna 1. Los comentarios de estilo C hicieron casi imposible agregar lenguajes más prácticos (específicamente C y Python). Se agregan más espacios en las líneas 4-5 para garantizar que la parte rúnica funcione.

8. El espacio en blanco , A010701

//   
	
		   		
	
 	

n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/**/

Pruébalo en línea!

C #
Brainfuck
Runic
Jelly
Gol> <>
Javascript
Paranthetic

No tengo idea de cómo funciona el espacio en blanco. Intenté con todas mis fuerzas multiplicar la entrada con otro valor, pero seguía quejándome de la aritmética infija, por lo que tenía trabajo de entrada, trabajo de salida y trabajo de valor de inserción para apilar, así que seguí con eso.

El valor de entrada parece perderse cuando se empuja 3a la pila, pero bueno. Disfruta de una secuencia de 3s. El programa técnicamente toma datos , simplemente termina descartándolo.

_{Tampoco sé cómo funciona Paranthetic, por lo que no puedo verificar que la presentación sea válida, pero por lo que puedo decir, el código de espacios en blanco no interfiere.}

_{Respuestas futuras: tenga en cuenta que las pestañas en Runic son una sola instrucción amplia y causan estragos en el diseño del código.}

11. Hierba , A000030

//0q   
	
		   		
	
 	

n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Pruébalo en línea!

Grass ignora todos los caracteres excepto w, vy W; convenientemente, estos tres caracteres son ignorados por varios de los idiomas utilizados anteriormente. Afortunadamente, la secuencia A000030 (devolver el dígito inicial en la base 10) todavía estaba disponible, ya que la codificación de funciones incluso ligeramente complicadas en Grass está más allá de mi capacidad.

C #
brainfuck
Runic
jalea
de Gol> <>
JavaScript
parentético
espacios en blanco
05AB1E
ilegible

La parte relevante para Grass es wvWwwWWwwwwwwWwWWWw. Aquí está mi comprensión (probablemente defectuosa) de cómo funciona: la pila se inicializa como OUT::SUCC::w::IN::ε(eso wes solo el personaje w). Cada instrucción agrega un elemento a la pila (nunca se abren); el número de ws o Ws indica qué tan profundo ir en la pila; vSepara las instrucciones.

wv        # identity
Www       # identity OUT
WWwwwwww  # identity IN (read in 1 character)
Ww        # apply the function identity IN
WWWw      # apply the function identity OUT to the value at the top of the stack

Si la entrada es 1234, al final, la pila probablemente se parece a esto: 1::1::id IN::id OUT::id::OUT::SUCC::w::IN::ε.

Podría hacerse más corto (no es necesario definirlo, id OUTpor ejemplo), pero me detuve tan pronto como encontré una versión que funcionó.

Si alguien que conoce Grass quiere corregir / mejorar la explicación, edite mi respuesta.

17. Pepe , A000578

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0e#'
/*	
박망희		   		0#
;*/	
 	//\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Intérprete en línea

C #
Brainfuck
Runic encantamientos
jalea
de Gol> <>
Javascript (Node.js) (Todo 1s)
parentético
Los espacios en blanco (Todo 3s)
05AB12 (Todo 0s)
ilegible
Hierba
Ancho
Alphabeta
Aheui (Todos los 2s)
Comentarista
de Java

Tendrá que disculpar el enlace de Pepe por no contener la fuente completa: el intérprete ignora cualquier código que no sea Pepe (literalmente, ningún carácter que no esté en el conjunto RE re) y, por lo tanto, su enlace corto no molesta en codificarlo. Lo mismo ocurre con los valores de entrada.

$a(n) = n^3$

AlphaBeta ha comenzado a arrojar errores después de escribir la salida, pero como respuesta previa inyectó ese problema, lo dejé solo. Había planeado arreglarlo para esta respuesta, pero necesito pasar un tiempo investigando las compensaciones de salto para resolver el problema. El error con las entradas >0es fácil de corregir, pero si 0se produce, se producirá el mismo error y llevará tiempo volver a aprender el código para corregir el desplazamiento. Desearía poder usar en Wlugar de UUUUUUUUUU, pero causa estragos en el código Grass.

1. C # (compilador interactivo de Visual C #) A022996

n=>40-n

También funciona en C # (.NET Core), C # (compilador Mono C #), C # (Shell Mono C #) y C # (compilador Visual C #)

Pruébalo en línea!

9. 05AB1E , A000004

//0q   
	
		   		
	
 	

n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/**/

C # (C # interactivo Compilador)
brainfuck
Runic encantamientos
jalea
de Gol> <>
JavaScript (Node.js)
parentético
espacios en blanco
05AB1E

7. Parenthetic , A019590

//
n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/**/

C # (A022996)

BF (A000034)

Rúnico (A000302)

Jalea (A000312)

Gol> <> (A001489)

JS (ES6) (A000012)

Paréntesis (A019590)

Los paréntesis ignoran todo menos los caracteres (y ). Sin 1embargo, he tenido que insertar s antes de cada paréntesis de cierre para evitar que Jelly se enloquezca (EDITAR: dejé uno )sin precedentes por un 1, por lo que aparentemente no todos necesitan uno, pero ya es demasiado tarde para jugarlo). El código real define un lambda llamado ((())), que se puede invocar en un número para obtener el resultado (1 indexado).

10. Ilegible , A001477

//0q   
	
		   		
	
 	

n=>5/2>2?1:40-n//(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Pruébalo en línea!

C #
Brainfuck
Runic
Jelly
Gol> <>
Javascript
Paranthetic
Whitespace
05AB1E

Ilegible, como su nombre lo indica, es ilegible. Para programarlo, tuve que usar una plantilla y luego convertir de texto legible a código ilegible.

[A=READ()];DO{(A+1)?:BOTH(PRINT(A),[A=READ()])}
[A=READ()]: '""""""'"""'""""""""""
PRINT(A): '"'"""""""'"""
A?: '""'"""
Functioning:
['""""""'"""'""""""""""];'"""""{('""'"""""""'""")?:'""""('"('"""""""'"""),['""""""'"""'""""""""""])}

Todo lo que hace es leer cada carácter en la entrada y sacarlo. Una de las secuencias más aburridas, pero buena para un lenguaje con el que es difícil trabajar. También jugué con el uso de la secuencia A000030 antes de hacer que el bucle funcione.

_{Trabajar a través del escritorio remoto es una molestia, crees que las cosas funcionan, haces todos los enlaces, luego te das cuenta de que uno de ellos se rompió y no se dio cuenta.}

14. Aheui , A007395

Ligeramente cambiado para que AlphaBeta funcione.

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC
/*  
박망희*/               



n=>5/2>2?1:40-n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Pruébalo en línea!

Aheui descarta cualquier carácter no coreano, así 박망희ejecutado, que imprime 2y termina.

C #
Brainfuck
Runic encantamientos
jalea
de Gol> <>
Javascript (Node.js)
parentético
espacios en blanco
05AB12
ilegible
Hierba
Ancho
Alphabeta
Aheui

2. brainfuck , A000034

n=>40-n
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.

Pruébalo en línea!

C#

3. Encantamientos rúnicos , A000302

n=>40-n//
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
       //ip@
       //

Pruébalo en línea!

C#

BF

Si necesita ayuda para mantener el Runic en funcionamiento, existe el IDE Esotérico , así como mi propio IDE (integrado en Unity3D) en la rama maestra del repositorio git de Runic . El IDE esotérico no maneja mostrar la direccionalidad de IP muy bien (principalmente mi propia incapacidad para agregarlo al marco existente).

Todo el BF crea un grupo de IP que se auto-terminan debido a la realización de acciones no válidas (principalmente debido al flujo inferior de la pila) mientras que >en C # llena la pila con un 4, rebotes de los creadores de comentarios (espejos en Runic), llegando ip@a ejecutarse x^4en un ingrese x e imprima el resultado.

5. Gol> <> , A001489

//
n=>40-n//
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.
       //ip@
       //
;/**/
//I01-* h
//
 ;/**/

Pruébalo en línea!

C #
Brainfuck
Runic
Jelly

Utilice marcadores de comentarios de una sola línea en C # para redirigir la IP de Fish al código operativo I01-*h, leyendo la entrada, multiplicándola por -1 y generando el resultado. Gol> <> hizo que la entrada de lectura y el volcado de la pila como un número sea fácil en comparación con raw> <>.

Espacios insertados para asegurar el flujo adecuado de las IP de Fish y Runic, donde C # y Jelly ignoran el espacio en blanco en la última línea (y es una celda NOP en ambos hongos).

12. Ancho , A020725

//0q   
	
		   		
	
 	

n=>5/2>2?1:40-n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

1 indexado. Salidas por código de salida.

Pruébalo en línea!

Los únicos caracteres relevantes para Ancho son a-zA-Z. El código que ejecuta Ancho es el siguiente:

qnnAcaAcAAI

Los primeros tres caracteres qnn, son no-ops. Aclee un entero desde la entrada, aes un no-op, y luego AcAAincrementa el entero en uno. Ifinaliza el programa y la parte superior de la pila se convierte en el código de salida. Todas las demás letras del programa se ignoran desde que el programa finalizó.

C #
brainfuck
Runic encantamientos
jalea
de Gol> <>
JavaScript
parentético
espacios en blanco
05AB1E
ilegible
Hierba

13. AlphaBeta , A162672

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC
	
		   		
	
 	

n=>5/2>2?1:40-n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
               //ip@
               //
;/**/
//I01-* h
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Pruébalo en línea!

Originalmente había planeado usar la secuencia A000030 y el código JCL, pero eso se interpuso (no los culpo, es una buena secuencia para los idiomas que toman la entrada como bytes individuales). El código original para esta entrada después de tener que elegir una nueva secuencia era:

JiiiiihhZUUUUUNYAxcccccbCLDLxyzUUUUTTxxyzJCLOzWRxyxyzcccccbbCL
^                                                                 Read input (single byte)
                 ^          ^^^      ^^^^    ^  ^^^^^             Clear regisers
        ^                                            ^^^^^^^^^    Input = 0: print 0
 ^^^^^^^ ^^^^^                 ^^^^^^         ^                   Set jump locations
                  ^^^^^^^^                                        Print `1`
                          ^^                                      Print initial byte
                                         ^^^                      Read and print input
                                            ^                     (and loop)

Las secuencias de xxxo xyzxyzson espaciadores útiles para hacer que los objetivos de salto sean valores fáciles (46 es más fácil como "5 * 10-4" - 9 instrucciones - que "4 * 10 + 6 - diez instrucciones - pero 50 es par más simple: solo cinco) Verás algunos de esos.

Pero como hay otros bytes en la primera línea, los códeles de salto necesitaban algunos valores nuevos y eso se convirtió en:

//0q   xxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzWRxyxyzcccccbbCL

Evitar ejecutar este código ya que el código de Ancho implicaba envolverlo Gpara convertirlo en un literal de cadena (que no hace nada importante en AlphaBeta), un comando para hacer estallar la parte superior de la pila y luego algo más Wpara hacer que la beta beta no se bloquee al salir:

//0q   GxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzWWWWWWRxyxyzcccccbbCLGw

Sin embargo, para evitar conflictos con Grass, en lugar de hacer estallar, w Cse usa el comando con . Luego, se reemplaza el salto del "programa de salida" en UUUUUUlugar de WWWWWWEsto deja la IP en algún lugar en el medio del resto del código basura, pero lo suficientemente lejos como para que no imprima ningún error. Se Upuede agregar cualquier número de s adicionales en pares si esto se convierte en un problema.

//0q   GxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzUUUUUURxyxyzcccccbbCLGC

El adicional ique Runic termina ejecutando es un NOP en entradas válidas ya que no-input-left-to-read no empuja nada a la pila ("leer todas las entradas" es un dolor en Runic).

C #
brainfuck
Runic Enchantments
Jelly
Gol> <>
JavaScript
parentético
espacios en blanco
05AB1E
ilegible
Hierba
Ancho

18.] = [, A010716 , la secuencia de todos los 5

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0e#'[=====[===]]=[[==========]]=[
/*] 
박망희             0#
;*/ 
    //\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Este idioma no está en TIO y su único intérprete está escrito en otro idioma interpretado, que tampoco está en TIO. Y el que no jugó bien con Brainfuck la semana pasada en el último minuto, pero descubrí lo que estaba mal unas horas después de publicar la respuesta de Pepe, así que lo guardé para esta semana. Al ser un idioma que no está en TIO, consideraba que este era un as en el hoyo que fácilmente se podía agregar a CUALQUIER entrada y continuar la cadena.

• Código de intérprete: https://pastebin.com/raw/yqtpynnh
• Intérprete intérprete: https://12me21.github.io/12-basic/

Coloque el código del intérprete en el cuadro "código" en la parte superior, codifique desde la respuesta en la entrada y haga clic en Ejecutar y obtenga una salida (más algo de basura adicional que siempre se imprime).

La parte operativa de] = [es esta al final de la primera línea:

[=====[===]]=[[==========]]=[

Es ese rastro [que causó estragos en Brainfuck (el resto se ignora, debido a cómo [y] son manejados por Brainfuck) y una vez que miré la especificación Brainfuck nuevamente, me di cuenta del problema y que todo lo que tenía que hacer era insertar un ]lugar después del primera línea (como el] = [el intérprete no lee líneas nuevas) y antes del Brainfuck. Elegí la segunda línea.

C #
Brainfuck
Runic
jalea
de Gol> <>
JavaScript (Node.js)
Paranthetic
espacios en blanco
05AB1E
ilegible
Hierba
Ancho
Alphabeta
Aheui (esotope)
Comentarista
de Java (OpenJDK 8)
Pepe

19. En realidad , A005843 (2 * n)

//0q   GxxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLGC//*/0e#,2*1z⌂'[=====[===]]=[[==========]]=[
/*]	
박망희		   		0#
;*/	
 	//\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Pruébalo en línea!

Parte operacional: ,2*1z⌂ (primera línea)

Como ⌂ finaliza el programa, ninguno de los códigos después de que tenga algún efecto, y ninguno de los símbolos antes de que produzca ningún resultado o contamine negativamente la memoria operativa. La sección existe dentro de un comentario (C #, JS, Java), solo contiene caracteres ignorados (Comentarista,] = [, Pepe, Aheui ...), no está en la última línea (Jelly) ni en partes no ejecutadas de el código (Gol> <>, Runic, AlphaBeta).

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
ilegible
Grass
Anchura
Alphabeta
Aheui (esotope)
Comentarista
Java (OpenJDK 8)
Pepe
] = [(enlace no es posible, ver # 18 para obtener instrucciones)

20. Neim , A008592 (10 * n)

//0q   ÷GxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLxGC//*/0e#§≈2*1z⌂'>[=====[===]]=[[==========]]=[
/*]	
박망희		   		0#
;*/	
 	//\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Pruébalo en línea!

No tengo idea de cómo diablos funciona Neim. Sé lo que el código termina haciendo aquí, pero no tengo idea de cómo funciona el lenguaje en sí.

También resulta que estropeé el Brainfuck con el # 19. Debido a conflictos de comandos entre varios idiomas, cambiar la entrada de Actually §y luego coaccionarla a int con≈ fue la solución óptima.

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
ilegible
Grass
Anchura
Alphabeta
Aheui (esotope)
Comentarista
Java (OpenJDK 8)
Pepe
] = [(enlace no es posible, ver # 18 )
En realidad

21. Flobnar , A010709 (Todos los 4s)

//0q   ÷GxJiiiiihhZUUUUUUUNYAxcccccbCLDLxyzUUUUUTxyzJCLOzUUUUUURzyzxyzxyzcccccbbCLxGC//*/0e#§≈2*1z⌂'>[=====[===]]=[[==========]]=[
/*]	
박망희		   		0#
;*/	
 	//\u000A\u002F\u002A
n=>//\u002A\u002Fn->
/**/""+n==""+n?5/2>2?1:40-/**/n:n*n//AcaAcAAI(((1)(1)(1)1)((1)(((1)1)1)1)(((1)(1)1)(((1)((1)1)(1)1)1)(((1)(1)(1)(1)1)(((1)(1)((1))(1)1)((1)((1)1)(1)1)(((1)1)(1)(1)1)1)(((1)1)(1)1)(((1)1)1)1)1)1)
//[>[-]<[>+<-],]>>+<[->[>>+<<-]>[<+>-]>[<+>-]<<<]>>>>++++++[<++++++++>-]<<[>+<-]>+.wvWwwWWwwwwwwWwWWWw
                          //ip!4@
                          //rEeE rEeeEe reEE
;/**/
//I01-* h
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Pruébalo en línea!

Flobnar comienza en @y se expande hacia afuera evaluando los elementos según lo dictan las reglas ( @evalúa lo que está a su izquierda, 4evalúa 4, +evalúa lo que está a la izquierda sumado con lo que está a la derecha, etc.). Como la colocación de la @única entra en contacto con Runic, un simple !evita la alteración de la pila de Runic.

Dado que la métrica de entrada de Flobnar es "un byte" y entra en un bucle infinito si no hay bytes para leer, decidí no molestarme con nada más complejo.

Idiomas anteriores

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
ilegible
Grass
Anchura
Alphabeta
Aheui (esotope)
Comentarista
Java (OpenJDK 8)
Pepe ] = [(enlace no es posible, ver # 18 )
En realidad
Neim