Esse desafio tem dois tópicos. Este é o tópico dos policiais. O tópico dos ladrões está localizado aqui .

Seu desafio é escolher uma sequência OEIS e escrever dois programas completos em dois idiomas diferentes que produzam o enésimo item na sequência quando um n é dado via STDIN ou outras formas de entrada padrão, onde n é qualquer número positivo. No entanto, seus dois programas devem ser anagramas, o que significa que cada um pode ser reorganizado a partir das letras dos outros.

Os programas devem gerar o decimal do número seguido pelo espaço em branco opcional para STDOUT. Os programas podem ser enviados para STDERR, no entanto, devem ser ignorados e, se o caso oculto ocorrer, deve ser claramente indicado que esse é o caso.

Se desejar, você também pode enviar por código de caractere. No entanto, se você fizer isso em sua solução oculta, deverá declarar isso no corpo de sua submissão.

Você apresentará o número OEIS, o código-fonte e o nome de um idioma em que está.

Os ladrões quebram sua submissão se encontrarem um anagrama da submissão original que é executado em um idioma diferente daquele que você já apresentou. Para decifrar uma resposta, eles devem encontrar apenas qualquer idioma e programa que produza a sequência e seja um anagrama do original, não necessariamente a resposta em que você estava pensando.

Assim, você é incentivado a tornar o mais difícil possível encontrar qualquer idioma que execute a tarefa usando sua lista de símbolos.

Pontuação

Isso é código-golfe, então o programa mais curto e sem quebra é o vencedor.

línguas

Os idiomas serão considerados diferentes se as duas soluções propostas não concluírem a tarefa nos dois idiomas. Isso incluirá versões diferentes do mesmo idioma , desde que a solução do policial ou do ladrão não produza a saída correta no idioma do outro.

ou seja, se houver duas soluções 1 e 2 nos idiomas A e B, respectivamente, a solução 2 não deve produzir a saída correta no idioma A e a solução 1 não deve produzir a saída correta no idioma B.

Segurança

Depois que sua submissão for descomplicada por uma semana, você poderá postar sua solução e declarar sua postagem segura. Se depois de uma semana você optar por não postar uma solução, sua resposta ainda poderá estar quebrada.

Python 2, 118 bytes, A042545 Rachado

i=input();s=1/(801**.5-28);a=[0,1]
for p in range(i):a+=[a[-2]+a[-1]*int(s)];s=1/(s-int(s))
print a[i]#,,,.//000fhlmo|

Não estava com vontade de implementar uma sequência trivial, por isso decidi usar meu ID de usuário PPCG. Eu escrevi isso no outro idioma primeiro, o que deve lhe dar uma pista sobre o que é esse idioma, embora eu aposto 100 dólares em que isso será quebrado em um idioma de golfe antes de ser quebrado no outro idioma pretendido.

Nota: Devido a erros de precisão de ponto flutuante, isso é preciso apenas até uma entrada de 14. A solução pretendida é da mesma maneira.

Solução pretendida, JavaScript (ES7)

for(i=prompt(),s=1/(801**.5-28),a=[1,0];i--;s=1/(s-n))
  n=s|0,a.unshift(a[1]+a[0]*n);
alert(a[0])  //#+2:[]giiiiinnpt

Funciona da mesma maneira que a solução Python, embora a sequência seja armazenada maior primeiro do que menor, devido ao fato de o JS não suportar indexação negativa.

Flak cerebral, 24 bytes, A000290 , Seguro

Mais uma solução quadrada. Desta vez, não há nada além de parênteses

({(({}[()])()){}[()]}{})

A solução pretendida estava no Brain-Flueue , uma versão do brain-flak que usa filas em vez de pilhas. O programa foi:

({(({})[()]){}}{})[()()]

Os idiomas são considerados distintos porque nenhum dos dois programas é interrompido quando executado no outro idioma.

Python 2, 38 bytes, A000290 Rachado por Emigna

def e(X):return X*X
print e(input())##

Provavelmente será muito fácil de quebrar. Estou postando isso principalmente como ponto de partida.

Solução original no CJam:

ri:XX*e#def ()return X
e#pnt (input())

CJam , 7 bytes, A005843 Rachado!

ri2*e#^

Esta é uma 2*nsequência básica .

Explicação:

r          e# read input
 i         e# convert to integer
  2*       e# multiply it by 2
    e#^    e# this is a comment that is ignored by the interpreter

Experimente online!

Solução Original, Cenoura

#^i*2er

Cenoura é um esolang criado por mim. Eu parei de desenvolvê-lo há muito tempo. A razão pela qual escolhi isso é porque esperava que seria difícil para outros idiomas comentar as partes desnecessárias do código.

Explicação:

#^            This pushes the input to the stack (anything before the ^ is the stack)
  i           Convert stack to integer
   *2         Multiply it by 2
     er       These are ignored because they are not Carrot commands
              Implicit output

Experimente online!

2sable , 15 bytes, A000290 , Rachado!

Pulando no mesmo trem n ² : p.

*?"!#$&<=@\^{|}

Experimente online!

Brain-Flak, 44 bytes, A000290 Rachado

<({({})({}[()])}{}))()()()turpentine/"*"*4splint>

Experimente online!

Solução original, Python 2

print(input()**(len(set("{}{}{}[]()<>"))/4))

Excel, 12 bytes, A000012 Rachado

=IF(1=1,1,1)

Talvez não seja o mais difícil, mas divertido de quebrar.

Python 2, 25 bytes, A000583 , quebrado

Y=input("");print`Y**4`,X

Este programa é encerrado com um erro após a impressão da saída.

Meu código oculto (substancialmente diferente da solução quebrada!):

Na verdade , 25 bytes

4,n`*`Y")ii(*nppruttY;="X

Experimente online!

Explicação:

4,n`*`Y")ii(*nppruttY;="X
4,n                        input, repeat 4 times
   `*`Y                    do * until the stack stops changing (fixed-point combinator)
       ")ii(*nppruttY;="X  push this string and immediately pop and discard it

Python, 118 bytes, A042545 , Seguro

i=int(input());s=pow(801.0,0.5);a=[0|0,1]
for Moshprtflmah in range(i):s=1./(s%1);a+=[a[-2]+a[-1]*int(s)];
print(a[i])

Desta vez, funciona em 2 e 3. E não há comentários! O que você vai fazer?

Nota: Como na solução antiga, isso perde precisão após os primeiros 15 termos devido a erros aritméticos de ponto flutuante.

Solução pretendida, JavaScript (ES6)

giiiiinnnnprt:
i=prompt([n=+2]);s=Math.pow(801,.5);for(a=[1,0];i--;a.unshift(a[1]+a[0]*(s|0)))s=1/(s%1)
alert(a[0])   

Embora eu tenha mantido várias versões antigas, de alguma maneira consegui perder essa cópia, mas felizmente juntar as outras não foi muito difícil. Vejo agora que eu tinha um estranho prtem ambos os programas que poderiam ter sido jogados fora. Ah bem.

Python 2, 124 bytes, A144945 , [Seguro]

Se quebrar isso, você ganha uma recompensa de 500 representantes! Muito tarde!

Número de maneiras de colocar 2 rainhas em um tabuleiro de xadrez n X n para que elas se atacem.

Espero que não seja muito fácil. Organizei meu código para que o espaço em branco fique claramente visível. Esses são apenas espaços e novas linhas.

_{Nota: saídas pretendidas da solução via código de caractere}

n=input();print((3+2)*n*n+~0*6*n+1)*n/3;            +6;



























+7+7+7+7+7+7+7+7+7;+++++++++++++++9+9*9*9

Experimente online

Solução pretendida, Headsecks :

r2=ni***p**
(


p((0 ;3+++3;+;/


)





i+++nn
 +)7
n

n+++ 


17+~
 +)7;97++++7


69+9n+ ++7+n 69
 +7+ ++7


**7+++tut

Isso é equivalente ao seguinte programa BF:

>>,[->>>+>>>+>>>+++++<<<<<<<<<]>>>->>>>>>-<<<[[>+<-]>[>>[<<<+>>+>-]<[>+<-]<-]<<<<]>>+++>[-<-[<+<<]<[+[->+<]<+<<]>>>>>]<<<.,.

Fuzzy Octo Guacamole, 26 bytes, A070627 [Seguro]

49++*5^pm#]%:"?:.=:#,|"1:@

Casos de teste:

1 -> 1
3 -> 23
5 -> 1

Solução:

^::::|*?1=#@]","%.#49++5pm

Trabalha em Magistack.

Pitão, 75 bytes, A004526 Leite rachado

Mais um teste divertido do que qualquer coisa, mas:

/Q/////////////////****22222 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2;;;;;

Experimente online!

Solução de leite (convexa):

2/Q2 2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2*2*2*; 2*;                 2; 2; 2;

Experimente online

Solução pretendida (///):

/*///;2/;// ///22/Q//2;///;//;***2222222222222222222222                    

Experimente online

Pega entrada na forma de 2 antes do último ponto e vírgula e gera o número correto de Q's.

A sequência é indexada em 0 (ou seja, 0 é 0, 1 é 0, 2 é 1, ...)

Foram encontrados pequenos erros sintáticos no ///, portanto, editamos todas as soluções.

MATL, 7 bytes, A000217 , quebrado

:sp{1}x

A seqüência é n(n+1)/2(números triangulares), a partir de entrada n=1, conforme especificado pelo desafio: 1, 3, 6, 10, ... (Saída para entrada 0não são garantidos para ser o mesmo nos dois programas).

O programa no outro idioma sai com um erro (após produzir a saída correta em STDOUT).

Experimente online!

:            % Push [1 2 ... n], where n is implicit input
 s           % Sum of that array. Gives the desired result
   p         % Product of that. Gives the same number
    {1}      % Push a cell array containing number 1
       x     % Delete it

Python 2, 37 bytes, A000290 Rachado

print(input()**(1+1))
"'10°3¢','m'"

Python 3, 27 bytes, A000012 , Rachado

Nenhuma entrada desta vez!

if 1:
    if 1:
        print( '1' )

Os recuos são guias, mas não para salvar bytes - eles são necessários para espaços em branco.

Não acho que precise de um link ou explicação do TIO!

(Provavelmente não vai demorar muito para quebrar de alguma forma)

Resposta pretendida (espaço em branco):

-Start-


    if1:if1:print('1')
-End-

(O início e o fim não fazem parte do programa)

Desculpe, esqueci de adicionar que ele imprime no STDERR:

Experimente online!

Guacamole octo difuso , 11 bytes, A001844 [Seguro!]

hha02^d+**+

Uma fenda que esse tipo de trabalho é dh*h++^2*0a, em Pyth. Porém, não é o formato de saída correto.

Meu código ainda está lá fora! (e não está em Pyth)

Casos de teste:

0 -> 1
1 -> 5

Solução:

^++d0ah*2*h

Em Jolf.

WinDbg, 39 bytes, A000007 Rachado por jimmy23013

~e.block{j(0>=@$t0)?@$t0+(1<7);??0}t":"

A difícil sequência de 0**n.

A entrada é feita passando um valor no pseudo-registro $t0.

Minha solução original foi c #:

@t=>(object)(0<@t?0:1)??"$$700~lk.{}+";

JavaScript ES6, 38 bytes, A000290 , Rachado

J=>eval(Array(J).fill(J).join`+`)|2-2;

Este trem quadrado é bem bacana, mas não vai a lugar nenhum rápido. (Entendi? Trem quadrado ? Como em rodas? Não? Ok, tudo bem. Críticos .)

Resposta pretendida: Reticular ( Experimente online! ),

in2Jo;=>eval(Array(J).fill(J).j`+`)|-2
in      take input, convert to number
  2J    raise to the second power
    o;  output and terminate; ignores following chars

MATL , 13 bytes, A002275 Rachado!

i:"@ax'1']
v!

Experimente online!

Explicação:

i           % Grab input
 :          % Push (range(1,input))
  "         % For each element in this range:
   @        %   Push it
    a       %   Is is truthy?
     x      %   Delete it
      '1'   %   Push '1'
         ]  %   End loop
v           % Join all of these '1's together
 !          % Transpose and display

2sable , 13 bytes, A002378 , Rachado!

Esperando não ter perdido nada. Calcula a (n) = n × (n + 1) :

>*?"!&)<=@\\}

Minha versão:

?"\>@&*})<\=!

Ou a versão desdobrada:

  ? " \
 > @ & *
} ) < \ =
 ! . . .
  . . .

Observe que o >canto superior esquerdo não é utilizado (exceto o programa 2sable). Eu fiz isso para confundir os ladrões (mas isso obviamente não funcionou haha).

Experimente online!

2sable, 15 bytes, A087156

D1QiA0*<}.;2->>

Experimente online

A sequência de números não negativos, exceto 1.

Befunge 93 , 14 bytes, A121377 , Rachado pelo leite !

&52* %68*+ .@Q

Curiosidade: a solução pretendida para isso é a primeira vez que utilizo esse idioma.

Minha solução em Pyth. & @ imprime um erro, mas isso vai para STDERR que, de acordo com o OP, é ignorado.

+%Q*5 2*6 8.&@

Python 2, 35 bytes, A048735 , Seguro

print(lambda u:u&u<<1)(input())>>1

A solução original estava na minha própria linguagem de programação Wise .

:<<>&>print(lambda uuu1)(input())1

A maioria dos personagens é irrelevante. Os personagens importantes são os seis primeiros. :cria duas cópias do primeiro item na pilha. <<>bit muda duas vezes para a esquerda e uma vez para a direita, o que equivale a mudar de bits uma vez para a esquerda. &pega o bit a bit e o item superior e segundo (a cópia original e a bit deslocada). Por fim, o >bit muda uma vez para a direita.

05AB1E, 5 bytes, A000012 , Seguro

$;$1?

Sequência de 1's. Experimente online

Solução pretendida: Arcyou

1;$$?

Experimente online . Não encontrei documentação para esse idioma, portanto, não tenha uma explicação de como ele funciona exatamente.

Python 2, 70 bytes, A000217 Rachado!

Tenho a sensação de que isso não será quebrado no idioma que usei para a outra versão, veremos :)

o=input()
v=0
i=1
while o:
 v+=i
 i+=1
print v


#|  d00->1@@@++-^,,[

Percebi depois que ofusquei o código incorretamente (ele não altera a validade da resposta postada). Aqui está o código que eu comecei no Haystack:

v
0
v
0
i
1
-
>      d0[v
^-1@+@d+1@?,,o|

05AB1E , 9 bytes, A000042 Rachado!

1×,1*-^$)

Esta é a representação unária de números naturais (OEIS). Portanto, se a entrada fosse 3, por exemplo, a saída seria 111.

Explicação:

                    # implicit input
1                   # pushes 1 to the stack   
 ×                  # pushes "1" × (the input)
  ,                 # outputs the stack
   1*-^$)           # irrelevant

Experimente online!

Solução Original, Cenoura

1^*$-1×^)

Explicação

1^             Push "1" to the stack
  *            Multiply the string by
   $-1         ...the input (as an integer) minus 1 times
      ×,)      Ignored by the interpreter

O *multiplica a string por(n+1) vezes, de modo que a^*3resulta em aaaae não aaa. É por isso que subtraí 1da entrada.

Só agora eu percebo que isso )tem sido irrelevante nos dois idiomas: D

Experimente online!

J, 2 bytes, A000290 , Rachado

*~

Bem, pode muito bem começar a procurar os dois participantes. Rende n × n ou n ² .

solução pretendida, Jolf, 2 bytes

*~

Bem. Sim. Esta é a minha própria linguagem e acho que funciona porque ~procura um caractere estendido, mas não encontra um, então apenas o ignora. ¯ \ _ (ツ) _ / ¯ Ops.

ABCR , 24 bytes, A023443 Rachado!

70: Quit xi. Classy queue!

Há um monte de no-ops. Calcula n - 1.

05AB1E, 8 bytes, A000042 , Rachado

F1}J,(1&

Casos de teste:

1 -> 1
2 -> 11
3 -> 111

Ouroboros , 6 bytes, A000012 Rachado

)49.o(

Sempre sai 1.