Questo è un poliziotto e ladri se non si ha familiarità con il formato fare clic sul tag per andare al wiki. Non ci sarà un thread di ladri per questa domanda.

Cops

Il tuo compito come poliziotti è selezionare due sequenze dall'Enciclopedia online delle sequenze di interi e scrivere un programma che prende l'ennesimo elemento di una sequenza come input e produce l'ennesimo elemento della seconda sequenza. Quindi fai una risposta includendo il codice e omettendo le sequenze selezionate. I ladri tenteranno di trovare le sequenze che hai selezionato e se uno riesce a trovare le sequenze che avevi in ​​mente o alcune altre sequenze per le quali il tuo programma devi contrassegnare la tua risposta come Cracked . Se un ladro ti informa con una crepa che ritieni non sia valida, puoi presentare una prova che non è una crepa. Altrimenti devi contrassegnarlo così.

Secondo le solite risposte che sono state rimosse per 7 giorni, possono essere contrassegnate come sicure. Un poliziotto può contrassegnare la propria risposta come sicura rivelando le sequenze che aveva in mente. Una volta al sicuro, una risposta potrebbe non essere più risolta.

L'obiettivo è ridurre al minimo il conteggio dei byte del programma rimanendo senza crack.

Esempio

Il seguente codice Python traduce l'ennesimo elemento di A000290 (i numeri quadrati) in A000217 (i numeri triangolari):

lambda x:sum(range(0,int(x**.5+1)))

Stipulazioni e requisiti

• Se si sceglie una sequenza che non è stata dimostrata finita, è necessario generare tutti i termini che potrebbero esistere, non solo quelli elencati nella pagina OEIS

• In deroga alle precedenti lingue delle regole senza numeri interi di precisione infinita, non è necessario generare o immettere numeri al di fuori del loro intervallo.

• La dimensione della sequenza di input non deve essere stata dimostrata essere inferiore alla sequenza di output.

• La sequenza di input non deve contenere elementi di ripetizione (altrimenti l'attività è praticamente impossibile)

• L'OEIS include un indice sulla loro pagina (il primo numero dopo l'intestazione "OFFSET") per impostazione predefinita, questo è il tuo offset per n (n è uguale all'indice per il primo elemento della sequenza) se scegli un altro indice devi indicarlo in la tua risposta.

• Se si sceglie un offset diverso da quello elencato nell'OEIS, è comunque necessario mappare tutti gli elementi nella sequenza di input sull'elemento corrispondente nella sequenza di output.

• Se il tuo programma riceve un input che non si trova nella sequenza di input, può fare quello che desidera (comportamento indefinito). Tuttavia, è probabilmente nel tuo interesse per l'output di un numero intero.

• È antisportivo rendere intenzionalmente difficile l'esecuzione del codice, sia esso che richiede tempo per l'esecuzione o attraverso la selezione della lingua non libera . Mentre farò rispettare il secondo, non posso far valere obiettivamente il primo. Tuttavia, per divertimento, ti imploro di non tentare il primo perché rende la sfida specificamente più difficile per chi ha un computer più debole.

Robbers

Il tuo compito come ladri è selezionare risposte non crackate, non sicure e trovare le sequenze tra loro mappate. Se trovi una soluzione una soluzione che funziona (non necessariamente la soluzione prevista dai poliziotti) commenta le sequenze sulla risposta appropriata.

I ladri non dovrebbero preoccuparsi troppo di verificare che due sequenze particolari siano una soluzione, si dovrebbe pubblicare una soluzione se corrisponde a tutte le voci su OEIS. Se questa non è la sequenza che aveva in mente un poliziotto, il poliziotto può offrire una prova che è errato o contrassegnarlo come incrinato se non riesce a trovarne uno.

Jelly , 14 byte (crackato da @Wolfram)

+66%444µ111<µ¡

Provalo online!

Dovrebbe essere abbastanza ovvio cosa fa. In effetti, a beneficio degli utenti non Jelly, darò anche una spiegazione:

Spiegazione

+66%444µ111<µ¡
       µ    µ¡  Run the transformation
+66%444           "add 66, then modulo 444"
        111<    once if 111 is less than the input, zero times otherwise 

La domanda è: perché lo fa?

Crepa

Le sequenze in questione erano A201647 e A201647 . Sono finiti e differiscono solo negli ultimi 2 elementi:

• 3, 5, 7, 9, 11, 15, 21, 165, 693
• 3, 5, 7, 9, 11, 15, 21, 231, 315

Pertanto, se l'input è basso, lo lascio lo stesso e inserisco semplicemente una funzione nella trasformazione degli ultimi due.

Jelly , 7 byte (Cracking di @JonathanAllan)

ÆFḅÆdÆẸ

Provalo online!

Cosa fa

ÆFḅÆdÆẸ  Main link. Argument: n

ÆF       Factor n into prime-exponent pairs.
   Æd    Compute σ, the number of divisors of n.
  ḅ      Convert each pair from base σ to integer.
     ÆẸ  Yield the integer whose prime signature (infinite sequence of all prime
         exponents, including zeroes, in order) is equal to the result.

Python 3, 256 byte ( Cracked! )

from math import*
def p(i,m):
 r=0;d=floor(log(i))
 for y in range(d):r+=(pow(16,d-y-1)%(8*y+m))/(8*y+m)
 o=-1;y=d
 while r!=o:o=r;r+=pow(16,d-y-1)/(8*y+m);y+=1
 return r
def q(n):r=4*p(n,1)-2*p(n,4)-p(n,5)-p(n,6);return floor((1-(-r%1)if r<0 else r%1)*16)

Provalo online!

Scusate se questo codice sembra orrendo, penso che questo sia il mio primo golf Python. Il casting in Python semplifica la codifica.

Elaborazione , 184 byte, SICURO!

int x(int y){int b=TRIANGLES-MITER;for(int i=OVERLAY/BURN;i>#fffffe;b*=(int)pow(y,(MOVE-HAND+0.)/(int)sqrt(red(color(-1<<16))/(int)log(color(0)*color(-1)))),i-=QUAD/DARKEST);return b;}

Una funzione che accetta un int e restituisce un int. Finché il numero di input è intcompreso nell'intervallo, il programma dovrebbe funzionare correttamente.

Questo non è lento, solo illeggibile. In bocca al lupo!

Sono sorpreso che questa presentazione sia durata così a lungo. Oh bene, almeno è la prima presentazione sicura :)

Da A000578 a A000290

In altre parole: i cubi ai quadrati.

Spiegazione

Durante la risposta Nessuna stringa (o numero) allegata , ho scoperto un elenco di costanti di elaborazione che rappresentano ints. Ad esempio, CORNERha un valore di 0. L'elenco completo è disponibile qui . Per trovare il valore di una costante, puoi semplicementeprint farlo.

Usando questo, ho deciso di scambiare determinati numeri con combinazioni di queste costanti per offuscarlo. Quindi, ecco cosa ottieni quando sostituisci le costanti con i rispettivi valori int.

int x(int y){int b=9-8;for(int i=512/8192;i>#fffffe;b*=(int)pow(y,(13-12+0.)/(int)sqrt(red(color(-1<<16))/(int)log(color(0)*color(-1)))),i-=16/16);return b;}

Anche ora, il codice completo non viene rivelato. I colori restano. In Elaborazione, le variabili di colore hanno valori int, ad esempio bianco ( #ffffff) è -1, #fffffeè -2, #fffffdè -3e così via. Questo può essere trovato printing il colore. Quindi semplificiamo i colori.

int x(int y){int b=9-8;for(int i=512/8192;i>-2;b*=(int)pow(y,(13-12+0.)/(int)sqrt(red(color(-1<<16))/(int)log(-16777216*-1))),i-=16/16);return b;}

Siamo a metà strada lì :) Per capire i valori, dobbiamo semplificare le espressioni numeriche.

int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/(int)sqrt(red(color(-65536))/(int)log(16777216))),i-=1);return b;}

Molto più chiaro! Ora semplifichiamo il logaritmo.

int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/(int)sqrt(red(color(-65536))/(int)16.6...)),i-=1);return b;}


int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/(int)sqrt(red(color(-65536))/16)),i-=1);return b;}

Quasi finito! Ora dobbiamo capire questo (int)sqrt(red(color(-65536))/16))boccone. color(-65536)è rosso, quindi rgb(255, 0, 0). Ora la red()funzione restituisce il valore del componente rosso nell'argomento (che è un colore). Quindi, quanto rosso c'è in rosso? La risposta è 255. Con quello otteniamo

(int)sqrt(255/16))
(int)sqrt(15)
(int)3.8...
3

Sostituendo questo nel programma si ottiene:

int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/3),i-=1);return b;}

Sì, è fatto!

int x(int y){                        // y is the cube
  int b=1;                           // variable that holds the final result
  for(int i=0;                       // for-loop that
          i>-2;                      // loops twice
          b*=(int)pow(y,(1.)/3),     // multiply b by the cube root of y
          i-=1);                     // decrement the looping variable
  return b;                          // finally return b
}

Per riassumere, questo restituisce il quadrato (fatto moltiplicando due volte nel ciclo for) della radice del cubo del numero di input.

Mathematica (o qualsiasi altra cosa) -  Cracked!

f[x_] := Quotient[ 366403414911466530559405368378193383110620062 - 
    755296348522256690003418238667147075159564695 x + 
    525778437135781349270885523650096958873079916 x^2 - 
    156594194215500250033652167655133583167162556 x^3 + 
    20861131421245483787723229627506507062999392 x^4 - 
    1181515772235154077024719095229309394979146 x^5 + 
    29382627265060088525632055454760915985604 x^6 - 
    308672970015057482559939241399297150364 x^7 + 
    1087516675449597417990589334580403666 x^8 - 
    312989984559486345089577524231879 x^9, 
  265451130886621254401938908479744271974400 ]

So che Mathematica è un software non libero, ma questa funzione è banale per eseguire il porting in qualunque lingua preferita tu voglia eseguirlo. Calcola letteralmente il valore del dato polinomio di grado 9 valutato all'intero di input, quindi prende il quoziente intero di quel valore e il numero di 42 cifre sull'ultima riga. Ad esempio, f[100]valuta -3024847237.