Este é um desafio de encadeamento de respostas relacionado ao OEIS.

Ah, a justificativa para isso é porque uma empresa precisa de um programa para imprimir suas seqüências OEIS muito ruins e elas têm todos os idiomas.

O formato de encadeamento de respostas funciona da seguinte maneira:

Alguém postou a primeira resposta, da qual todas as outras soluções derivam. Esta resposta é um programa que, dado um número N, insere o número enésimo na sequência OEIS de qualquer índice que escolher (chamaremos de sequência 1), em qualquer idioma que escolherem (idioma 1)

Outra pessoa aparece e escolhe sua própria sequência (que deve ser diferente da anterior e de todas as seqüências anteriores). Eles criam um programa, em outro idioma (que deve ser diferente de todos os idiomas anteriores), que, dado um número N no idioma 1, gera o enésimo número da sequência 1 e, dado um número no idioma 2, gera o enésimo número da sequência 2)

Esse processo continua ad infinitum.

O enésimo termo de uma sequência é o termo que vem n vezes após o primeiro, trabalhando a partir do primeiro item. Aqui usamos a indexação 0 e 1, para facilitar os codificadores!

Não há reutilização de idioma ou sequência.

A entrada deve ser um número inteiro ou uma representação de seqüência de caracteres de um número inteiro e a saída deve ser o valor correto da sequência. O tratamento de erros (entrada não int) não é necessário.

Você não deve postar duas vezes seguidas.

Você deve esperar uma hora ou mais antes de publicar novamente.

Quem for o penúltimo a postar após uma semana sem respostas (a pessoa que não quebrou a cadeia) vence, embora o concurso possa continuar indefinidamente. Se você é o último e pode mostrar que pode adicionar mais um idioma, continue o desafio até o próximo vencedor.

Você pode assumir que a entrada ou a saída não estará fora do intervalo numérico do seu idioma (por exemplo, assumindo que o limite do IEEE não será ultrapassado por nenhuma sequência), mas não seja um trapaceiro e abuse disso usando um idioma que possui apenas 1.

Qualquer sequência pode ser escolhida, desde que não tenha sido usada antes.

A entrada não pode estar fora dos limites da sequência que você está usando.

Duas versões de idiomas diferentes são linguagens diferentes (Python 2 e Python 3 são considerados diferentes idiomas próprios). Isso não é rígido, mas como regra geral, se for separado de outra versão do mesmo idioma no TIO, é diferente.

Isso não é proibido, mas tente uma vez não usar a fórmula fornecida pelo OEIS.

Se o seu código resultante tiver mais de 65536 caracteres, forneça um link para acessá-lo (por exemplo, Pastebin).

É isso e é tudo. Pronto? Conjunto? DIVERSÃO!

Sim, este é "um OEIS após o outro", mas é multijogador. Eu pensei que seria legal.

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

Experimente online!

C #
Brainfuck
Encantos rúnicos
Jelly
Gol> <>
Javascript (Node.js) (Todos os 1s)
Espaço em
branco parênteses (Todos os 3s)
05AB12 (Todos os 0s) Largura de grama
ilegível AlphaBeta Aheui (Todos os 2s)

Eu tinha alguns planos com o Commentator, mas apenas um sobreviveu ao contato com todos os outros idiomas. Um causou erros no Jelly (iirc) e eu não consegui resolvê-lo porque não sei por que o Jelly interpretou os bytes da maneira que fez.

4. Jelly , A000312

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

C # (Compilador Interativo Visual C #)
brainfuck Jelly
Enchantments Runic

Explicação:

Contamos apenas com a última linha, todas as outras linhas são ignoradas.

;/**/ 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 fazer o C # ignorar o código, estamos tentando colocá-lo em um comentário. No entanto, uma linha iniciada por /não é válida no Jelly, porque /precisa de um operando. O operando que estamos usando aqui é ;, pois ele também se encaixa perfeitamente como ponto e vírgula em C #. De fato, o ponto-e-vírgula e o comentário multi-linhas vazio juntos formam um link que calcula 2 z = z z . Observe que o envio da função em C # ainda é válido, pois não há consenso geral que não permita várias instruções no envio de uma função anônima (por exemplo, importações).$^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 pensei que veria o dia em que seria capaz de adicionar uma resposta Java como 16ª resposta em uma cadeia poliglota! : D

1. Experimente em C #: $a(n)=40-n$
2. Experimente em cérebro: $a(n)=1+n\text{ mod }2$
3. Experimente em Encantos Rúnicos: $a(n)=4^n$
4. Tente em Jelly: $a(n)=n^n$
5. Experimente em Gol> <>: $a(n)=-n$
6. Experimente em JavaScript: $a(n)=1$
7. Experimente em Parenthetic: $a(n)=1\text{ if }x^n+y^n=z^n\text{ has a nontrivial solution in integers, otherwise }a(n)=0$
8. Experimente no espaço em branco: $a(n)=3$
9 Experimente em 05AB1E: $a(n)=0$
10. Experimente em Ilegível: $a(n)=n$
11. Experimente em Grass: $a(n) = \lfloor n/10^\left(\lfloor log_{10}(n)\rfloor\right)\rfloor$
12. Experimente em Largura: $a(n)=n+1\text{ with }n\geq2$
13. Experimente em AlphaBeta: $a(n)=1\Vert n$
14. Experimente em Aheui: $a(n)=2$
15. Experimente no Commentator. $a(n)=2n+6$
16. Experimente no Java 8: $a(n)=n^2$

Explicação:

Deixe-me começar dizendo que, embora tenha ouvido falar de cada uma dessas linguagens antes aqui no CGCC, só sou habilitado em Java, C #, 05AB1E e Whitespace e, além disso, pode ler a parte JavaScript do código. Como as outras linguagens não são familiares para mim, esperava que, depois das mudanças que eu tinha em mente, fizesse o Java interagir com C # / JavaScript, a maioria das outras linguagens ainda funcionaria.

A primeira coisa principal a enfrentar foi o Java n->vs C # / JavaScript n=>. Java suporta valores unicode como parte do código, usando o seguinte:

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

Será interpretado como este em C # / JavaScript:

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

Mas como isso em Java:

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

Isso ocorre porque \u000Aé uma quebra de linha,\u002F é /e \u002Aestá *em Java.

Em seguida, para diferenciar a sequência entre Java e C # / JavaScript, adicionei o seguinte:

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

onde ...está o existente 5/2>2?1:40-ne n*né a parte Java do código para a sequência oeis A000290 (quadrados aka $a(n)=n^2$ ).

Por que isso funciona? Em Java Strings are Objects, onde ==é usado para verificar se as referências de objetos estão apontando para o mesmo local (ou para verificar se as primitivas são iguais) e a realObject.equals(Object) deve ser usado para verificar se os valores desses objetos são iguais. O ""+n==""+nmesmo acontece com falsey em Java, mas em C # / JavaScript.

Depois que isso foi resolvido (reutilizando as novas linhas existentes para não interromper o programa Whitespace), algumas coisas tiveram que ser corrigidas. Quatro dos programas existentes estavam falhando agora: encantamentos rúnicos, geléia, ilegível e comentarista.

A correção para Ilegível foi fácil. Nós adicionamos quatro """"antes da primeira ', então simplesmente colocamos a em 'algum lugar mais cedo (eu a coloquei no final da primeira linha) e removemos as'"""" da parte Ilegível do código na parte inferior.

Depois disso veio Jelly, que estava dando uma IndexError: pop from empty list. Eu não sou muito habilidoso em Jelly, então não sei exatamente por que isso deu esse erro. Se bem me lembro, a última linha será o link principal de um programa Jelly, e como o código nessa última linha não usa nenhum dos outros links, todo o resto deve ser ignorado. Mas de alguma forma a parte""+n==""+n ainda deu alguns problemas. Consegui consertar isso adicionando /**/na frente dessa linha.

Quanto aos encantamentos rúnicos, ele não produzia mais nada. @ Draco18s me indicou que os Encantos Rúnicos começam >simultaneamente, mas apenas os >2?1:40-n/e /ip@eram relevantes. Esta foi uma grande ajuda para entender o fluxo do programa Encantos da Rúnica, e eu pude corrigir o caminho adicionando um /**/at >2?1:40-/**/n:n*ne alterando as posições do //ip@,// e espaço na última linha.

Tudo o que resta foi comentarista. Naquele momento, percebi que minhas correções anteriores de adição /**/não eram uma boa idéia, afinal, uma vez que geraria um monte de lixo adicional devido aos componentes internos /*(converter ativo em caractere e saída unicode) e */(saída ativa como número) ..>.> Depois de um pouco de mexer e tentar algumas coisas, a correção acabou sendo muito fácil: eu adicionei um eantes do #na primeira linha. e#é o builtin para negar um ativo, corrigindo os problemas causados ​​pelo código que adicionei (aparentemente).

6. JavaScript (Node.js) , A000012

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

C # (A022996) : Como 5/2==2a função retorna 40-n(Linha 2)

BF (A000034) : A parte adicionada apenas empurra a fita inteira uma célula para a direita, outras inalteradas (Linha 2-3)

Rúnico (A000302) : O ?depois 2pula as 1:operações e outras seguem de 4(Linha 2)

Gelatina (A000312) : última linha inalterada

Gol> <> (A001489) : primeira coluna inalterada

JS (ES6) (A000012) : Como 5/2>2a função retorna 1(Linha 2)

Infiltrou o ternário 5/2>2?1:40-nna parte C #. Em C # desde que 5/2==2a função retorna 40-n, enquanto em JS 5/2>2as funções retornam 1. Os comentários no estilo C tornaram quase impossível adicionar linguagens mais práticas (especificamente C e Python). Mais espaços são adicionados nas linhas 4-5 para garantir que a parte rúnica funcione.

8. Espaço em branco , 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
//
 ;/**/

Experimente online!

C #
Brainfuck
Runic
Jelly
Gol> <>
Javascript
Paranthetic

Não faço ideia de como o Whitespace funciona. Tentei muito multiplicar a entrada por outro valor, mas ele continuava reclamando da aritmética do infix, assim como eu trabalhava na entrada, na saída e no push-value-to-stack, então continuei com isso.

O valor de entrada parece se perder ao empurrar 3para a pilha, mas tudo bem. Desfrute de uma sequência de 3s. Tecnicamente, o programa recebe entrada , acaba descartando-a.

_{Também não sei como o Paranthetic funciona, por isso não posso verificar se o envio é válido, mas, até onde sei, o código de espaço em branco não interfere.}

_{Respostas futuras: esteja ciente de que as guias no Runic são uma única instrução ampla e causam estragos no layout do código.}

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

Experimente online!

Grass ignora todos os caracteres w, exceto , ve W; convenientemente, esses três caracteres são ignorados por vários dos idiomas usados ​​anteriormente. Felizmente, a sequência A000030 (retornar o dígito inicial na base 10) ainda estava disponível, pois a codificação de funções ainda um pouco complicadas no Grass está além da minha capacidade.

C #
brainfuck
Runic
Jelly
Gol> <>
JavaScript
parentético
Whitespace
05AB1E
ilegível

A parte relevante para Grass é wvWwwWWwwwwwwWwWWWw. Aqui está o meu (provavelmente falho) entendimento de como ele funciona: a pilha é inicializada como OUT::SUCC::w::IN::ε(esse wé apenas o personagem w). Cada instrução adiciona um elemento à pilha (eles nunca são exibidos); o número de ws ou Ws indica a profundidade da pilha; vsepara as instruções.

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 a entrada é 1234, no final, a pilha provavelmente se parece com isso:1::1::id IN::id OUT::id::OUT::SUCC::w::IN::ε .

Pode ser reduzido (não é necessário definir id OUT por exemplo), mas parei assim que encontrei uma versão que funcionava.

Se alguém que conhece Grass quiser corrigir / melhorar a explicação, edite minha resposta!

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 Online

C #
Brainfuck
Encantos rúnicos
Jelly
Gol> <>
Javascript (Node.js) (Todos os 1s)
Espaço em
branco parênteses (Todos os 3s)
05AB12 (Todos os 0s) Largura de grama
ilegível AlphaBeta Aheui (Todos os 2s) Comentador Java

Você terá que desculpar o link Pepe por não conter a fonte completa: O intérprete desconsidera qualquer código que não seja Pepe (aceso. Qualquer caractere que não esteja no conjunto RE re ) e, portanto, seu link curto não se preocupa em codificá-lo. O mesmo vale para os valores de entrada.

$a(n) = n^3$

O AlphaBeta começou a gerar erros após escrever a saída, mas como resposta anterior injetou esse problema, eu o deixei em paz. Eu tinha planejado corrigi-lo para esta resposta, mas preciso dedicar algum tempo a analisar as compensações de salto para resolver o problema. O erro com as entradas >0é fácil de corrigir, mas fornecer 0o mesmo erro e levar um tempo para reaprender o código, a fim de corrigir o deslocamento para ele. Eu gostaria de poder usar em Wvez de UUUUUUUUUU, mas isso causa estragos no código Grass.

1. C # (compilador interativo do Visual C #) A022996

n=>40-n

Também funciona em C # (.NET Core), C # (compilador Mono C #), C # (Shell mono C #) e C # (Visual C # Compiler)

Experimente 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 # (compilador interativo de Visual C #)
brainfuck
Encantos rúnicos
Jelly
Gol> <>
JavaScript (Node.js) Espaço em branco
parênteses 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)

Gelatina (A000312)

Gol> <> (A001489)

JS (ES6) (A000012)

Parêntese (A019590)

Parenthetic ignora tudo, menos os caracteres (e ). Eu tive que inserir 1s antes de todos os parênteses de fechamento para impedir que Jelly surtasse (EDIT: eu deixei um )sem precedentes por 1, então aparentemente nem todos eles precisam de um, mas é tarde demais para jogar agora). O código real define um lambda chamado ((())), que pode ser chamado em um número para produzir o resultado (indexado 1).

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

Experimente online!

C #
Brainfuck
Runic
Jelly
Gol> <> Espaço em branco paranthetic
Javascript 05AB1E

Ilegível, como o próprio nome sugere, é ilegível. Para programá-lo, tive que usar um modelo e depois converter de texto legível em código ilegível.

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

Tudo o que faz é ler cada caractere na entrada e enviá-lo. Uma das sequências mais chatas, mas boa para um idioma difícil de trabalhar. Também brinquei com o uso da sequência A000030 antes de fazer o loop funcionar.

_{Trabalhar na área de trabalho remota é uma dor, você acha que as coisas funcionam, faz todos os links e percebe que um deles quebrou e não percebeu.}

14. Aheui , A007395

Ligeiramente alterado para fazer o AlphaBeta funcionar.

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

Experimente online!

Aheui rejeita qualquer caractere não coreano, tão 박망희excutado, que imprime 2e termina.

C #
Brainfuck
Encantos rúnicos
Jelly
Gol> <>
Javascript (Node.js) Espaço em branco
parênteses 05AB12 Largura ilegível da grama AlphaBeta Aheui

2. brainfuck , A000034

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

Experimente online!

C #

3. Encantos Rúnicos , A000302

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

Experimente online!

C #

BF

Se você precisar de ajuda para manter o Runic funcional, existe o IDE Esotérico e o meu próprio IDE (incorporado no Unity3D) no ramo principal do repositório git do Runic . O IDE esotérico não lida com a exibição da direcionalidade do IP muito bem (principalmente minha própria incapacidade de adicionar isso à estrutura existente).

Todo o BF cria um monte de IPs que terminam automaticamente devido à execução de ações inválidas (principalmente devido ao fluxo insuficiente da pilha) enquanto >o C # preenche a pilha com a 4, rejeições dos criadores de comentários (espelhos no Runic), alcançando ip@a execução x^4em um insira xe imprima o resultado.

5. Gol> <> , A001489

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

Experimente online!

C #
Brainfuck
Runic
Jelly

Use marcadores de comentário de linha única em C # para redirecionar o IP do Fish para o código operacional, I01-*h , lendo a entrada, multiplicando por -1 e exibindo o resultado. Gol> <> facilitou a leitura e despejou a pilha como um número em comparação com o bruto> <>.

Espaços inseridos para garantir o fluxo adequado dos IPs Fish e Rúnico, onde C # e Jelly ignoram o espaço em branco líder na última linha (e é uma célula NOP nos dois fungoides).

12. Largura , 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. Saídas por código de saída.

Experimente online!

Os únicos caracteres relevantes para Largura são a-zA-Z. O código Width é o seguinte:

qnnAcaAcAAI

Os três primeiros caracteres qnn,, são no-ops. Aclê um número inteiro da entrada, aé um no-op e, em seguida, AcAAincrementa o número inteiro em um. Ifinaliza o programa e o topo da pilha se torna o código de saída. Todas as outras letras do programa são ignoradas desde que o programa foi encerrado.

C #
brainfuck
Encantamentos rúnicos
Jelly
Gol> <> Espaço em branco parênteses
JavaScript 05AB1E Grama ilegível

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

Experimente online!

Inicialmente, eu planejara usar a sequência A000030 e o código JCL, mas isso foi interrompido (não os culpo, é uma boa sequência para idiomas que recebem entrada como bytes únicos). O código original para esta entrada depois de ter que escolher uma nova sequência 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)

Sequências de xxxouxyzxyz são espaçadores úteis para facilitar o salto para os valores (46 é mais fácil como "5 * 10-4" - 9 instruções - do que "4 * 10 + 6 - dez instruções - mas 50 é par mais simples: apenas cinco) Você verá alguns deles.

Mas como existem outros bytes na primeira linha, os codels de salto precisavam de alguns novos valores e que se transformaram em:

//0q   xxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzWRxyxyzcccccbbCL

Evitar a execução desse código como código Width envolveu envolvê-lo Gpara torná-lo uma string literal (o que não faz nada importante no AlphaBeta), um comando para abrir a parte superior da pilha e mais alguns Wpara impedir que o alfa beta travasse ao sair:

//0q   GxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzWWWWWWRxyxyzcccccbbCLGw

Para evitar conflitos com o Grass, no entanto, em vez de exibir o comando, w Cé usado. Em seguida, o salto "exit program" é substituído por, em UUUUUUvez de WWWWWWThis, deixa o IP em algum lugar no meio do restante do código indesejado, mas longe o suficiente para que ele não imprima nenhum erro. Qualquer número de Us adicionais pode ser adicionado em pares, se isso se tornar um problema.

//0q   GxxJiiiiihhZUUUUUUNYAxcccccbCLDLxyzUUUUUTxxyzJCLOzUUUUUURxyxyzcccccbbCLGC

O adicional ique o Runic acaba executando é um NOP em entradas válidas, já que nenhuma entrada deixada para ler não empurra nada para a pilha ("ler todas as entradas" é um problema no Runic).

C #
brainfuck
Encantos rúnicos
Jelly
Gol> <> Espaço em branco parênteses
JavaScript 05AB1E Largura ilegível da grama

18.] = [, A010716 , a sequência dos 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
//
 ;/*""'"""'""""""""""'"""" "'""'"""""""'"""'""""'"'"""""""'"""'""""""'"""'""""""""""*/

Esse idioma não está no TIO e seu único intérprete está escrito em outro idioma interpretado, que também não está no TIO. E o que não foi legal com Brainfuck na semana passada, no último minuto, mas descobri o que havia de errado algumas horas depois de postar a resposta em Pepe, então guardei para esta semana. Sendo um idioma que não está no TIO, eu estava considerando este um ás-no-buraco que poderia ser facilmente colocado em QUALQUER entrada e continuar a cadeia.

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

Coloque o código do interpretador na caixa "código" na parte superior, codifique a resposta na entrada e clique em executar e obter uma saída (mais algum lixo extra que sempre é impresso).

A parte operacional do] = [é esta no final da primeira linha:

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

Sua essa fuga [que estragos jogado com o Brainfuck (o restante sendo ignorados, devido à forma como [e ]são manipulados por Brainfuck) e uma vez eu olhei para o Brainfuck especificação novamente eu percebi o problema e que tudo o que eu tinha a fazer era inserir a ]algum lugar após a primeira linha (como o] = [intérprete não lê novas linhas) e antes do Brainfuck. Eu escolhi a segunda linha.

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
ilegível
Grama
Largura
Alphabeta
Aheui (esotope)
Comentarista
Java (OpenJDK 8)
Pepe

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

Experimente online!

Parte operacional: ,2*1z⌂(primeira linha)

Ao ⌂finalizar o programa, nenhum código após este efeito e nenhum dos símbolos anteriores a ele resulta em saída ou polui adversamente a memória operacional. A seção existe em um comentário (C #, JS, Java), contém apenas caracteres ignorados (Comentador,] = [, Pepe, Aheui ...), não está na última linha (Jelly) ou em partes não executadas de o código (Gol> <>, Runic, AlphaBeta).

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Espaço em
branco
parantético 05AB1E Largura de grama
ilegível AlphaBeta Aheui (esótopo) Comentador Java (OpenJDK 8) Pepe ] = [(link não possível, consulte o item 18 para obter instruções)

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

Experimente online!

Não faço ideia de como o Neim funciona. Eu sei o que o código aqui acaba fazendo, mas não tenho idéia de como a própria linguagem funciona.

Acontece também que eu estraguei o Brainfuck com # 19. Devido a conflitos de comando entre vários idiomas, alterar a entrada do Actually para §e forçá-lo a um int ≈foi a solução ideal.

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Espaço em
branco
parantético 05AB1E Largura de grama
ilegível AlphaBeta Aheui (esótopo) Comentador Java (OpenJDK 8) Pepe ] = [(link não possível, consulte o item 18 ) Na verdade

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

Experimente online!

Flobnar começa @e expande para fora a avaliação de itens conforme as regras determinam ( @avalia o que estiver à esquerda, 4avalia 4, +avalia o que estiver à esquerda somado ao que estiver à direita, etc.). Como a colocação do @único entra em contato com Runic, um simples !impede a alteração da pilha de Runic.

Dado que a métrica de entrada de Flobnar é "um byte" e entra em um loop infinito se não houver bytes para ler, decidi não me preocupar com nada mais complexo.

Línguas anteriores

C #
Brainfuck
Runic
Jelly
Gol> <>
JavaScript (Node.js)
Paranthetic
Whitespace
05AB1E
ilegível
Grama
Largura
Alphabeta
Aheui (esotope)
Comentarista
Java (OpenJDK 8)
Pepe ] = [(ligação não for possível, veja # 18 )
Na verdade
Neim