Il s'agit d'un défi de chaînage des réponses concernant l'OEIS.

Oh, la justification en est qu'une entreprise a besoin d'un programme pour imprimer ses séquences OEIS vraiment mal et qu'elle a toutes les langues.

Le format de chaînage des réponses fonctionne de la manière suivante:

Quelqu'un publie la première réponse, d'où découlent toutes les autres solutions. Cette réponse est un programme qui, étant donné un nombre N, entre le Nième nombre dans la séquence OEIS de l'index qu'ils choisissent (nous l'appellerons la séquence 1), dans la langue qu'ils choisissent (langue 1)

Quelqu'un d'autre arrive et choisit sa propre séquence (qui doit être différente de la précédente et de toutes les séquences précédentes). Ils font un programme, dans une autre langue (qui doit être différente de toutes les langues précédentes), qui étant donné un nombre N dans la langue 1 sort le Nième numéro de la séquence 1 et, étant donné un numéro dans la langue 2 sort le Nième numéro de la séquence 2.

Ce processus se poursuit à l'infini.

Le nième terme d'une séquence est le terme qui vient n fois après le premier, à partir du premier élément. Ici, nous utilisons l'indexation 0 et 1, pour être facile avec les codeurs!

Aucune réutilisation de langue ou de séquence.

L'entrée doit être un entier ou une représentation sous forme de chaîne d'un entier et la sortie doit être la valeur correcte de la séquence. La gestion des erreurs (entrée non-int) n'est pas nécessaire.

Vous ne devez pas poster deux fois de suite.

Vous devez attendre une heure ou plus avant de poster à nouveau.

Celui qui est le deuxième avant-dernier à poster après une semaine sans réponse (la personne qui n'a pas brisé la chaîne) gagne, bien que le concours puisse se poursuivre indéfiniment. Si vous êtes le dernier et que vous pouvez montrer que vous pouvez y ajouter une autre langue, vous continuez le défi jusqu'au prochain gagnant.

Vous pouvez supposer que l'entrée ou la sortie ne sera pas en dehors de la plage numérique de votre langue (par exemple, en supposant que la limite d'IEEE ne sera dépassée par aucune séquence) mais ne soyez pas un filou et abusez-en en utilisant un langue qui n'a que 1.

N'importe quelle séquence peut être choisie, tant qu'elle n'a pas été utilisée auparavant.

L'entrée ne peut pas être hors limites pour la séquence que vous utilisez.

Deux versions linguistiques différentes sont des langues différentes (Python 2 et Python 3 sont considérés comme des langages différents). Ce n'est pas rigide, mais en règle générale, s'il est séparé d'une autre version de la même langue sur TIO, c'est différent.

Ce n'est pas interdit, mais essayez une fois de ne pas utiliser la formule donnée par l'OEIS.

Si votre code résultant comporte plus de 65 536 caractères, fournissez un lien pour y accéder (par exemple Pastebin).

C'est tout et c'est tout. Prêt? Ensemble? AMUSEMENT!

Oui, c'est "un OEIS après l'autre" mais mis en multijoueur. Je pensais que ce serait cool.

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

Essayez-le en ligne!

C #
Brainfuck
Runic enchantements
Jelly
Gol> <>
Javascript (Node.js) (tous les 1)
parenthetic
Whitespace (Toutes les 3s)
05AB12 (Toutes les 0s)
Illisible
Herbe
Largeur
AlphaBeta
Aheui (Toutes les 2 s)

J'avais quelques projets avec Commentator, mais un seul a survécu au contact avec toutes les autres langues. L'un a provoqué des erreurs dans Jelly (iirc) et je n'ai pas pu le résoudre car je ne sais pas pourquoi Jelly a interprété les octets de la façon dont il l'a fait.

4. Gelée , A000312

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

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

Explication:

Nous ne prenons en compte que la dernière ligne, toutes les autres lignes sont ignorées.

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

Pour que C # ignore le code, nous essayons de le mettre dans un commentaire. Cependant, une ligne commençant par /n'est pas valide dans Jelly, car a /besoin d'un opérande. L'opérande que nous utilisons ici l'est ;, car il convient également parfaitement comme point-virgule en C #. En fait, le point-virgule et le commentaire multiligne vide forment ensemble un lien qui calcule 2 z = z z . Notez que la soumission de fonction en C # est toujours valide, car il n'y a pas de consensus général interdisant plusieurs déclarations dans une soumission de fonction anonyme (par exemple les importations).$^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
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Je n'aurais jamais pensé voir le jour où je pourrais ajouter une réponse Java comme 16ème réponse dans une chaîne polyglotte! :RÉ

1. Essayez-le en C #: $a(n)=40-n$
2. Essayez-le dans brainfuck: $a(n)=1+n\text{ mod }2$
3. Essayez-le dans Runic Enchantments: $a(n)=4^n$
4. Essayez en Jelly: $a(n)=n^n$
5. Essayez-le dans Gol> <>: $a(n)=-n$
6. Essayez-le en JavaScript: $a(n)=1$
7. Essayez-le en parenthèse: $a(n)=1\text{ if }x^n+y^n=z^n\text{ has a nontrivial solution in integers, otherwise }a(n)=0$
8. Essayez-le en blanc: $a(n)=3$
9 Essayez-le dans 05AB1E: $a(n)=0$
10. Essayez-le dans Illisible: $a(n)=n$
11. Essayez-le dans Grass: $a(n) = \lfloor n/10^\left(\lfloor log_{10}(n)\rfloor\right)\rfloor$
12. Essayez-le en largeur: $a(n)=n+1\text{ with }n\geq2$
13. Essayez-le en AlphaBeta: $a(n)=1\Vert n$
14. Essayez-le dans Aheui: $a(n)=2$
15. Essayez-le dans Commentator. $a(n)=2n+6$
16. Essayez-le en Java 8: $a(n)=n^2$

Explication:

Permettez-moi de commencer en disant que bien que j'aie entendu parler de chacun de ces langages avant ici sur CGCC, je ne suis compétent qu'avec Java, C #, 05AB1E et Whitespace, et à part cela, je peux lire la partie JavaScript du code. Les autres langages ne me sont généralement pas familiers, donc j'espérais qu'après les changements que j'avais en tête pour faire interagir Java avec C # / JavaScript, la plupart des autres langages continueraient de fonctionner.

La première chose principale à aborder était Java n->vs C # / JavaScript n=>. Java prend en charge les valeurs unicode dans le cadre du code, utilisez donc les éléments suivants:

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

Sera interprété comme ceci en C # / JavaScript:

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

Mais comme cela en Java:

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

En effet, \u000Aest un saut de ligne, \u002Fest /et \u002Aest *en Java.

Ensuite, pour différencier la séquence entre Java et C # / JavaScript, j'ai ajouté ce qui suit:

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

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

Pourquoi ça marche? En Java, les chaînes sont des objets, où ==est utilisé pour vérifier si les références des objets pointent vers le même endroit (ou pour vérifier si les primitives sont égales), et le réel Object.equals(Object)doit être utilisé pour vérifier si les valeurs de ces objets sont les mêmes. Il en ""+n==""+nsera de même pour Falsey en Java, mais en vérité en C # / JavaScript.

Après avoir résolu ce problème (en réutilisant les nouvelles lignes existantes pour ne pas interrompre le programme Whitespace), certaines choses ont dû être corrigées. Quatre des programmes existants échouaient maintenant: Enchantements runiques, Gelée, Illisible et Commentateur.

Le correctif pour Illisible était facile. Nous en avons ajouté quatre """"avant le premier ', donc nous avons simplement mis 'quelque part plus tôt (je l'ai placé à la fin de la première ligne), et supprimons le début '""""de la partie illisible du code en bas.

Après cela est venu Jelly, qui donnait un IndexError: pop from empty list. Je ne suis pas trop habile en Jelly, donc je ne sais pas exactement pourquoi cela a donné cette erreur. Si je me souviens bien, la dernière ligne sera le lien principal d'un programme Jelly, et parce que le code de cette dernière ligne n'utilise aucun des autres liens, tout le reste doit être ignoré. Mais d'une manière ou d'une autre, la partie ""+n==""+nposait encore quelques problèmes. J'ai pu résoudre ce problème en ajoutant /**/devant cette ligne.

Quant aux enchantements runiques, ils ne produisaient plus rien. @ Draco18s m'a fait remarquer que les enchantements runiques commencent du tout >simultanément, mais seuls les >2?1:40-n/et /ip@étaient pertinents. Ce fut une grande aide pour comprendre le déroulement du programme enchantements runiques, et je suis en mesure de fixer le chemin en ajoutant un /**/au >2?1:40-/**/n:n*n, et en changeant les positions du //ip@, //et l' espace sur la dernière ligne.

Il ne restait plus que le commentateur. À ce moment-là, je me suis rendu compte que mes correctifs précédents d'ajout /**/n'étaient pas une si bonne idée après tout, car cela produirait un tas de détritus supplémentaires en raison des fonctions intégrées /*(conversion active en caractère unicode et sortie) et */(sortie active en tant que numéro) ..>.> Après un peu de tripotage et d'essayer certaines choses, le correctif s'est avéré très facile: j'ai ajouté un eavant le #sur la première ligne. e#est la fonction intégrée pour annuler un actif, corrigeant les problèmes causés par le code que j'ai ajouté (apparemment).

6. JavaScript (Node.js) , A000012

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

C # (A022996) : puisque 5/2==2la fonction retourne 40-n(ligne 2)

BF (A000034) : la partie ajoutée ne fait que pousser la bande entière d'une cellule vers la droite, les autres inchangées (ligne 2-3)

Runique (A000302) : L' ?après 2saute le 1:, et d'autres opérations découlent de 4(Ligne 2)

Gelée (A000312) : dernière ligne inchangée

Gol> <> (A001489) : Première colonne inchangée

JS (ES6) (A000012) : puisque 5/2>2la fonction retourne 1(ligne 2)

Inséré le ternaire 5/2>2?1:40-ndans la partie C #. En C # depuis 5/2==2le retour de la fonction 40-n, tandis qu'en JS 5/2>2les fonctions retournent 1. Les commentaires de style C ont rendu presque impossible l'ajout de langages plus pratiques (spécifiquement C et Python). Plus d'espaces sont ajoutés sur les lignes 4-5 pour s'assurer que la partie runique fonctionne.

8. Les espaces blancs , 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
//
 ;/**/

Essayez-le en ligne!

C #
Brainfuck
Runic
Jelly
Gol> <>
Javascript
paranthétique

Je n'ai aucune idée du fonctionnement de Whitespace. J'ai essayé très fort de multiplier l'entrée avec une autre valeur, mais cela ne cessait de se plaindre de l'arithmétique des infixes, donc comme j'avais des entrées qui fonctionnaient, des sorties qui fonctionnaient et des push-value-to-stack qui fonctionnaient, alors je suis juste allé avec ça.

La valeur d'entrée semble se perdre en poussant 3vers la pile, mais bon. Profitez d'une séquence de 3s. Techniquement, le programme prend des entrées, il finit par les rejeter.

_{Je ne sais pas non plus comment fonctionne Paranthetic, donc je ne peux pas réellement vérifier que la soumission est valide, mais pour autant que je sache, le code des espaces blancs n'interfère pas.}

_{Réponses futures: sachez que les onglets dans Runic sont une seule instruction et jouent des ravages avec la disposition du code.}

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

Essayez-le en ligne!

Grass ignore tous les caractères sauf w, vet W; commodément, ces trois caractères sont ignorés par plusieurs des langues précédemment utilisées. Heureusement, la séquence A000030 (renvoyer le chiffre initial en base 10) était toujours disponible, car le codage de fonctions même légèrement compliquées dans Grass est au-delà de mes capacités.

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

La partie pertinente pour Grass est wvWwwWWwwwwwwWwWWWw. Voici ma compréhension (probablement erronée) de son fonctionnement: la pile est initialisée en tant que OUT::SUCC::w::IN::ε(c'est wjuste le personnage w). Chaque instruction ajoute un élément à la pile (elles ne sont jamais sautées); le nombre de ws ou Ws indique la profondeur à parcourir dans la pile; vsépare les instructions.

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 l'entrée est 1234, à la fin, la pile ressemble probablement ceci: 1::1::id IN::id OUT::id::OUT::SUCC::w::IN::ε.

Il pourrait être raccourci (pas besoin de définir id OUTpar exemple), mais je me suis arrêté dès que j'ai trouvé une version qui fonctionnait.

Si quelqu'un qui connaît Grass veut corriger / améliorer l'explication, veuillez modifier ma réponse!

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

Interprète en ligne

Gelée d' enchantements runiques C #
Brainfuck


Gol> <>
Javascript (Node.js) (Tous les 1s)
Parenthétique
Whitespace (Toutes les 3s)
05AB12 (Toutes les 0s)
Illisible
Herbe
Largeur
AlphaBeta
Aheui (Toutes les 2 secondes)
Commentateur
Java

Vous devrez excuser le lien Pepe pour ne pas contenir la source complète: l'interprète ne tient pas compte de tout code qui n'est pas Pepe (allumé tout caractère ne figurant pas dans l'ensemble RE re) et donc son lien court ne dérange pas de l'encoder. Idem valeurs d'entrée.

$a(n) = n^3$

L'AlphaBeta a commencé à lancer des erreurs après avoir écrit la sortie, mais comme une réponse précédente a injecté ce problème, je l'ai laissé seul. J'avais prévu de le corriger pour cette réponse, mais je dois passer un peu de temps à creuser dans les décalages de saut pour résoudre le problème. L'erreur avec les entrées >0est facile à corriger, mais le donner 0produira la même erreur et il faudra du temps pour réapprendre le code afin de corriger le décalage pour lui. J'aimerais pouvoir utiliser à la Wplace de UUUUUUUUUU, mais cela fait des ravages avec le code Grass.

1. C # (compilateur interactif Visual C #) A022996

n=>40-n

Fonctionne également en C # (.NET Core), C # (compilateur Mono C #), C # (shell Mono C #) et C # (compilateur Visual C #)

Essayez-le en ligne!

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 # compilateur interactif)
brainfuck
Runic enchantements
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)

Runique (A000302)

Gelée (A000312)

Gol> <> (A001489)

JS (ES6) (A000012)

Parenthétique (A019590)

Parenthétique ignore tout sauf les caractères (et ). J'ai dû insérer des 1s avant chaque parenthèse fermante pour empêcher Jelly de paniquer (EDIT: j'en ai laissé un )sans précédent par un 1, donc apparemment ils n'en ont pas tous besoin d'un, mais il est trop tard pour le jouer maintenant). Le code réel définit un lambda appelé ((())), qui peut être appelé sur un nombre pour donner le résultat (indexé 1).

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

Essayez-le en ligne!

Gelée runique C #
Brainfuck


Gol> <>
Javascript
Paranthetic
Whitespace
05AB1E

Illisible, comme son nom l'indique, est illisible. Afin de le programmer, j'ai dû utiliser un modèle, puis convertir un texte lisible en un code illisible.

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

Il ne fait que lire chaque caractère dans l'entrée et le sortir. Une des séquences les plus ennuyeuses, mais bonne pour une langue difficile à travailler. J'ai aussi joué avec la séquence A000030 avant de faire fonctionner la boucle.

_{Travailler via un bureau à distance est pénible, vous pensez que les choses fonctionnent, faites tous les liens, puis réalisez que l'un d'eux s'est cassé et n'a pas remarqué.}

14. Aheui , A007395

Légèrement changé pour que AlphaBeta fonctionne.

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

Essayez-le en ligne!

Aheui rejette tout caractère non coréen, donc 박망희excusé, qui imprime2 et se termine.

C #
Brainfuck
Runic enchantements
Jelly
Gol> <>
Javascript (Node.js)
parenthetic
Whitespace
05AB12
Illisible
Herbe
Largeur
AlphaBeta
Aheui

2. brainfuck , A000034

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

Essayez-le en ligne!

C #

3. Enchantements runiques , A000302

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

Essayez-le en ligne!

C #

BF

Si vous avez besoin d'aide pour garder la fonctionnalité Runic, il y a l' IDE ésotérique ainsi que mon propre IDE (intégré à Unity3D) dans la branche principale du dépôt git de Runic . IDE ésotérique ne gère pas très bien l'affichage de la directionnalité IP (principalement ma propre incapacité à l'ajouter au cadre existant).

Tout le BF crée un tas d'IP qui se terminent automatiquement en raison de l'exécution d'actions non valides (principalement en raison d'un débordement de pile) tandis que >le C # remplit la pile avec un 4, rebonds des fabricants de commentaires (miroirs dans Runic), atteignant ip@pour s'exécuter x^4sur un saisissez x et imprimez le résultat.

5. Gol> <> , A001489

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

Essayez-le en ligne!

Gelée runique C #
Brainfuck

Utilisez des marqueurs de commentaire sur une seule ligne en C # pour rediriger l'IP Fish vers le code opérationnel I01-*h, en lisant l'entrée, en la multipliant par -1 et en sortant le résultat. Gol> <> a rendu la lecture d'entrée et le vidage de la pile comme un nombre facile par rapport à raw> <>.

Espaces insérés pour assurer le bon flux des adresses IP poisson et runique, où C # et Jelly ignorent le premier espace blanc sur la dernière ligne (et est une cellule NOP dans les deux fungoids).

12. Largeur , 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 indexé. Sorties par code de sortie.

Essayez-le en ligne!

Les seuls caractères pertinents pour la largeur sont a-zA-Z. La largeur du code s'exécute est la suivante:

qnnAcaAcAAI

Les trois premiers caractères qnn,, sont sans opération. Aclit un entier à partir de l'entrée, aest un no-op, puis AcAAincrémente l'entier d'une unité. Itermine le programme et le haut de la pile devient le code de sortie. Toutes les autres lettres du programme sont ignorées depuis la fin du programme.

C #
brainfuck
Runic enchantements
Jelly
Gol> <>
JavaScript
parenthetic
Whitespace
05AB1E
Illisible
Herbe

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

Essayez-le en ligne!

J'avais initialement prévu d'utiliser la séquence A000030 et le code JCL, mais cela a été ignoré (je ne leur en veux pas, c'est une bonne séquence pour les langues qui prennent les entrées en octets uniques). Le code d'origine pour cette entrée après avoir dû choisir une nouvelle séquence était:

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)

Séquences de xxx ou xyzxyzsont des espaceurs utiles pour rendre les cibles de saut faciles (46 est plus facile comme "5 * 10-4" - 9 instructions - que "4 * 10 + 6 - dix instructions - mais 50 est pair plus simple: cinq seulement. Vous en verrez quelques-unes.

Mais comme il y a d'autres octets sur la première ligne, les codels de saut avaient besoin de nouvelles valeurs et cela s'est transformé en:

//0q   xxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzWRxyxyzcccccbbCL

Éviter d'exécuter ce code en tant que code Width impliquait simplement de l'enrouler Gpour en faire un littéral de chaîne (ce qui n'a rien d'important dans AlphaBeta), une commande pour faire apparaître le haut de la pile, puis quelques extras Wpour que la version alpha beta ne se bloque pas lors de la sortie:

//0q   GxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzWWWWWWRxyxyzcccccbbCLGw

Pour éviter les conflits avec Grass, au lieu de sauter, la commande w Cest utilisée à la place. Ensuite, le saut "exit program" est remplacé par UUUUUUau lieu de WWWWWWCela laisse l'IP quelque part au milieu du reste du code indésirable, mais suffisamment loin pour qu'il n'imprime aucune erreur. N'importe quel nombre de Us supplémentaires peut être ajouté par paires si cela devient un problème.

//0q   GxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzUUUUUURxyxyzcccccbbCLGC

Le supplément i que Runic finit par exécuter est un NOP sur des entrées valides car aucune entrée-gauche à lire ne pousse rien dans la pile ("lire toutes les entrées" est un problème dans Runic).

C #
brainfuck
Runic enchantements
Jelly
Gol> <>
JavaScript
parenthetic
Whitespace
05AB1E
Illisible
Herbe
Largeur

18.] = [, A010716 , la séquence des 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
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Ce langage est pas TIO et son seul interprète lui - même est écrit dans un autre langage interprété, qui est également pas TIO. Et celui qui n'a pas bien joué avec Brainfuck la semaine dernière à la dernière minute, mais j'ai compris ce qui n'allait pas quelques heures après avoir posté la réponse de Pepe, alors je l'ai gardée pour cette semaine. Étant une langue qui n'est pas sur TIO, je considérais celle-ci comme un as dans le trou qui pouvait facilement être clouée sur à peu près N'IMPORTE QUELLE entrée et continuer la chaîne.

• Code d'interprète: https://pastebin.com/raw/yqtpynnh
• Interprète interprète: https://12me21.github.io/12-basic/

Mettez le code de l'interpréteur dans la case "code" en haut, le code de la réponse dans l'entrée, puis cliquez sur exécuter et obtenez une sortie (plus quelques ordures supplémentaires qui sont toujours imprimées).

La partie opérationnelle du] = [est celle-ci à la fin de la première ligne:

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

Son qui fuite [qui a décimé le Brainfuck (le reste étant ignoré, en raison de la façon dont [et ]sont gérés par Brainfuck) et une fois que je regardais à nouveau je me suis rendu le problème spec Brainfuck et que tout ce que je devais faire était insérer un ]quelque part après la première ligne (comme l'interpréteur] = [ne lit pas les sauts de ligne) et avant le Brainfuck. J'ai choisi la 2ème ligne.

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
Illisible
Herbe
Largeur
AlphaBeta
Aheui (esotope)
Commentateur
Java (OpenJDK 8)
Pepe

19. En fait , 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
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Essayez-le en ligne!

Partie opérationnelle: ,2*1z⌂(première ligne)

À la ⌂fin du programme, aucun du code après lui n'a d'effet, et aucun des symboles avant qu'il n'entraîne une sortie ou pollue la mémoire opérationnelle de manière défavorable. La section existe dans un commentaire (C #, JS, Java), ne contient que des caractères ignorés (commentateur,] = [, Pepe, Aheui ...), n'est pas sur la dernière ligne (Jelly), ou autrement dans les parties non exécutées de le code (Gol> <>, Runic, AlphaBeta).

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
Illisible
Herbe
Largeur
AlphaBeta
Aheui (esotope)
Commentateur
Java (OpenJDK 8)
Pepe
] = [(lien pas possible, voir # 18 pour les instructions)

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

Essayez-le en ligne!

Je ne sais pas comment fonctionne le diable Neim. Je sais ce que le code finit par faire ici, mais je n'ai aucune idée du fonctionnement du langage lui-même.

Il s'avère également que j'ai foiré le Brainfuck avec le # 19. En raison des conflits de commandes entre plusieurs langues, la modification de l'entrée d'Actually §puis sa compression en int avec ≈était la solution optimale.

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
Illisible
Herbe
Largeur
AlphaBeta
Aheui (esotope)
Commentateur
Java (OpenJDK 8)
Pepe
] = [(lien pas possible, voir # 18 ) En
fait ,

21. Flobnar , A010709 (tous les 4)

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

Essayez-le en ligne!

Flobnar commence à @et se développe vers l'extérieur en évaluant les éléments selon les règles ( @évalue à tout ce qui est à gauche, 4évalue à 4, +évalue à tout ce qui est à gauche additionné à tout ce qui est à droite, etc.). Comme le placement du @seul entre en contact avec Runic, un simple! empêche l'altération de la pile de Runic.

Étant donné que la métrique d'entrée de Flobnar est "un octet" et entre dans une boucle infinie s'il n'y a pas d'octets à lire, j'ai décidé de ne pas m'embêter avec quelque chose de plus complexe.

Langues précédentes

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
Illisible
Herbe
Largeur
AlphaBeta
Aheui (esotope)
Commentateur
Java (OpenJDK 8)
Pepe ] = [(lien pas possible, voir # 18 ) En
fait
Neim