Questa è una sfida incatenata alla risposta relativa all'OEIS.

Oh, la giustificazione per questo è perché un'azienda ha bisogno di un programma per stampare le loro sequenze OEIS in modo molto cattivo e hanno tutte le lingue.

Il formato di concatenazione delle risposte funziona nel modo seguente:

Qualcuno pubblica la prima risposta, da cui derivano tutte le ulteriori soluzioni. Questa risposta è un programma che, dato un numero N, inserisce l'ennesimo numero nella sequenza OEIS di qualunque indice scelgano (lo chiameremo sequenza 1), in qualunque lingua scelgano (lingua 1)

Qualcun altro arriva e sceglie la propria sequenza (che deve essere diversa dalla precedente e da tutte le sequenze precedenti). Fanno un programma, in un'altra lingua (che deve essere diverso da tutte le lingue precedenti), che dato un numero N nella lingua 1 produce l'ennesimo numero di sequenza 1 e, dato un numero nella lingua 2, genera l'ennesimo numero di sequenza 2.

Questo processo continua all'infinito.

L'ennesimo termine di una sequenza è il termine che arriva n volte dopo il primo, a partire dal primo elemento. Qui usiamo l'indicizzazione 0 e 1, per essere facili sui programmatori!

Nessun riutilizzo di lingua o sequenza.

L'input deve essere un numero intero o una rappresentazione in formato stringa di un numero intero e l'output deve essere il valore corretto della sequenza. La gestione degli errori (input non int) non è necessaria.

Non devi postare due volte di seguito.

Devi attendere un'ora o più prima di pubblicare nuovamente.

Chiunque sia il penultimo a postare dopo una settimana senza risposte (la persona che non ha rotto la catena) vince, anche se il concorso può continuare indefinitamente. Se sei l'ultimo e puoi dimostrare che puoi aggiungere un'altra lingua, continua la sfida fino al prossimo vincitore.

Puoi presumere che l'input o l'output non saranno al di fuori dell'intervallo numerico della tua lingua (ad esempio, supponendo che il limite IEEE non sarà superato da nessuna sequenza) ma non essere un imbroglione e abusarne usando un lingua che ha solo 1.

È possibile scegliere qualsiasi sequenza, purché non sia mai stata utilizzata in precedenza.

L'input non può essere fuori limite per la sequenza in uso.

Due versioni di lingue diverse sono lingue diverse (Python 2 e Python 3 sono considerati lingue diverse). Questo non è rigido, ma come regola empirica, se è separato da un'altra versione della stessa lingua su TIO, è diverso.

Questo non è vietato, ma prova una volta a non usare la formula fornita da OEIS.

Se il codice risultante ha una lunghezza superiore a 65536 caratteri, fornire un collegamento per accedervi (ad es. Pastebin).

Questo è tutto e tutto qui. Pronto? Impostato? DIVERTIMENTO!

Sì, questo è "Un OEIS dopo l'altro" ma messo su multiplayer. Ho pensato che sarebbe stato bello.

15. Commentatore , 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
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Provalo online!

C #
Brainfuck
Runic Enchantments
Jelly
Gol> <>
Javascript (Node.js) (Tutti 1s) Spazio bianco tra
parentesi (Tutti 3 secondi ) 05AB12 (Tutti 0 secondi ) Larghezza erba illeggibile AlphaBeta Aheui (Tutti i 2 secondi )

Avevo alcuni piani con Commentator, ma solo un contatto è sopravvissuto con tutte le altre lingue. Uno ha causato errori nella Jelly (iirc) e non sono stato in grado di risolverlo perché non so perché Jelly interpretasse i byte nel modo in cui lo faceva.

4. Gelatina , A000312

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

C # (Visual C # Interactive Compiler)
brainfuck
Runic Enchantments
Jelly

Spiegazione:

Consideriamo solo l'ultima riga, tutte le altre righe vengono ignorate.

;/**/ 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).

Per fare in modo che C # ignori il codice, stiamo provando a inserirlo in un commento. Tuttavia, una riga che inizia con /non è valida in Jelly, perché ha /bisogno di un operando. L'operando che stiamo usando qui è ;, dal momento che si adatta perfettamente anche come punto e virgola in C #. Infatti, il punto e virgola e il commento a più righe vuoti insieme formano un collegamento che calcola 2 z = z z . Si noti che l'invio di funzioni in C # è ancora valido, in quanto non esiste un consenso generale che vieta più istruzioni in un invio di funzioni anonime (ad es. Importazioni).$^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
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Non avrei mai pensato di vedere il giorno in cui avrei potuto aggiungere una risposta Java come 16a risposta in una catena poliglotta! : D

1. Provalo in C #: $a(n)=40-n$
2. Provalo in brainfuck: $a(n)=1+n\text{ mod }2$
3. Provalo in Incantesimi runici: $a(n)=4^n$
4. Prova it in Jelly: $a(n)=n^n$
5. Provalo in Gol> <>: $a(n)=-n$
6. Provalo in JavaScript: $a(n)=1$
7. Provalo tra parentesi: $a(n)=1\text{ if }x^n+y^n=z^n\text{ has a nontrivial solution in integers, otherwise }a(n)=0$
8. Provalo in Whitespace: $a(n)=3$
9 Provalo in 05AB1E: $a(n)=0$
10. Provalo in Illeggibile: $a(n)=n$
11. Provalo in Erba: $a(n) = \lfloor n/10^\left(\lfloor log_{10}(n)\rfloor\right)\rfloor$
12. Provalo in Larghezza: $a(n)=n+1\text{ with }n\geq2$
13. Provalo in AlphaBeta: $a(n)=1\Vert n$
14. Provalo in Aheui: $a(n)=2$
15. Provalo in Commentator. $a(n)=2n+6$
16. Provalo in Java 8: $a(n)=n^2$

Spiegazione:

Vorrei iniziare dicendo che, sebbene abbia già sentito parlare di ognuna di queste lingue qui su CGCC, sono esperto solo con Java, C #, 05AB1E e Whitespace e, a parte ciò, posso leggere la parte JavaScript del codice. Le altre lingue sono per lo più sconosciute per me, quindi ho sperato che dopo le modifiche che avevo in mente di far interagire Java con C # / JavaScript, la maggior parte delle altre lingue avrebbe ancora funzionato.

La prima cosa principale da affrontare è stata Java n->vs C # / JavaScript n=>. Java supporta i valori unicode come parte del codice, quindi utilizzando quanto segue:

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

Verrà interpretato come questo in C # / JavaScript:

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

Ma come in Java:

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

Questo perché \u000Aè un'interruzione di linea, \u002Fè /ed \u002Aè *in Java.

Quindi per differenziare la sequenza tra Java vs C # / JavaScript ho aggiunto quanto segue:

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

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

Perché funziona? In Java Stringhe sono oggetti, dove ==viene utilizzato per verificare se i riferimenti di oggetti puntano allo stesso posto (o per verificare se le primitive sono uguali) e l'effettivo Object.equals(Object)deve essere utilizzato per verificare se i valori di questi oggetti sono uguali. Quindi ""+n==""+nsarà falso in Java, ma in verità in C # / JavaScript.

Dopo che è stato affrontato (riutilizzando le nuove linee esistenti per non interrompere il programma degli spazi bianchi), alcune cose dovevano essere riparate. Quattro dei programmi esistenti ora fallivano: Runic Enchantments, Jelly, Unreadable e Commentator.

La correzione per Illeggibile è stata semplice. Ne abbiamo aggiunti quattro """"prima del primo ', quindi abbiamo semplicemente inserito il punto 'precedente (l'ho inserito alla fine della prima riga), e rimuoviamo il lead '""""dalla parte illeggibile del codice in fondo.

Successivamente è arrivata Jelly, che stava dando un IndexError: pop from empty list. Non sono troppo esperto in Jelly, quindi non so esattamente perché abbia dato questo errore. Se ricordo bene che l'ultima riga sarà il collegamento principale di un programma Jelly e poiché il codice in quest'ultima riga non utilizza nessuno degli altri collegamenti, tutto il resto dovrebbe essere ignorato. Ma in qualche modo la parte ha ""+n==""+nancora sollevato alcuni problemi. Sono stato in grado di risolvere questo problema aggiungendo /**/di fronte a quella riga.

Per quanto riguarda gli incantesimi runici, non ha prodotto più nulla. @ Draco18s mi ha fatto notare che gli Incantesimi runici iniziano >simultaneamente, ma solo >2?1:40-n/e /ip@sono rilevanti. Questo è stato un grande aiuto per capire il flusso del programma di Runic Incantesimi, e sono stato in grado di risolvere il percorso con l'aggiunta di un /**/a >2?1:40-/**/n:n*n, e cambiare le posizioni del //ip@, //e lo spazio sull'ultima riga.

Non è rimasto che commentatore. A quel punto mi sono reso conto che le mie precedenti correzioni di aggiunta /**/non erano poi una buona idea, dal momento che avrebbe prodotto un sacco di spazzatura aggiuntiva a causa dei builtin /*(converti attivo in carattere Unicode e output) e */(output attivo come numero) ..>.> Dopo aver giocherellato un po 'e aver provato alcune cose, la correzione si è rivelata molto semplice: ho aggiunto un eprima #sulla prima riga. e#è il builtin per negare un attivo, risolvendo i problemi causati dal codice che ho aggiunto (apparentemente).

6. JavaScript (Node.js) , A000012

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

C # (A022996) : poiché 5/2==2la funzione ritorna 40-n(Riga 2)

BF (A000034) : la parte aggiunta spinge l'intero nastro solo una cella a destra, altre invariate (Linea 2-3)

Runico (A000302) : Il ?dopo 2salta il 1:, e altre operazioni seguono da 4(Linea 2)

Jelly (A000312) : Ultima riga invariata

Gol> <> (A001489) : prima colonna invariata

JS (ES6) (A000012) : poiché 5/2>2la funzione ritorna 1(Linea 2)

Infilò il ternario 5/2>2?1:40-nnella parte C #. In C # poiché 5/2==2la funzione ritorna 40-n, mentre in JS 5/2>2ritorna 1. I commenti in stile C hanno reso quasi impossibile l'aggiunta di linguaggi più pratici (in particolare C e Python). Ulteriori spazi vengono aggiunti alle linee 4-5 per garantire che la parte runica funzioni.

8. Whitespace , 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
//
 ;/**/

Provalo online!

C #
Brainfuck
Runic
Jelly
Gol> <>
Javascript
Parantetico

Non ho idea di come funzioni Whitespace. Ho provato molto duramente a moltiplicare l'input con un altro valore, ma continuavo a lamentarmi dell'aritmetica infix, quindi dato che avevo il funzionamento dell'input, l'output funzionante e il push-value-to-stack funzionante, quindi sono andato solo con quello.

Il valore di input sembra perdersi quando si spinge 3in pila, ma vabbè. Goditi una sequenza di 3 secondi. Il programma prende tecnicamente input e finisce per scartarlo.

_{Inoltre non so come funziona Paranthetic, quindi non posso effettivamente verificare che l'invio sia valido, ma per quanto posso dire il codice degli spazi bianchi non interferisce.}

_{Risposte future: tieni presente che le schede in Runic sono composte da un'unica istruzione e creano il caos con il layout del codice.}

11. Erba , 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
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Provalo online!

Grass ignora tutti i caratteri tranne w, ve W; convenientemente, questi tre caratteri sono ignorati da molte delle lingue utilizzate in precedenza. Fortunatamente, la sequenza A000030 (restituisce la cifra iniziale nella base 10) era ancora disponibile, poiché la codifica anche di funzioni leggermente complicate in Grass è al di là delle mie capacità.

C #
brainfuck
Runic
Jelly
Gol> <>
JavaScript
parenthetic
Whitespace
05AB1E
illeggibile

La parte rilevante per Grass è wvWwwWWwwwwwwWwWWWw. Ecco la mia (probabilmente imperfetta) comprensione di come funziona: lo stack è inizializzato come OUT::SUCC::w::IN::ε(questo wè solo il personaggio w). Ogni istruzione aggiunge un elemento allo stack (non vengono mai visualizzati); il numero di ws Windica quanto in profondità andare nello stack; vsepara le istruzioni.

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

Se l'ingresso è 1234, alla fine, lo stack probabilmente simile a questa: 1::1::id IN::id OUT::id::OUT::SUCC::w::IN::ε.

Potrebbe essere abbreviato (non è necessario definirlo id OUTad esempio), ma mi sono fermato non appena ho trovato una versione che funzionava.

Se qualcuno che conosce Grass vuole correggere / migliorare la spiegazione, modifica la mia risposta!

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
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Interprete online

C #
Brainfuck
Runic Enchantments
Jelly
Gol> <>
Javascript (Node.js) (Tutti 1s) Spazio bianco tra
parentesi (Tutti 3 secondi ) 05AB12 (Tutti 0 secondi ) Larghezza erba illeggibile AlphaBeta Aheui (Tutti i 2 secondi ) Commentatore Java

Dovrai scusare il collegamento Pepe per non contenere la fonte completa: l'interprete ignora qualsiasi codice che non sia Pepe (lett. Qualsiasi carattere non nel set RE re) e quindi il suo collegamento breve non si preoccupa di codificarlo. Idem valori di input.

$a(n) = n^3$

AlphaBeta ha iniziato a generare errori dopo aver scritto l'output, ma come risposta precedente ha iniettato quel problema l'ho lasciato da solo. Avevo programmato di risolverlo per questa risposta, ma ho bisogno di dedicare un po 'di tempo a scavare negli offset di salto per risolvere il problema. L'errore con gli input >0è facile da correggere, ma fornirlo 0produrrà lo stesso errore e ci vorrà del tempo per riapprendere il codice per correggere l'offset. Vorrei poter usare Winvece di UUUUUUUUUU, ma gioca il caos con il codice Grass.

1. C # (compilatore interattivo Visual C #) A022996

n=>40-n

Funziona anche in C # (.NET Core), C # (compilatore Mono C #), C # (Shell Mono C #) e C # (compilatore Visual C #)

Provalo online!

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 # (Visual C # Interactive Compiler)
brainfuck
Runic Enchantments
Jelly
Gol> <>
JavaScript (Node.js)
Parenthetic
Whitespace
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)

Runico (A000302)

Gelatina (A000312)

Gol> <> (A001489)

JS (ES6) (A000012)

Parentesi (A019590)

La parentesi ignora tutto tranne i caratteri (e ). 1Prima di ogni parentesi di chiusura ho dovuto inserire s per impedire a Jelly di impazzire (EDIT: ne ho lasciato uno )senza precedenti con un 1, quindi a quanto pare non tutti hanno bisogno di uno, ma è troppo tardi per giocarci giù adesso). Il codice attuale definisce un lambda chiamato ((())), che può essere chiamato su un numero per produrre il risultato (1-indicizzato).

10. illeggibile , 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
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Provalo online!

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

Illeggibile, come suggerisce il nome, è illeggibile. Per programmarlo ho dovuto usare un modello e poi convertire da testo leggibile a codice illeggibile.

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

Tutto ciò che fa è leggere ogni carattere nell'input e emetterlo. Una delle sequenze più noiose, ma buona per un linguaggio con cui è difficile lavorare. Ho anche giocato con l'uso della sequenza A000030 prima di far funzionare il loop.

_{Lavorare tramite desktop remoto è una seccatura, pensi che le cose funzionino, fai tutti i collegamenti, poi ti rendi conto che uno di loro si è rotto e non se ne è accorto.}

14. Aheui , A007395

Leggermente modificato per far funzionare AlphaBeta.

//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
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Provalo online!

Aheui respinge qualsiasi personaggio non coreano, così 박망희escluso, che stampa 2e termina.

Incantesimi runici C #
Brainfuck Jelly Gol> <> Javascript (Node.js) Spazio bianco tra parentesi 05AB12 Larghezza erba illeggibile AlphaBeta Aheui

2. brainfuck , A000034

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

Provalo online!

C #

3. Incantesimi runici , A000302

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

Provalo online!

C #

BF

Se hai bisogno di aiuto per mantenere funzionale Runic, c'è l' IDE esoterico e il mio IDE (incorporato in Unity3D) nel ramo master del repository git di Runic . IDE esoterico non gestisce molto bene la visualizzazione della direzionalità IP (principalmente la mia incapacità di aggiungere tale al framework esistente).

Tutto il BF crea un gruppo di IP che si auto-terminano a causa di azioni non valide (principalmente a causa di underflow dello stack) mentre >in C # popola lo stack con a 4, rimbalza dei commentatori (mirror in runico), raggiungendo ip@l'esecuzione x^4su un inserire x e stampare il risultato.

5. Gol> <> , A001489

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

Provalo online!

Gelatina runica di
Brainfuck C #

Utilizza i marcatori di commento a riga singola in C # per reindirizzare l'IP Fish al codice operativo, I01-*h , leggendo l'input, moltiplicando per -1 e producendo il risultato. Gol> <> ha reso l'input di lettura e scaricato lo stack come un numero facile rispetto a raw> <>.

Spazi inseriti per assicurare il corretto flusso degli IP Fish e Runic, in cui sia C # che Jelly ignorano lo spazio bianco principale sull'ultima riga (ed è una cellula NOP in entrambi i fungoidi).

12. Larghezza , 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-indicizzati. Uscite per codice di uscita.

Provalo online!

Gli unici caratteri rilevanti per Larghezza sono a-zA-Z. Il codice Width run è il seguente:

qnnAcaAcAAI

I primi tre personaggi, qnnnon sono operativi. Aclegge un numero intero dall'input, aè un no-op e quindi AcAAincrementa il numero intero di uno. Itermina il programma e la parte superiore dello stack diventa il codice di uscita. Tutte le altre lettere nel programma vengono ignorate dal termine del programma.

C #
brainfuck
Runic Incantesimi
Jelly
Gol> <>
JavaScript
parenthetic
Whitespace
05AB1E
illeggibile
Erba

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
//
 ;/*'""""""'""" '""""""""""'"""""'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Provalo online!

Inizialmente avevo programmato di utilizzare la sequenza A000030 e il codice JCL, ma questo mi ha incasinato (non li biasimo, è una buona sequenza per le lingue che accettano input come byte singoli). Il codice originale per questa voce dopo aver dovuto scegliere una nuova sequenza 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)

Le sequenze di xxxo xyzxyzsono utili distanziatori per rendere facili i valori target dei jump-to (46 è più facile come "5 * 10-4" - 9 istruzioni - rispetto a "4 * 10 + 6 - dieci istruzioni - ma 50 è pari più semplice: solo cinque. Ne vedrai alcuni.

Ma poiché ci sono altri byte sulla prima riga, i codici jump-to necessitavano di alcuni nuovi valori che si trasformavano in:

//0q   xxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzWRxyxyzcccccbbCL

Evitare di eseguire questo codice come codice di larghezza implicava semplicemente il wrapping Gper renderlo letterale di stringa (cosa che non fa nulla di importante in AlphaBeta), un comando per far apparire la parte superiore dello stack e quindi qualche extra Wper far sì che alpha beta non si arrestasse in modo anomalo all'uscita:

//0q   GxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzWWWWWWRxyxyzcccccbbCLGw

Per evitare conflitti con Grass, invece, w Cviene utilizzato invece il comando scoppiare con il comando . Quindi il salto "esci dal programma" viene sostituito con Questo UUUUUUinvece WWWWWWlascia l'IP da qualche parte nel mezzo del resto del codice spazzatura, ma abbastanza lontano da non stampare alcun errore. Qualsiasi numero di messaggi aggiuntivi Upuò essere aggiunto in coppia se questo diventa un problema.

//0q   GxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzUUUUUURxyxyzcccccbbCLGC

L'aggiunta iche Runic finisce per eseguire è un NOP su input validi poiché nessun input-left-to-read non inserisce nulla nello stack ("leggere tutti gli input" è un dolore in Runic).

C #
brainfuck
Runic Incantesimi
Jelly
Gol> <>
JavaScript
parenthetic
Whitespace
05AB1E
illeggibile
Erba
Larghezza

18.] = [, A010716 , la sequenza di tutti e 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
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Questo linguaggio non è su TIO e il suo unico interprete stesso è scritto in un altro linguaggio interpretato, che è anche non su TIO. E quello che non ha funzionato bene con Brainfuck la scorsa settimana all'ultimo minuto, ma ho capito cosa c'era che non andava poche ore dopo aver pubblicato la risposta di Pepe, quindi l'ho salvato per questa settimana. Essendo un linguaggio non su TIO, stavo considerando questo come un asso nella manica che poteva essere facilmente applicato su QUALSIASI entrata e continuare la catena.

• Codice interprete: https://pastebin.com/raw/yqtpynnh
• Interprete interprete: https://12me21.github.io/12-basic/

Inserisci il codice dell'interprete nella casella "code" nella parte superiore, codifica dalla risposta nell'input e fai clic su Esegui e ottieni un output (più un po 'di junk extra che viene sempre stampato).

La parte operativa di] = [è questa alla fine della prima riga:

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

È quel finale [che ha causato il caos con Brainfuck (il resto è stato ignorato, a causa di come [e ]sono gestiti da Brainfuck) e una volta che ho guardato di nuovo le specifiche Brainfuck ho capito il problema e che tutto quello che dovevo fare era inserire un ]da qualche parte dopo il prima riga (come] = [l'interprete non legge le nuove righe) e prima del Brainfuck. Ho scelto la seconda linea.

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
illeggibile
Erba
Larghezza
AlphaBeta
Aheui (esotope)
Commentator
Java (OpenJDK 8)
Pepe

19. In realtà , 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
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Provalo online!

Parte operativa: ,2*1z⌂(prima riga)

Man mano che ⌂termina il programma, nessuno del codice dopo che ha avuto alcun effetto e nessuno dei simboli prima di esso provoca qualsiasi output o inquina negativamente la memoria operativa. La sezione esiste all'interno di un commento (C #, JS, Java), contiene solo caratteri ignorati (Commentator,] = [, Pepe, Aheui ...), non si trova sull'ultima riga (Jelly), o altrimenti in parti non eseguite di il codice (Gol> <>, Runic, AlphaBeta).

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
illeggibile
Erba
Larghezza
AlphaBeta
Aheui (esotope)
Commentator
Java (OpenJDK 8)
Pepe
] = [(link non è possibile, vedi # 18 per le istruzioni)

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
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Provalo online!

Non ho idea di come diavolo funzioni Neim. So cosa finisce per fare il codice qui, ma non ho idea di come funzioni il linguaggio stesso.

Si scopre anche che ho incasinato la Brainfuck con il numero 19. A causa di conflitti di comando tra più lingue, la soluzione ottimale è stata cambiare l'input di Actually §e quindi forzarlo a un int con ≈.

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
illeggibile
Erba
Larghezza
AlphaBeta
Aheui (esotope)
Commentator
Java (OpenJDK 8)
Pepe
] = [(link non è possibile, vedi # 18 )
In realtà

21. Flobnar , A010709 (Tutti i 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
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Provalo online!

Flobnar inizia da @e si espande verso l'esterno valutando gli elementi secondo le regole ( @valuta qualsiasi cosa alla sua sinistra, 4valuta 4, +valuta tutto ciò che è a sinistra sommato con ciò che è a destra, ecc.). Poiché il posizionamento @dell'unica viene a contatto con Runic, una semplice !impedisce l'alterazione della pila di Runic.

Dato che la metrica di input di Flobnar è "un byte" e va in un ciclo infinito se non ci sono byte da leggere, ho deciso di non preoccuparmi di qualcosa di più complesso.

Lingue precedenti

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
illeggibile
Erba
Larghezza
AlphaBeta
Aheui (esotope)
Commentator
Java (OpenJDK 8)
Pepe ] = [(link non è possibile, vedi # 18 )
In realtà
Neim