Esse é o fio dos ladrões desse desafio

Os policiais escolhem uma sequência OEIS e escrevem dois programas completos em dois idiomas diferentes que produzem o enésimo item na sequência quando recebem um n via STDIN. Os dois programas devem ser anagramas um do outro, o que significa que cada um pode ser reorganizado das letras do outro.

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

Você deve encontrar um anagrama do envio do policial original que é executado em um idioma diferente daquele usado pelo policial. Para decifrar uma resposta, você deve encontrar apenas qualquer idioma e programa que produza a sequência e seja um anagrama do original, não necessariamente a resposta em que o policial estava pensando.

Você pode imprimir pelo código de caractere ou incluir STDERR em sua solução, mas somente se o policial indicou que a solução oculta o faz. A saída decimal para STDOUT é sempre uma rachadura válida.

Assim, os policiais são incentivados a tornar o mais difícil possível encontrar qualquer idioma que execute a tarefa usando sua lista de símbolos.

Pontuação

A pessoa com mais rachaduras será a vencedora desta seção. Somente o primeiro crack para cada solução será contabilizado na pontuação de alguém.

Entre os melhores

Um grande obrigado a todos que ocorreram neste desafio.

Aqui está o quadro de líderes como está

Place  User             Score
-----------------------------
1      Adnan            3
1      Kritixi Lithos   3
1      Emigna           3
1      milk             3
5      Steven H.        2
5      Wheat Wizard     2
5      jimmy23013       2
8      ETH Productions  1
8      Dennis           1
8      alleks           1
8      Martin Ender     1
8      Oliver           1
8      Conor O'Brien    1

05AB1E , 38 bytes, Loovjo , A000290

nXtdief e():return X*X
pr e(input())##

Experimente online!

Muito provavelmente não é a solução pretendida, mas funciona.

Explicação

n      # square input
 X     # push 1
  t    # push sqrt(1)
   d   # push is_number(1.0)
    i  # if true do the rest of the code (1.0 is not a number so it will never execute)

Jolf, 15 bytes, Adnan , A000290

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

Experimente aqui! Definitivamente não é a solução pretendida, mas, ei, funciona.

Explicação

*&"?!#$|<=@\^{}
*                multiply
 &               the two inputs to this func, x, y: x && y
                 returns y if x and y, or the falsey argument.
  "?!#$|<=@\^{}  this string is always truthy, so the second arg is used.
                 two implicit inputs are taken, both equal to the first arg
                 so, this corresponds to *xx, which is x^2.

05AB1E , 49 bytes, Assistente de trigo , A000290

Na verdade, a mesma abordagem que o crack de Emigna: p.

n4i<({({)({[()]){))()()()turpetne/"*"*splint>}}}}

Explicação:

n          # Square the input
 4i        # If 4 == 1, do the following...
   <({...

Experimente online!

05AB1E , 35 bytes, Oliver , A000290

Policiais devem parar de postar n^2desafios em python ...

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

Experimente online!

Explicação

n    # square input
 0i  # if 0 == 1 do the rest of the code

2sable , 7 bytes, Kritixi Lithos , A005843

Código:

r^#ei2*

Explicação:

r         # Reverse the stack, which is a no-op
 ^        # XOR the input with itself, always leading to 0
  #       # If 1, break (which stops the program)
   e      # Compute input nPr input, which always leads to 1
    i     # If equal to one, do the following..
     2*   #   Multiply the input by 2.

Experimente online!

Hexagonia , 13 bytes, Adnan , A002378

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

Experimente online!

Desdobrado:

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

Não é 100% se este é o original, porque o canto superior esquerdo \não é utilizado.

Como <\>são apenas espelhos, o programa é totalmente linear:

?"&)}=*!@

?          Read input.
 "         Move back and left.
  &        Copy input.
   )       Increment copy.
    }=     Move forward and right and turn around (to face the n and n+1 edges).
      *    Multiply.
       !   Print.
        @  Terminate.

V , 13 bytes, DJMcMayhem , A002275

v!:x]''"
@ai1

Experimente online!

Essa pode ser a primeira solução no idioma pretendido pelo autor.

Explicação

v!:x]''"   Does nothing
@ai1       inserts 1 a times

2sable, Conor O'Brien , A000290

~*

Experimente online!

Não sei como funciona, na verdade, existe apenas um programa que atende aos requisitos e sou apenas forçado a encontrar o idioma em que ele trabalhou.

Depois de examinar os documentos, sou capaz de apresentar uma explicação:

~         Push Input OR Input (always pushes the input)
 *        Multiply that by Input 

Pyth , 26 bytes, Steven H. , A023443

Código:

tQ.qly 7:esau0euii s uxC !

Experimente online .

Relativamente simples:

 Q                            Reads input
t                             Substracts 1 from it
  .q                          Quits program (implicit print)
    ly 7:esau0euii s uxC !    None of this ever plays a part...
                                I just thought it'd be fun to scramble it.

Python 3, 118 bytes, ETHproductions, A042545

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

Test it on Ideone.

Cop submission

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|

What's different

The cop submission doesn't work in Python 3 for two reasons.

• A função de entrada do Python 2 avalia automaticamente uma linha de entrada, enquanto a contrapartida do Python 3 retorna a linha como uma string. Podemos simplesmente chamar int para corrigir isso.

• print foi uma afirmação no Python 2, mas é uma função no Python 3. Em particular, isso significa que precisamos cercar seu argumento entre parênteses.

Isso significa que precisamos int()e(), but those characters aren't all part of the comment. That means we must make some changes.

Em vez da fração s , registramos 1 / s .

A inicialização de s - s=1/(801**.5-28)- torna-se s=801**.5-28, salvando os caracteres1/() .

O fator a [-1] na atualização de a - int(s)- se torna int(1/s), custando os caracteres 1/.

A atualização de s - s=1/(s-int(s))- se torna s=1/s-1//s, custando os caracteres 1//, mas salvando os caracteres (int()).

Os caracteres salvos ()(int())abrangem aqueles que precisávamos para portar o código para o Python 3, mas obtê-los nos custou 1//. Podemos tirar //do comentário, mas teremos que salvar em 1outro lugar.

Uma maneira (a única?) De salvar o necessário 1é substituir o 1na inicialização de um por 0==0. Isso custa esses quatro caracteres, mas podemos pegar00 from the comment.

Até agora, temos o seguinte código.

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

Para recuperar um dos =que agora "devemos", podemos reescrever a inicialização de s e a com uma única atribuição: s,a=801**.5-28,[0,0==0]Além disso, isso salva a ;e custa a ,, que podem ser adicionados e removidos do comentário.

O segundo =pode ser salvo não armazenando a entrada em uma variável, ou seja, escrevendo em range(int(input()))vez disso, salvando os caracteres i=. Também usamos i após o loop, mas o i- ^ésimo elemento de a é apenas o segundo da direita, para que possamos substituí-lo ipor -2. Pela mesma razão, a[-2]no corpo do loop pode ser substituído por i.

Agora temos uma permutação para trabalhar o código Python 3:

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

However, this code also works in Python 2! One way of fixing this is to replace print(a[-2]) with (print(a[-2]),); we have the characters we need in the comment. As mentioned before, print is a function in Python 3, so this constructs the tuple (None,). However, Python 2's print statement is a SyntaxError inside a tuple literal.

CJam, 39 bytes, milk, A000007

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

Try it here.

Pyth, 7 bytes, Luis Mendo, A000217

x:{ps}1

As requested, the program exits with error after printing the correct answer.

Try it online here!

05AB1E, 12 bytes, tuskiomi, A000012

1,(FI1=1=1,)

Try it online!

Explanation

1,            # print 1
  (           # negate input
   F          # that many times do (i.e. no times)
    I1=1=1,)  # the rest of the code

05AB1E, 38 bytes, Conor O'Brien, A000290

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

Try it Online!

Explanation

This is based on Emigna's crack here.

n   #Squares the number
 2i #Runs the rest of the code if 2==1

05AB1E, 27 bytes, boboquack, A000012

1 1pif:
    if :
        rint( '1' )

Try it online

How it works:

1                     # push 1
  1                   # push 1
   p                  # pop (1), push is_prime(1)
    i                 # pop (is_prime(1), false), if is false so don't execute rest

CJam, 70 bytes, Shebang, A000217

ri),:+








e#|  d00->1@@@++-^,[o=input(v=0i=1whil o v=i i+=1pnt v

Try it here.

Convex, 75 bytes, boboquack, A004526

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;

Try it online

How it works:

2  e# push 2
 / e# pop first 2, divide, push result
   e# push a bunch of garbage but discard it all with semi-colons (;)
  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;

Dip, 9 bytes, Kritixi Lithos

Definitely not the intended answer.

1^,-$)×1*

Explanation:

1$^,-)×   # Basically does nothing
       1* # Repeat "1" n times

Pip, 6 bytes, DLosc, A000012

.()49o

I figured I'd try the OP's esolang first ;-)

Try it online.

05AB1E, 25 bytes, Mego, A000583

Code:

nnYi=put("");prit`Y**4`,X

Explanation:

n       # Square the input
 n      # Square the squared input
  Y     # Constant that pushes 2
   i    # If equal to 1, do the following:
    =put...

Try it online!

Dip, 8 bytes, Oliver, A000042

(1J&F},1

Explanation

              #Implicit Input
(             #Start range loop
 1            #Push 1 to the stack
  J           #Join all the elements in the stack
   &          #End program
    F},1      #These are ignored

The funny thing is that this was the intended language! Dip is an esolang created by Oliver.

Test Cases and Running Dip from Command-Line

$python3 dip.py
Dip v1.0.0 by Oliver Ni.
>>> (1J&F},1
> 4
1111
>>> (1J&F},1
> 7
1111111

2sable, 14 bytes, Dopapp, A121377

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

Try it online.

How it works (more or less):

Q@
  5              # Push 5
    2            # Push 2
     *           # Pop (2), pop (5), push 5*2=10
      %          # Pop (10), pop (input), push input%10
       6         # Push 6
         8       # Push 8
          *      # Pop (8), pop (6), push 8*6=48
           +     # Pop (48), pop (input), push input+48
            .&

05AB1E, 4 bytes, Oliver, A000012

p¥_1

Try it online!

This is a sequence of 1s.

              # Implicit input
p¥_           # Does nothing
   1          # Pushes 1 to the stack
              # Implicit output

This outputs 1 no matter what the input is.

Dip, 5 bytes, Oliver, A000012

`¸WW/

The sequence just prints a 1 no matter what the input is. Oliver's answer prints a 1.0. This program also prints a 1.0. This apparently is the intended solution.

Explanation

`¸                  # push character `¸`
  W                 # pushes 1000000
   W                # pushes 1000000 also
    /               # divides the last two items in stack resulting in 1.0
                    # implicit output (1.0)

Alternative solution (courtesy of @milk)

Convex, 5 bytes

WW¸`/

Try it online!

Explanation

                  // implicit input
W                 // pushes -1
 W                // pushes -1 also
  ¸               // calculates the LCM of the two numbers (which evaluates to 1)
   `              // finds its string representation
    /             // slices the string (so that it would evaluate to "1")
                  // implicit output