Questa è una sfida di poliziotti e ladri , il thread dei ladri può essere trovato qui .

Il tuo compito è quello di scrivere del codice che genera una sequenza OEIS e contiene il nome della sequenza nel codice ( A______) e genera una seconda sequenza separata quando il nome della sequenza nel codice viene cambiato con il nome della seconda sequenza.

Ecco un esempio in Haskell che funziona per A000217 e A000290 .

f x|last"A000217"=='0'=x^2|1>0=sum[1..x]

Provalo online!

Dovrai quindi rivelare una delle due sequenze e il codice che mantiene segreta la seconda sequenza. I ladri tenteranno di capire quale sia la sequenza nascosta. Se un ladro riesce a determinare qual è la tua sequenza (o un'altra sequenza che si adatta ai criteri), la tua risposta è incrinata. Se nessuno lo fa in una settimana dalla pubblicazione della risposta, è possibile contrassegnare la risposta come sicura e rivelare la soluzione prevista per la verifica. Le risposte sicure non possono essere decifrate.

Input Output

^{Tratto da qui}

Il codice può essere una funzione o programma completo che prende n tramite un metodo standard input ed emette il n esimo termine della sequenza come indicizzato dall'indice fornito nella pagina OEIS.

È necessario supportare tutti i valori forniti nei file b di OEIS per quella sequenza, non è necessario supportare alcun numero non presente nei file b.

punteggio

Il tuo punteggio sarà il numero di byte nel tuo codice, con meno byte migliori.

Python 3, 59 byte, A162626 , crackato da Wheat Wizard

lambda n:n*(n+1)*(n+2)/3if 0<=n<=3else n*(n**2+5)/3#A162626

Questo è doveva essere impossibile, non è vero?

Python 3 , 62 byte, A017016 ( Cracked )

n=int(input())
print(sum(1for i in"A017016"if i>"0")*-~n//-~n)

Provalo online!

Japt , 13 byte ( Cracking )

C'è (almeno) un'altra soluzione, se qualcun altro vuole prenderla a pugni.

p#A000012uCnG

Provalo online
A000012

Spiegazione

#seguito da un personaggio in Japt ci dà il codice di quel personaggio, quindi #A=65il resto del numero viene poi aggiunto, dandoci 65000012o 65000290.

uè il metodo modulo (differisce dal fatto %che restituirà sempre un numero positivo).

Il nmetodo sottrae il numero a cui viene applicato dal numero passato ad esso. Ce Gsono le costanti di Japt rispettivamente per 11 e 15. Quindi, CnGci dà 4.

Ora abbiamo 65000012%4=0e 65000290%4=2. Il pmetodo aumenta il numero a cui viene applicato (in questo caso è, implicitamente, l'input intero U) alla potenza del numero passato ad esso, dandoci le 2 formule finali di U**0e U**2.

MATL , 30 29 byte ( Cracking )

A077430I\2-|Gw^1Mwx*10&Ylk1+&

A077430

Provalo online!

-1 byte grazie a @Sanchises

C #, 28 byte ( crackato )

n=>n*n*("A000290"[6]<49?1:n)

Funziona con A000290 .

Facile da iniziare.

Provalo online!

Python 2, 43 byte, A000079 ( Cracked )

Provalo online

lambda n:((sum(map(ord,'A000079'))*2)%8)**n

C #, 75 byte, ( Cracking )

n=>{int r=1,e=3-0xA000244%2;for(;n>0;e*=e){r*=(n%2>0?e:1);n>>=1;}return r;}

A000244

Provalo online!

Python 2 , 53 byte, A000012 [crackato]

lambda x:len(`x**(sum(map(int,'A000012'[1:]))==22)`) 

Provalo online!

La sequenza successiva è A055642 (lunghezza delle cifre in un numero decimale). Per cui il numero si valuta da solo, poiché la somma delle cifre in OEIS è 22; la len (...) calcola quindi la lunghezza effettiva del numero di input per 'A055642'. Per le sequenze A000012 (o qualsiasi altra diversa da A055642. La len sarà sempre uguale a una, poiché il numero valutato sarà '1'.

Python 3, 65 byte, A000027, incrinato

a=lambda a,n=((int("A000027",11)-0x103519a)%100%30+1)/2:a//(14-n)

Yay aritmetica pazza!

Smalltalk, 148 byte, sicuro!

|x o|x:=(16rA018253*0.00861-1445345)floor. o:=OrderedCollection new. 1 to:x/2 do:[:i|x\\i=0 ifTrue:[o add:i]].o add:x.^o at:stdin nextLine asInteger

A018253

Accetta un numero intero come input, la sequenza è basata su 1.

La seconda sequenza prevista è A133020 . Nel writeup di A018253 è presente un collegamento a un elenco di voci per sequenze correlate ai divisori di numeri . In tale elenco, A133020 è suddiviso in quadrati: 100² . Se vuoi vedere l'intera sequenza, inserisci Transcript show: o printString; cr.prima dell'istruzione return ^nel codice.

Haskell, 226 byte, sicuro!

Non sono sicuro se intelligente o brutto, forse entrambi ...

o n=read.pure.(!!n)$"A001906"
m::Integral a=>[a->a->a]
m=[const,(+),(-),(*),div,(^)]++(flip<$>m)
l=o 1:o 3-o 1:zipWith(m!!(o 6+o 3-o 2))(tail l)l
f=(l!!).((m!!(o 4+o 5+o 6-2*o 1-o 2))$sum[1|n<-[1..6],odd(o n)]).((m!!o 6)$o 3)

Quindi ora questo calcola A001906 , ma dovrebbe essere in grado di generare molte sequenze.

Provalo online!

Soluzione: A131078

Ti chiedi se questo è stato troppo difficile o nessuno ci ha provato?

o 1per o 6essere le cifre del numero di serie, mè un elenco di operazioni. lè un elenco infinito definito ricorsivamente con i primi due valori derivati ​​dal numero di serie e quelli rimanenti calcolati dai due precedenti utilizzando un'operazione fissa da m. Nel caso di A001906, la definizione può essere semplificata

l=0:1:zipWith(flip(+))(tail l)l

(flip(+))è (di solito) lo stesso di (+)e otteniamo una definizione ben nota (ma non la più breve) dei numeri di Fibonacci. Questo schema di ricorsione potrebbe calcolare direttamente A001906, ma ciò richiede un'operazione più complicata di quelle in m. Un altro esempio: utilizzando valori di partenza 1e 2e l'operazione (*)dà la serie A000301 . Viene calcolato dal nostro codice quando il numero di serie viene sostituito con ?103206.

Infine, la funzione si findicizza nell'elenco l, ma solo dopo alcune trasformazioni dell'input. Per A001906, la parte centrale si riduce a (*)2, in modo da ottenere solo i numeri di Fibonacci in posizioni pari. La parte giusta diventa flip const 1, che è la funzione identità e non interferisce ulteriormente.

Per la soluzione A131078, i valori iniziali di lsono 1e 0, e l'operazione è flip const, che consente di lessere 1,0,1,0,.... La parte centrale dif diventa (flip div 4), risultando in 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,.... Sembrava una bella risposta, ma poi ho visto che A131078 inizia n=1, quindi ho aggiunto la parte giusta f, che qui è quella flip(-)1di sottrarre una.

La mia idea era di renderlo un po 'offuscato usando me indicizzandolo con cifre dai numeri delle serie, poi è diventato più offuscato (termini complicati) per farlo funzionare (forse non stavo cercando abbastanza a lungo per alternative); e poi è diventato ancora più offuscato (parte destra f) per farlo funzionare davvero. Penso comunque che alcune ipotesi e tentativi avrebbero potuto risolverlo.

dc , 52 byte, incrinato

Questo funziona con A000217 :

?SaA000217d8d1+Sb%1r-dScla*r10 7^-Lb%+la*1+Lc+La*2/p

Provalo online!

Python 3.6, 114 byte, crackato

from random import*
g=lambda n:eval(''.join(Random("A005843").choices('n8-9+17n#8*+26%n1 32-3+4-545*-#6*7',k=34)))

A005843

g(n) restituisce il valore n-esimo della sequenza per n> = 0.

random.choices(s,k)è una novità di Python 3.6, restituisce gli kelementi selezionati scon la sostituzione.

Chip , 67 byte, rotto da Yimin Rong

2D5B#{*Cm49!}E-7
(A000012d#,zkmsh
b-\6/e2)[1Zv^~^S
33a#kcf3g88taz1@

A000012 . Un po 'sfacciato, sì.

Provalo online!

Usa byte per l'I / O, quindi sono stato gentile e ho creato un wrapper bashy / pythony.

La sequenza alternativa è A060843 . Provalo online per gli input 1..4.

Yimin Rong ha ragione, un programma Chip così breve può solo calcolare cose molto semplici. La sequenza originale è tutta una, e la sequenza alternativa sono i numeri di castori occupati, di cui solo 4 sono noti.

Questi numeri 1, 6, 21, 107sono semplicemente codificati per gli input 1..4.

Una cosa interessante sull'uso di Chip per questa sfida è che le cifre 0- 9non sono numeri, ma elementi logici. In particolare, 0- 7sono gli otto bit che si rivolgono alla testa dello stack, e un potenziale omaggio è che solo -8 e 9sono gli interruttori di lettura e scrittura. Ciò ha reso questo un po 'più interessante e molto più offuscato.

ADappare, il che significa che abbiamo solo 4 bit per indicizzare la sequenza. Ciò significa che potrebbero esserci al massimo 16 valori diversi. In realtà, solo A- Cvengono effettivamente utilizzati per la sequenza alternativa, fornendo al massimo 8 valori diversi.

Per chiunque possa essere interessato, ecco lo stesso codice, privo di elementi non utilizzati e non utilizzati:

.

   B  *C 49!
 A000012d ,z  s
b-\6/e   1Zv-~^S
`3a`-cf3g`8taz1