Questo è il filo conduttore dei rapinatori di questa sfida

I poliziotti sceglieranno una sequenza OEIS e scriveranno due programmi completi in due lingue diverse che producono quell'ennesimo elemento nella sequenza quando gli viene dato un n tramite STDIN. I due programmi devono essere anagrammi l'uno dell'altro, il che significa che ognuno può essere riorganizzato dalle lettere dell'altro.

Presenteranno il numero OEIS, il codice sorgente e il nome di una lingua in cui si trova.

Devi trovare un anagramma della presentazione del poliziotto originale che corre in una lingua diversa da quella usata dal poliziotto. Per ottenere una risposta devi solo trovare qualsiasi linguaggio e programma che produca la sequenza ed è un anagramma dell'originale, non necessariamente la risposta a cui stava pensando il poliziotto.

Puoi emettere per codice carattere o includere STDERR nella tua soluzione, ma solo se il poliziotto ha indicato la loro soluzione nascosta lo fa. L'output decimale su STDOUT è sempre un crack valido.

Quindi i poliziotti sono incentivati ​​a rendere il più difficile possibile trovare qualsiasi lingua che svolga il compito usando la loro lista di simboli.

punteggio

La persona con più crepe sarà il vincitore di questa sezione. Solo il primo crack per ogni soluzione verrà conteggiato ai fini del punteggio.

Classifica

Grazie mille a tutti coloro che hanno avuto luogo in questa sfida.

Ecco la classifica così com'è

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 byte, Loovjo , A000290

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

Provalo online!

Molto probabilmente non è la soluzione prevista, ma funziona.

Spiegazione

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 byte, Adnan , A000290

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

Provalo qui! Sicuramente non è la soluzione prevista, ma ehi, funziona.

Spiegazione

*&"?!#$|<=@\^{}
*                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 byte , Procedura guidata per il grano , A000290

In realtà lo stesso approccio del crack di Emigna: p.

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

Spiegazione:

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

Provalo online!

05AB1E , 35 byte, Oliver , A000290

I poliziotti dovrebbero smettere di pubblicare n^2sfide in Python ...

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

Provalo online!

Spiegazione

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

2 file , 7 byte, Kritixi Lithos , A005843

Codice:

r^#ei2*

Spiegazione:

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.

Provalo online!

Esagonia , 13 byte, Adnan , A002378

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

Provalo online!

non piegato:

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

Non al 100% se questo è l'originale, perché in alto a sinistra \non è utilizzato.

L' <\>sono solo specchi, in modo che il programma è in realtà del tutto lineare:

?"&)}=*!@

?          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 byte, DJMcMayhem , A002275

v!:x]''"
@ai1

Provalo online!

Questa potrebbe essere la prima soluzione nella lingua voluta dall'autore.

Spiegazione

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

2sable, Conor O'Brien , A000290

~*

Provalo online!

Non so come funzioni, esiste davvero un solo programma che soddisfa i requisiti e sono solo costretto a trovare la lingua in cui ha funzionato.

Dopo aver esaminato i documenti, sono in grado di fornire una spiegazione:

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

Pyth , 26 byte, Steven H. , A023443

Codice:

tQ.qly 7:esau0euii s uxC !

Prova online .

Abbastanza semplice:

 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 byte, 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|

Provalo su Ideone .

Presentazione del poliziotto

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|

Cosa c'è di diverso

L'invio di poliziotti non funziona in Python 3 per due motivi.

• La funzione di input di Python 2 elimina automaticamente una riga di input, mentre la controparte di Python 3 restituisce semplicemente la riga come stringa. Possiamo semplicemente chiamare int per risolvere questo problema.

• print era un'istruzione in Python 2, ma è una funzione in Python 3. In particolare, ciò significa che dobbiamo racchiudere il suo argomento tra parentesi.

Ciò significa che abbiamo bisogno int()e (), ma quei personaggi non fanno tutti parte del commento. Ciò significa che dobbiamo apportare alcune modifiche.

Invece della frazione s , teniamo traccia di 1 / s .

L'inizializzazione di s - s=1/(801**.5-28)- diventa s=801**.5-28, salvando i caratteri 1/().

Il fattore di un [-1] nell'aggiornamento di un - int(s)- diventa int(1/s), costando i caratteri 1/.

L'aggiornamento di s - s=1/(s-int(s))- diventa s=1/s-1//s, costando i personaggi 1//, ma salvando i personaggi (int()).

I personaggi salvati ()(int())coprono quelli di cui avevamo bisogno per portare il codice su Python 3, ma ottenerli ci è costato 1//. Possiamo prendere //dal commento, ma dovremo salvare 1altrove.

Un modo (l'unico?) Di salvare il necessario 1è quello di sostituire 1l'inizializzazione di un con 0==0. Questo costa quei quattro personaggi, ma possiamo prendere 00dal commento.

Finora abbiamo il seguente codice.

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|

Per recuperare uno dei ="debiti" che ora dobbiamo, possiamo riscrivere l'inizializzazione di s e a con un unico compito: s,a=801**.5-28,[0,0==0]Inoltre, questo salva un ;e costa un ,, che può essere aggiunto e rimosso dal commento.

Il secondo =può essere salvato non memorizzando l'input in una variabile, ovvero scrivendo range(int(input()))invece salvando i caratteri i=. Usiamo i dopo il ciclo pure, ma l' ho ^esimo elemento di una è solo la seconda da destra, in modo che possiamo sostituirlo icon -2. Per lo stesso motivo, a[-2]nel corpo del loop può essere sostituito con i.

Ora abbiamo una permutazione nel funzionamento del codice 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|

Tuttavia, questo codice funziona anche in Python 2! Un modo per risolvere questo problema è sostituirlo print(a[-2])con (print(a[-2]),); abbiamo i personaggi di cui abbiamo bisogno nel commento. Come accennato in precedenza, print è una funzione in Python 3, quindi costruisce la tupla ( None ,) . Tuttavia, l' istruzione print di Python 2 è un SyntaxError all'interno di una tupla letterale.

CJam, 39 byte, latte , A000007

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

Provalo qui.

Pyth, 7 byte, Luis Mendo , A000217

x:{ps}1

Come richiesto, il programma esce con errori dopo aver pstampato la risposta corretta.

Provalo online qui !

05AB1E , 12 byte, tuskiomi , A000012

1,(FI1=1=1,)

Provalo online!

Spiegazione

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

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

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

Provalo online!

Spiegazione

Questo si basa sulla crepa di Emigna qui .

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

05AB1E, 27 byte, boboquack , A000012

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

Provalo online

Come funziona:

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 byte, Shebang , A000217

ri),:+








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

Provalo qui.

Convesso, 75 byte, 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;

Provalo online

Come funziona:

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 byte, Kritixi Lithos

Sicuramente non la risposta prevista.

1^,-$)×1*

Spiegazione:

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

Pip , 6 byte, DLosc , A000012

.()49o

Ho pensato di provare prima l'esolang dell'OP ;-)

Provalo online.

05AB1E , 25 byte, Mego , A000583

Codice:

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

Spiegazione:

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

Provalo online!

Dip , 8 byte, Oliver , A000042

(1J&F},1

Spiegazione

              #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

La cosa divertente è che questa era la lingua desiderata! Dip è un esolang creato da Oliver.

Casi di test e corsa in corso dalla riga di comando

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

2 file, 14 byte, Dopapp , A121377

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

Provalo online.

Come funziona (più o meno):

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 byte, Oliver , A000012

p¥_1

Provalo online!

Questa è una sequenza di 1s.

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

Ciò genera 1indipendentemente dall'ingresso.

Dip , 5 byte, Oliver , A000012

`¸WW/

La sequenza viene stampata 1indipendentemente dall'input. La risposta di Oliver stampa a 1.0. Questo programma stampa anche a 1.0. Questa apparentemente è la soluzione prevista.

Spiegazione

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

Soluzione alternativa (per gentile concessione di @milk)

Convesso , 5 byte

WW¸`/

Provalo online!

Spiegazione

                  // 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