28

Questa è una sfida per poliziotti e ladri . Il thread dei ladri è qui .

Una domanda interessante a cui pensare è la seguente:

Se ho una sequenza di numeri, quanti ne devo fornire prima che sia chiaro di quale sequenza sto parlando?

Ad esempio, se voglio parlare degli interi positivi in ordine a partire da , potrei dire , ma è davvero abbastanza? $1$ $1,2,3, \dots$

Ho un modo di rispondere a questa domanda, ed essendo un golfista di codice implica il golf di codice. Hai fornito abbastanza termini di una sequenza se il codice più breve che produce quei termini produce tutti i termini della sequenza. Se pensiamo a questo in termini di code-golf, ciò significherebbe che hai fornito un numero sufficiente di casi di test in modo tale che il codice più breve che supera i casi di test faccia il compito desiderato.

Sfida

Questa sfida è una sfida per poliziotti e ladri . In cui i poliziotti presenteranno casi di test e i ladri dovranno trovare un modo più breve per falsificare i casi di test diversi dalla sequenza prevista. Gli sbirri presenteranno le seguenti cose:

Un pezzo di codice che accetta un intero non negativo come input e produce un intero come output. Questo codice definirà la sequenza. Il tuo codice non deve supportare 0 come input, scegliendo invece di prendere 1 come input più piccolo. Dovrebbe essere chiaro se questo è il caso nella tua risposta.
Qualsiasi piattaforma pertinente o requisiti linguistici che potrebbero influire sull'output, ad esempio la dimensione del longint.
Un numero , insieme ai primi termini della sequenza calcolati dal codice. Questi fungeranno da "casi di test". $n$ $n$

Sei incoraggiato a spiegare cosa fa la tua sequenza e collegare OEIS se esiste, tuttavia è il tuo codice che definisce la sequenza e non la descrizione.

I ladri troveranno un programma nella stessa lingua che è più breve di quello presentato e supera tutti i casi di test (produce lo stesso output per i primi input del codice del poliziotto). Il codice del ladro deve anche differire nell'output dal programma del poliziotto per un numero maggiore di . $n$ $n$

Gli sbirri devono essere in grado di decifrare le proprie risposte prima di inviarle.

Dopo una settimana un poliziotto può rivelare il proprio crack e contrassegnare la propria risposta come sicura. Le risposte contrassegnate come tali non possono più essere violate.

punteggio

Le risposte degli sbirri saranno segnate dal numero di byte con meno byte migliori. Le risposte incrinate segnano un punteggio infinito.

code-golf sequence cops-and-robbers

— Mago del grano
fonte

È chiaro che ci sono modi per risolvere in modo non matematico un problema, come stampare tutti i casi di test, ma tale problema è subordinato ai casi forniti dagli sbirri. Dovrebbe esserci una regola al riguardo? Esiste una restrizione contro la calcolabilità delle sequenze o altro dalla teoria di Ramsey? (cioè devi essere in grado di rompere la tua macchina?)

— theREALyumdub

2

@theReallyumdub la domanda stabilisce che devi essere in grado di infrangere la tua richiesta.

— Wheat Wizard

@CatWizard Grazie, sono andato avanti e questo è già su un ovvio meta post, apparentemente impedisce alcuni di questi ragazzi. Quindi non è nello spirito del tag fare in modo che una crepa

— impieghi

4

spikedmath.com/062.html

— Giuseppe

Esiste una condizione "sebbene in teoria la tua soluzione debba funzionare per tutti i numeri in pratica, deve funzionare solo per ..."?

— user202729

6

cQuents , 4 byte ( Cracked )

"::$

Provalo online!

Ecco otto ( n=8) casi:

Spiegazione del codice:

"      Stringify sequence (join on "", remove it and see what happens)
 ::    Given input n, output all items in the sequence up to and including n
   $   Each item in the sequence equals the index

Quindi la sequenza è 1,2,3,4,5 ..., è unita in ""modo che diventi 12345 ..., e ::significa che stampa fino all'input.

— Stefano
fonte

Cracked.

— Bubbler,

5

Python 3 , 66 57 byte ( Cracked )

crackato da xnor
anche crackato da Cat Wizard prima di una modifica

def f(n):x=n/10-2;return int(x*60-x**3*10+x**5/2-x**7/84)

Provalo online!

Ciao! Ecco una sequenza da decifrare per . Fornisce questi primi 40 elementi con indicizzazione 0, non è una sequenza OEIS $n=40$

[-54, -56, -58, -59, -59, -59, -59, -57, -55, -53, -50, -46, -43, -38, -33, -28, -23, -17, -11, -5, 0, 5, 11, 17, 23, 28, 33, 38, 43, 46, 50, 53, 55, 57, 59, 59, 59, 59, 58, 56]

— crashoz
fonte

Ho dimenticato di rimuovere gli spazi bianchi, non sono ancora un esperto golfista: p Ti dispiace se modifico per risolvere il problema?

— crashoz,

Certo andare avanti. Rimuoverò la mia crepa.

— Wheat Wizard

Cracked

— xnor

5

Python 2 , 44 byte ( crackato )

f=lambda n,i=1,p=1:n and-~f(n-p%i,i+1,p*i*i)

Provalo online!

I numeri primi Quale sequenza potrebbe essere più pura? O più esagerato ? Il vostro obiettivo è quello di produrre i primi 50 numeri primi per n=1a n=50.

Il codice è un generatore di teoremi di Wilson copiato esattamente da questo suggerimento .

I diversi valori per la sequenza alternativa non sono dovuti a limitazioni della macchina come trabocchi e precisione. Nessuna libreria di terze parti.

Cracked da Arnauld, @PoonLevi, e il signor Xcoder.

— XNOR
fonte

Abbastanza sicuro che non intendevi lasciarti sfuggire da questo ; forse specificare "Python (senza librerie di terze parti)" o "Python (senza importazioni)" o qualcosa del genere?

— Jonathan Allan,

@JonathanAllan Grazie, ho modificato che non ci sono librerie di terze parti.

— xnor

Non sono ancora riuscito a risolverlo (il mio miglior tentativo al momento è di 47 byte o giù di lì), ma penso che ci sia qualcosa di interessante da notare su quei numeri primi. Per ogni

, con

, questo vale:

. Allo stesso tempo, questo non è vero per qualsiasi numero che non sia primo (nell'intervallo indicato sopra), ma lo fa

p_{i}

$p_i$

i \in [1, 50] \cap N

$i\in[1, 50]\cap \mathbb{N}$

2^{p_{i}} \equiv 2 (mod p_{i})

$2^{p_i}\equiv 2 (\text{mod } p_i)$ quindi per valori più alti. Lascio qui l'idea in modo che altri possano cimentarsi in una crepa usando la tecnica menzionata, e forse ottenere un punteggio migliore :)

— Mr. Xcoder

@ Mr.Xcoder Ecco il mio miglior tentativo basato sul metodo proposto. Si differenzia con successo a N = 69, restituendo 341 (il primo pseudoprime di Fermat alla base 2, o il primo numero di Poulet) ma fallisce anche per N = 1. Dubito di poterlo risolvere da solo, quindi ho pensato di condividere meglio quello che ho. (La mia migliore soluzione è di 46 byte ...)

— Arnauld

1

@Arnauld Ho trovato una soluzione a 44 byte usando questo metodo. Non riesco ad andare oltre. Forse qualcun altro sarà in grado di capirlo.

— Poon Levi,

4

Wolfram Language (Mathematica) , 39 34 byte (Sicuro)

Check[{1,9,7}[[#]],18+Boole[#>9]]&

Provalo online!

Sembra semplice, la soluzione dovrebbe essere difficile.

1 indicizzato e . Questa sequenza non è disponibile su OEIS. $n = 99$

{1, 9, 7, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19}

Questo elenco sopra è uguale a:

Join[{1, 9, 7}, Table[18, 6], Table[19, 90]]

Ecco un modello per verificare la tua soluzione: provalo online!

Crepa prevista

Il problema qui è che l'uscita aumenta di 1 quando il numero di cifre aumenta di 1, con l'eccezione dei primi tre termini; la soluzione prevista ha qualcosa a che fare con la conversione di stringhe.

Quindi, leggendo la documentazione su Conversione tra espressioni e stringa , si potrebbe trovare la funzione SpokenString.

La soluzione è semplicemente la lunghezza della versione della stringa parlata dell'espressione x^nper vari input:StringLength@SpokenString[x^#]&

— JungHwan Min
fonte

3

Haskell , 29 byte (Cracked: 1 , 2 )

a n=n*ceiling(realToFrac n/2)

Provalo online!

Questo è A093005 : . $a(n)=n\lceil \frac{n}{2} \rceil$

Casi di prova per , ovvero : $0 \leq n \leq 20$ map a [0..20]

[0,1,2,6,8,15,18,28,32,45,50,66,72,91,98,120,128,153,162,190,200]

Soluzione prevista (20 byte)

b n=sum$n<$show(3^n)

Provalo online! Differisce in , con e . $n=23$ $a(23) = 276$ $b(23) = 253$

$b(n) = n\ len(3^n) = n \lceil log_{10}(1+3^n)\rceil$ $0$ $22$

_fonte

— Laikoni
fonte

incrinato

— ბიმო

@Laikoni, se la crepa prevista è più breve, qualcun altro potrebbe potenzialmente rivendicare il ladro dal BMO.

— fəˈnɛtɪk,

@ fəˈnɛtɪk Grazie, non ero a conoscenza di questa regola.

— Laikoni,

@BMO ri-crackato

— Ørjan Johansen

2

@BMO Ecco qua :)

— Laikoni,

2

JavaScript (ES6), 12 byte ( crackato )

Questo è piuttosto semplice.

n=>n*(8*n+1)

Provalo online!

Questo è A139275 :

a (n) = n (8 n + 1)

$a(n) = n(8n+1)$

$0\le n<9$

0, 9, 34, 75, 132, 205, 294, 399, 520

$0, 9, 34, 75, 132, 205, 294, 399, 520$

E secondo le regole della sfida, deve divergere oltre.

— Arnauld
fonte

n=>8*n*n+ndifferisce per n=94906273, è una crepa valida?

— ngn,

@ngn Mi sembra valido secondo le regole della sfida, ma forse dovresti chiedere all'OP se la perdita di precisione conta come una divergenza valida? La crepa prevista differisce per n=9, però.

— Arnauld,

@CatWizard ^

— ngn

Direi che è una crepa valida.

— Mago del grano,

2

cracked ( |invece di +)

— ngn

2

Malbolge, 10 byte

ub&;$9]J6

Si noti che il codice termina con un byte 0x14 (controllo dispositivo 4).

Provalo online!

La sequenza con indice 0 da craccare è [9, 19, 29].

— Maniglia
fonte

2

> <> , 276 byte ( crackato )

1$1-:?!v$:      1[0$          >:?!va2[$:{:@%:{$-{,]v
       >$n; v              <  ^   >~{]02.1+1+ffr+1r<
 :}[r]{  [01>:{*@@+$a*l2=?!^~]+ff+9+1g"3"=?v"3"ff+9+1pf0.
 :}[l01-$>    $:0(?v$@$:@@:@)?v@@1-$}v     >"2"ff+9+1p00.
>.       ^-1l v!?} <  .4a}$@@$<   .4a<
^26{]r0[}:{]~{<

Provalo online! Chiamalo con questo -v nper ottenere l'n-esimo elemento (1-indicizzato)

1$1-:?!;$::n84*o1[0$          >:?!va2[$:{:@%:{$-{,]v
            v              <  ^   >~{]02.1+1+ffr+1r<
 :}[r]{  [01>:{*@@+$a*l2=?!^~]+ff+9+1g"3"=?v"3"ff+9+1pf0.
 :}[l01-$>    $:0(?v$@$:@@:@)?v@@1-$}v     >"2"ff+9+1p00.
>.       ^-1l v!?} <  .4a}$@@$<   .4a<
^26{]r0[}:{]~{<

Provalo online! Chiama con -v nper ottenere un elenco di n-1 elementi a partire da 1

Interprete di pesci online

Lungo e complesso, questo è OEIS A004000 .

Consenti a (n) = k, forma m invertendo le cifre di k, aggiungi da m a k, quindi ordina le cifre della somma in ordine crescente per ottenere a (n + 1).

Esempio: 668 -> 668 + 866 = 1534 -> 1345.

$n = 34$

1 2 4 8 16 77 145 668 1345 6677 13444 55778 133345 666677 1333444 5567777 12333445 66666677 133333444 556667777 1233334444 5566667777 12333334444 55666667777 123333334444 556666667777 1233333334444 5566666667777 12333333334444 55666666667777 123333333334444 556666666667777 1233333333334444 5566666666667777

— crashoz
fonte

Come si esegue il programma per produrre un singolo output per un dato n(come richiesto dalla domanda)?

— Jonathan Allan,

Dato che non ci sono realmente "funzioni" nei pesci, ho aggiunto una versione che puoi chiamare per ottenere l'n-esimo (che è essenzialmente la stessa, perché deve calcolare gli elementi precedenti n-1)

— crashoz

Ancora più importante, hai una crepa che si adatta allo stesso indice di input che produce il singolo output?

— Jonathan Allan,

1

1 <= n <= 34

$1<=n<=34$

n > 34

$n>34$

Cracked

— Jo King,

2

Gelatina , 6 byte , sicuro!

<4+ạ2ȯ

Questo definisce una sequenza indicizzata zero dove:

a (n) = {\begin{cases} 1 & n < 3 \\ 2 & n = 3 \\ n - 2 & n > 3 \end{cases}

$a(n) = \begin{cases} 1 & n<3 \\ 2 & n=3 \\ n-2 & n>3 \end{cases}$

$a(0)\cdots a(15)$ 1,1,1,2,2,3,4,5,6,7,8,9,10,11,12,13

Provalo online! ( ecco una versione a valore singolo)

Questo non è attualmente nell'OEIS (anche se A34138 funzionerà come una crepa se abbastanza corto)

Crepa prevista

$16$ $n$
$17^{\text{th}}$ $107004539285280$ $15$ $14=a(16)$

!ÆsDL

— Jonathan Allan
fonte

1

JavaScript, 26 byte ( crackato )

let f=x=>x>1?f(x-1)*f(x-2)+1:1

for (x of [0,1,2,3,4,5,6,7]) {
  console.log(x + ' -> ' + f(x))
}

Espandi frammento

OEIS A007660

L'output è i primi 6 elementi con 0 indicizzazione (1,1,2,3,7,22)

(in qualche modo spostato da ciò che OEIS ha elencato come)

Basta creare una risposta semplice da risolvere per dare il via alle cose

Provalo online!

— fənɛtɪk
fonte

Cracked .

— Mr. Xcoder,

L'output del tuo frammento di esempio inizia da 1, non da 0?

— Paŭlo Ebermann,

@ PaŭloEbermann Risolto questo

— fəˈnɛtɪk

1

JavaScript, 16 byte ( crackato )

g=
x=>Math.exp(x)|0

tmp=[0,1,2,3,4]
console.log(tmp.map(g).join(','))

Espandi frammento

$\lfloor e^n\rfloor$

Gli input richiesti da abbinare sono 0,1,2,3,4.

Provalo online!

— fənɛtɪk
fonte

Cracked

— Mr. Xcoder

1

APL (Dyalog Unicode) , 17 15 byte

⌈∊∘1 5+.633*5-⊢

Provalo online!

I primi 13 termini (basati su 1) sono:

2 1 1 1 2 2 3 4 7 10 16 25 39

Suggerimento: la soluzione prevista utilizza una delle funzioni integrate meno utilizzate.

— bubbler
fonte

cracked

— ngn

@ngn Aggiornato l'invio della polizia :)

— Bubbler il

1

Husk , 5 byte ( rotto da Jonathan Allan )

$16$

←d+16

Provalo online!

$0 \leq n < 23$

1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3

$1,1,1,1,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3$

Spiegazione

←d+16  -- example input:  23
  +16  -- add 16:         39
 d     -- digits:         [3,9]
←      -- extract first:  3

Soluzione

LdΣ

— ბიმო
fonte

incrinato

— Jonathan Allan il

1

JavaScript, 25 byte ( 21 byte incrinati )

f=
x=>[7,11,12,13,13][x]||14

for(i=0;i<15;i++)
  console.log(i+"->"+f(i))

Espandi frammento

Sequenza di 7,11,12,13,13 seguita da infiniti 14 secondi.

Soluzione prevista 22 byte:

x = Math.atan (x + 1) * 10 | 0

Provalo online!

— fənɛtɪk
fonte

Cracked

— Arnauld,

0

JavaScript, 22 byte ( crackato )

f=
x=>(3-(5/63)**.5)**x|1

for(y=0;y<16;y++)
  console.log(y +"->"+f(y))

Espandi frammento

Questo è 0 indicizzato e l'accuratezza è richiesta fino a un input di 15. Non può essere trovato su OEIS

La mia soluzione 20 byte

x => 163 ** (32 * x / 163) | 1

Provalo online!

— fənɛtɪk
fonte

Cracked .

— Mr. Xcoder,

0

> <> , 42 byte, incrinato

i3%0v
642 .
840
789
159
a 1
v<<
n
l
?
\/
;

Provalo online!

Sequence to crack (0-indexed): 101786, 5844, 19902(non su OEIS).

Soluzione prevista , per riferimento.

— Aidan F. Pierce
fonte

Cracked

— Jo King

Di solito i ladri dovrebbero essere in grado di codificare il risultato in uscita

— Jo King

@JoKing Il tuo crack non sembra produrre alcun valore diverso dal mio (o forse non l'ho provato abbastanza a fondo per scoprire quali valori differiscono), ma probabilmente è facilmente rettificabile. Anche se non sembra esserci nulla nelle regole che vietano l'hardcoding, sono d'accordo che potrebbe non adattarsi allo spirito della sfida - in ogni caso hai dimostrato che l'hardcoding (per un poliziotto) comporta i suoi rischi.

— Aidan F. Pierce,

1

Ho aggiornato la mia risposta per produrre un valore diverso per4

— Jo King

0

Perl 6 , 53 byte

{(1,2,2,{$!=++$;prepend(@,2-$!%2 xx$_).pop}...*)[$_]}

Provalo online!

Blocco di codice anonimo che restituisce la sequenza di Kolakoski con indice 0 ( OEIS A000002 ). Sono necessarie soluzioni per abbinare i primi 130 elementi, quindi per alcuni n > 129differisce dalla sequenza di Kolakoski.

— Jo King
fonte

0

Pascal (FPC) , 86 byte ( crackato )

var n:word;begin read(n);write(n div 2+n div 4+n div 8+n div 16+n div 32+n div 64)end.

Provalo online!

$n=120$

0   0   1   1   3   3   4   4   7   7   8   8  10  10  11  11  15  15  16  16  18  18  19  19  22  22  23  23  25  25  26  26  31  31  32  32  34  34  35  35  38  38  39  39  41  41  42  42  46  46  47  47  49  49  50  50  53  53  54  54  56  56  57  57  63  63  64  64  66  66  67  67  70  70  71  71  73  73  74  74  78  78  79  79  81  81  82  82  85  85  86  86  88  88  89  89  94  94  95  95  97  97  98  98 101 101 102 102 104 104 105 105 109 109 110 110 112 112 113 113 116

La mia soluzione originale era

var n,i,s:word;begin read(n);i:=2;repeat s:=s+n div i;i:=i*2until i>n;write(s)end.

ma r_64 lo ha reso ancora migliore !

— AlexRacer
fonte

cracked

— Wheat Wizard

Hardcoding di Cops and Robbers (Cops)

Sfida

punteggio

cQuents , 4 byte ( Cracked )

Python 3 , 66 57 byte ( Cracked )

Python 2 , 44 byte ( crackato )

Wolfram Language (Mathematica) , 39 34 byte (Sicuro)

Crepa prevista

Haskell , 29 byte (Cracked: 1 , 2 )

Soluzione prevista (20 byte)

JavaScript (ES6), 12 byte ( crackato )

Malbolge, 10 byte

> <> , 276 byte ( crackato )

Gelatina , 6 byte , sicuro!

Crepa prevista

JavaScript, 26 byte ( crackato )

JavaScript, 16 byte ( crackato )

APL (Dyalog Unicode) , 17 15 byte

Husk , 5 byte ( rotto da Jonathan Allan )

Spiegazione

Soluzione

JavaScript, 25 byte ( 21 byte incrinati )

JavaScript, 22 byte ( crackato )

> <> , 42 byte, incrinato

Perl 6 , 53 byte

Pascal (FPC) , 86 byte ( crackato )