Questo è il filo della polizia. Il filo dei ladri va qui .

L'ultimo thread di poliziotti e ladri è stato già 4 mesi fa .

Il compito del poliziotto

• Il compito del poliziotto è scrivere un programma / funzione che accetta un numero intero positivo (o non negativo) e restituisce / restituisce un altro numero intero.
• Il poliziotto deve dichiararlo se il programma è intollerante verso zero.
• Il poliziotto fornirà almeno 2 input / output di esempio.
• Ad esempio, se avessi deciso di scrivere la sequenza di Fibonacci , avrei scritto questo nella mia risposta:

a (0) restituisce 0
a (3) restituisce 2

• Il numero di esempi dipende dalla discrezione del poliziotto.
• Tuttavia, la sequenza deve effettivamente esistere nell'Enciclopedia on-line di Integer Sequences® , quindi nessun generatore di numeri pseudo-casuali per te.:(
• Il poliziotto può nascondere tutti i personaggi desiderati.
• Ad esempio, se il mio programma è:

function a(n)
    if n>2 then
        return n
    else
        return a(n-1) + a(n-2)
    end
end

• Quindi nasconderei questi personaggi come voglio:

function a(n)
    if ### then
        ########
    else
        ######################
    end
end

Il compito del ladro

• è ovviamente quello di trovare il codice sorgente originale.
• Tuttavia, qualsiasi codice sorgente proposto che produce lo stesso set di output viene considerato valido, purché si trovi anche in OEIS.

Suggerimenti per gli sbirri

• La funzione di ricerca in OEIS funziona solo per termini consecutivi, quindi se vuoi nascondere la sequenza, lascia un buco ovunque.
• Apparentemente non c'è modo di nascondere la sequenza. Ricordalo quando scegli la sequenza.

Il tuo punteggio è il numero di byte nel tuo codice.

Il vincitore sarà l'invio con il punteggio più basso che non è stato crackato in 7 giorni.

Solo gli invii pubblicati ad aprile 2016 sono idonei per la vittoria. Gli invii pubblicati in un momento successivo sono i benvenuti, ma non possono vincere.

Per richiedere la vincita devi rivelare il codice completo e la sequenza OEIS (dopo 7 giorni).

Il tuo post dovrebbe essere formattato in questo modo (NN è il numero di caratteri):

Lua, 98 byte

Produzione:

a(0) returns 0
a(3) returns 2

Codice ( #segna caratteri non rivelati):

function a(n)
    if ### then
        ########
    else
        ######################
    end
end

Se il codice è crackato, inserire [Cracked](link to cracker)nell'intestazione. Se l'invio è sicuro, inserisci "Sicuro" nell'intestazione e rivela il codice completo nella tua risposta. Solo le risposte che hanno rivelato il codice completo saranno idonee per la vittoria.

Vim, 36 sequenze di tasti - Sicuro!

i****<esc>:let @q="^*i****$**@***"<cr><n>@qbD

(Nota: <n>è dove si digita l'input)

Ecco il codice non correlato alla generazione di numeri:

          :let @q="              "<cr><n>@qbD

Significa che sto rivelando 5 personaggi su 19.

<n>è l'input. Ecco alcuni esempi di output:

1@q:    1
2@q:    3
6@q:    18

Risposta

Questo codice stampa The Lucas Numbers ( A000032 ), che sono proprio come The Fibonnaci Sequence, tranne per il fatto che inizia 2, 1invece di 1, 1. Ecco i primi 15 numeri:

2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, 199, 322, 521, 843

Ecco il codice rivelato:

i2 1 <esc>:let @q="^diwwyw$pb@-<c-v><c-a>"<cr><n>@qbD

Spiegazione:

i2 1 <esc>                          "Insert the starting numbers
          :let @q="....."<cr>       "Define the macro 'Q'

Spiegazione della macro:

^                      "Move to the first non-whitespace character on the line.
 diw                   "(d)elete (i)nner (w)ord. This is different then 'dw' because it doesn't grab the space. 
                      "It also throws people off since 'i' is usually used for inserting text.
    wyw$               "Move to the next number, yank it then move to the end of the line 
        pb             "(p)aste the yanked text and move (b)ack
          @-     <c-a> "@- is the register holding the word we deleted. Increment the current number that many times.
            <c-v>      "Since we're adding <c-a> this from the command line, we need to type it as a literal.

Ora, dobbiamo solo rimuovere il secondo numero, poiché il primo numero è il numero di lucas che vogliamo. Quindi lo facciamo

b   "move (b)ack
 D  "(D)elete to the end of the line.

Inoltre, se non sbaglio, questa è la prima presentazione sicura! È fantastico.

05AB1E , 5 byte, sicuro

L'ultimo per oggi: p. Produzione:

a(0) = 9
a(5) = 4
a(10) = 89

Codice:

___m_

I caratteri offuscati sono indicati con _. Provalo online! -LINK. Utilizza la codifica CP-1252 .

Soluzione:

žhžm‡

Spiegazione:

žh       # Short for [0-9].
  žm     # Short for [9-0].
    ‡    # Translate.

Provalo online! oppure prova per tutti i casi di test! .

Elemento , 7 byte, rotto

Produzione:

a(3) = 111
a(7) = 1111111

Il #sono i caratteri nascosti, e sono tutti ASCII stampabile. Penso che questo sia in realtà ragionevolmente difficile (per avere solo 5 personaggi mancanti).

###,##}

Per comodità, ecco il pagine wiki Try It Online ed Esolang .

Il mio programma originale era:

_'[,$ ` }

Il trucco è quello

]e }sono funzionalmente identici (entrambi tradotti in }in Perl). Inoltre, ho usato ,$per produrre 1un ulteriore livello di confusione, anche se è possibile ignorare ,completamente facendo ,1invece.

Jolf , 5 byte, rotto

Produzione:

a(2) = 8
a(10) = 4738245926336

Tutto questo è cruciale e ho mostrato 1 di 5.

####x

Codice originale:

mPm$x
mP     cube
  m$   catalan number
    x  input

Provalo online!

JavaScript (ES7), 10 byte, Cracked

Produzione

f(0) -> 1
f(1) -> -1

Codice

t=>~t##**#

Provalo in Firefox ogni notte. Il codice è una funzione anonima. Questo sarà probabilmente facile poiché ci sono solo tre personaggi nascosti, ma almeno è breve! : P

Il mio codice originale era:

t=>~top**t

ma dopo aver forzato brutalmente il mio codice per una soluzione, ho capito presto

t=>~t.x**t(dove xpuò essere qualsiasi carattere con nome variabile)

potrebbe anche essere usato. Questo funziona perché

nelle specifiche dell'operatore esponenziale ES7 originale, l'operatore aveva una precedenza inferiore rispetto agli operatori unari (a differenza della matematica convenzionale e della maggior parte delle altre lingue). ~esegue un NOT bit a bit su t.x( undefined) o top( Object) che li lancia a un intero con segno a 32 bit (gli uncastabili come questi diventano 0) prima di fare il NOT (così 0diventa -1). Ho approfondito questo aspetto e, molto recentemente, le specifiche sono cambiate per non consentire riferimenti ambigui come questo (non va bene per il futuro golf D:), tuttavia la maggior parte dei motori ES7 non ha ancora aggiornato l'ultima versione delle specifiche.

05AB1E, 4 byte ( Cracking )

Uscita campione:

a(5) = 51
a(8) = 257

E per il codice:

###^

Ho rivelato l'ultimo. Dovrebbe essere abbastanza facile, però, ho avuto difficoltà a trovare una sequenza :(

Tutti i personaggi nascosti sono stampabili.

MATL , 5 byte, incrinato

I caratteri nascosti sono indicati da %.

%5%*%

Produzione:

a(1) = 3
a(2) = 6
a(4) = 12

Ingresso 0 è valida

Codice originale:

35B*s

questo è,

35    % push number 35
B     % convert to binary: array [1 0 0 0 1 1]
*     % multiply element-wise by implicit input n: gives [n 0 0 0 n n]
s     % sum of array: gives 3*n

SWIFT, 55 byte, Cracked

func M(n:Int)->Int{
return(n*****) ?M(**n****):n***;
}

* segna un personaggio nascosto

Produzione:

M(30) -> 91
M(60) -> 91
M(90) -> 91
M(120)-> 110
M(150)-> 140

La funzione accetta 0

Rubino, 46 ​​byte, sicuro

Modifica per aggiungere disclaimer / scuse: questa sequenza inizia con f [0], mentre la voce OEIS inizia con f [1]. I valori sono gli stessi

Codice offuscato ( #qualsiasi carattere):

->####or x##1###(#..##0#);x*=3;end;#.###ect:+}

Chiama come

->####or x##1###(#..##0#);x*=3;end;#.###ect:+}[3] (returns 39)

Produzione:

f[0] = 0
f[1] = 3
f[2] = 12
f[3] = 39
f[4] = 120
f[5] = 363
f[6] = 1092
f[7] = 3279
f[8] = 9840
f[9] = 29523

Soluzione:

f=->*x{for x[-1]in(0..x[0]);x*=3;end;x.inject:+}

Sequenza:

http://oeis.org/A029858

Spiegazione:

Il trucco minore qui è che dichiariamo il parametro come *xpiuttosto che x. Ciò significa che se si passa 2, all'inizio xè impostato su [2]... Il trucco principale sfrutta la sintassi bizzarra e giustamente oscura di Ruby in cui è possibile impostare l'iteratore in un ciclo for su qualsiasi lato sinistro valido di un'espressione di assegnazione, invece di una variabile iteratore come i. Quindi questo passa da 0 a (in questo esempio) 2, assegnando ogni numero a x[-1], nel senso che sovrascrive l'ultimo valore di x. Quindi il corpo del loop x*=3, muta ulteriormente x concatenandolo a se stesso 3 volte. Quindi prima diventa x [0], quindi [0,0,0]. Nel ciclo successivo diventa [0,0,1], quindi [0,0,1,0,0,1,0,0,1]. Finalmente passiamo in 2 e diventa[0,0,1,0,0,1,0,0,2] , quindi[0, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 1, 0, 0, 2]. Quindi sommiamo il risultato usando il injectmetodo, che riduce l'array applicando +(il metodo passato) a ciascun elemento a sua volta. Se consideriamo come ogni iterazione modifica la somma, vediamo che aggiungiamo effettivamente 1 (sovrascrivendo l'ultimo elemento con un elemento uno superiore), quindi moltipliciamo per 3. Poiché 3*(n+1) = 3*n + 3, questo implementa la relazione di ricorrenza di Alexandre Wajnberg per la sequenza come descritto nella pagina.

05AB1E , 3 byte, incrinato

Produzione:

a(9) = 165
a(10) = 220

Codice nascosto:

##O

Provalo online potrebbe tornare utile.

Esagonia , 7 byte, incrinata

Produzione:

a(1) = 2
a(2) = 4

Codice nascosto:

?#####@

O in alternativa:

 ? #
# # #
 # @

Provalo online potrebbe tornare utile.

PHP, 41 byte, crackato

Sì, finalmente un'altra sfida per poliziotti e ladri. Spero di non averlo fatto facile.

Produzione

a(5)   = 0
a(15)  = 1
a(35)  = 0
a(36)  = 1
a(45)  = 1

fonte

____________________$argv[1]____________;
####################        ############

Gli appunti

• È un programma completo, non una funzione.
• Legge l'input dalla riga di comando (ovviamente).
• Non contiene alcun tag di apertura PHP .

Cracked

Ovviamente l'ho reso semplice e non ho fornito abbastanza esempi. La sequenza che avevo in mente era A010054 :

a (n) = 1 se n è un numero triangolare altrimenti 0.

Ecco il mio codice sorgente originale:

echo(int)($r=sqrt(8*$argv[1]+1))==$r?1:0;

Verifica se l'input è un numero triangolare e output 1o di 0conseguenza.

Jolf, 11 byte, Cracked , A011551

c*______x__

c*mf^+91x~P

Codice originale:

c*^c"10"x~P

Esempi:

0 -> 1

12 -> 1618033988749

MATL, 9 byte, Cracked

Codice:

3#2###*##

Produzione:

a(1)  = 3
a(2)  = 6
a(4)  = 12
a(12) = 37

a(0) è valido.

Cracked

Sequenza originale: A059563

Codice originale:

3L2^Ze*sk
3L          % Push [1 -1j] from the clipboard
  2^        % square
    Ze      % exp
      *     % times input
       s    % sum
        k   % floor

Java, 479 byte, Cracked

Uscite:

a(10) = 81
a(20) = 35890

(Gli input sono forniti tramite argomenti della riga di comando)

Codice ( #contrassegna i caratteri nascosti):

import java.util.*;
public class A{

    public static int#########
    public boolean###########

    static A a = new A();

    public static void main(String[] args){
        int input = Integer.parseInt(args[0]);

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);
        l.add(0);
        l.add(0);

        for(int ix = 0; ################if(##>##{
            ###########d#
            #######+##p##########+##########(#######
        }

        System.out.println(#########################
            ###(A.#############(#5#####)));
    }
}

Il programma inizia dall'indice 0.

(Si noti che SE sostituisce tutti i \trientri con 4 spazi, portando il totale dei byte a 569. Fare clic qui per vedere il programma con\t rientri anziché rientri di spazio.)

Codice originale:

import java.util.*;
public class A{
    public static interface B{
    public boolean C(int i);} 

    static A a = new A();

    public static void main(String[] args){
        int input = Integer.parseInt(args[0]);

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);
        l.add(0);
        l.add(0);

        for(int ix = 0; ix<input; ix++)cif(i->  {
            return l.add(
            l.pop()+l.peekFirst()+l.peekLast());});{    
        }

        System.out.println(l.get(1));}static boolean 
            cif(A.B b5){return (b5.C((0)));
    }
}

(Stesso codice, ma formattato normalmente):

import java.util.*;

public class A {
    public static interface B { //functional interface for lambda expression
        public boolean C(int i); //void would have given it away
    }

    static A a = new A(); //distraction

    public static void main(String[] args) {
        int input = Integer.parseInt(args[0]);//Input

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);//Set up list
        l.add(0);
        l.add(0);

        for (int ix = 0; ix < input; ix++)
            cif(i -> { //Fake if statement is really a lambda expression
                return l.add(l.pop() + l.peekFirst() + l.peekLast());
            });
        { //Distraction
        }

        System.out.println(l.get(1));//Output
    }

    static boolean cif(A.B b5) { //Used to pass in lambda expression.
                  //The A. and b5 were both distractions
        return (b5.C((0)));
    }
}

Ottava, 34 byte, incrinata

@(m)(m###m#####m##)&isprime(#)####

Uscite:

ans(1) = 0
ans(6) = 5
ans(7) = 10
ans(8) = 15

La sequenza inizia ans(1)in OEIS.

C, 71 byte incrinati

############
#####
main(){
 scanf("%d",##);
 ###6#;
 printf("%d",##);
}

Produzione:

a(1) = 0   a(2) = 0   a(5) = 1
a(6) = 1   a(7) = 1   a(9) = 2

Funziona con gcc ed è un programma completo. Accetta 0 come input.

Pyth, 70 byte, Cracked

DhbI|qb"#"qb"#"R!1Iqb"#"#####+""s####2###;##lY+Q1Ih+""Z#####)=Z+Z1;@YQ

# sono i personaggi nascosti

È stato crackato, quindi ecco la versionn senza caratteri nascosti:

DhbI|qb"4"qb"0"R!1Iqb"1"R!0Rh+""sm^sd2cb1;W<lY+Q1Ih+""Z=Y+YZ)=Z+Z1;@YQ

Output di esempio:

a(2) -> 10
a(4) -> 19

Buona fortuna a trovarlo su OEIS, personalmente non sono riuscito a trovarlo da quegli esempi (anche se la sequenza è abbastanza facile da individuare.)

Rubino, 38 byte, incrinato

Codice offuscato ( #può essere qualsiasi carattere):

->#{(s=#########).sum==#3333&&eval(s)}

Produzione:

Moltiplica l'ingresso per 10 (A008592). Funziona con qualsiasi numero intero, incluso 0. es

->#{(s=#########).sum==#3333&&eval(s)}[3]  => 30
->#{(s=#########).sum==#3333&&eval(s)}[10] => 100

05AB1E , 5 byte, incrinato

Produzione:

a(0) = 0
a(1) = 0
a(2) = 1
a(3) = 1
a(4) = 1
a(5) = 1
a(6) = 1
a(7) = 1
a(8) = 1
a(9) = 1
a(10) = 0
a(11) = 0

Codice offuscato:

_____

Provalo online! -LINK.

05AB1E , 4 byte, incrinato

Bene, allora penso di essere dipendente dal CnR ... Codice offuscato ( _indica un carattere jolly):

____

Sequenza:

a(1) = 2
a(4) = 6720

La sequenza in OEIS inizia con a (1) = 2.

Provalo online! -LINK

Lua, 45 byte, incrinato

Un piccolo suggerimento:

a(0) will make the program crash :)

Produzione

a(1)=>0
a(2)=>1

Codice

Usa #per nascondere il codice :).

a=function(n)#####n###### and #or ########end

Stavo usando OEIS A007814 , con il seguente codice:

a=function(n)return n%2>0 and 0or 1+a(n/2)end

Pyke , 15 byte, SICURO

Produzione

a(2) = 21
a(15) = 17

Codice rivelato:

#R#D######+##)#

Soluzione:

OEIS A038822
wR}DSR_Q*L+#P)l
Ho usato un paio di aringhe rosse qui usando wR}per generare il numero 100 e rivelando il personaggio Rche è normalmente usato per ruotare la pila. Ho anche usato al #P)lposto del più semplice mPscontare il numero di numeri primi nella sequenza.

C, 82 byte, sicuro

####=############
main(i){scanf("%d",##);
for(i=1;i++/4<#;)##=2;
printf("%d",##);}

Funziona con gcc ed è un programma completo, che legge i suoi input da stdin e stampa i suoi output su stdout. Qui la sequenza è A004526, piano (n / 2) .

a(0) = 0    a(1) = 0    a(2) = 1
a(3) = 1    a(4) = 2    a(5) = 2
a(6) = 3    a(7) = 3    a(8) = 4

Soluzione:

a;*b=(char*)&a+1;
main(i){scanf("%d",&a);
for(i=1;i++/4<2;)a*=2;
printf("%d",*b);}

Funziona solo su macchine little endian e solo se la dimensione di charè 1 byte.
E solo se il byte più alto del byte di ordine più alto aha valore 0. Penso che questo sia vero per gcc poiché le variabili globali non inizializzate di default vanno nel segmento bss e le variabili globali inizializzate vanno nel segmento di dati (vedi https: // stackoverflow.com/questions/8721475/if-a-global-variable-is-initialized-to-0-will-it-go-to-bss ).
Quindi ava solo in bss (l'unica altra variabile globale bviene inizializzata e quindi va nel segmento di dati). Se anon è alla fine di bss, allora anche il byte più alto del byte di ordine più alto di aè in bss e quindi ha valore 0.

05AB1E, 1 byte, Cracking

_

_ denota codice nascosto.

f(1) == 1
f(18) == 6

Elemento , 10 byte, rotto

Produzione:

a(3) = 6561
a(4) = 4294967296

Probabilmente ci sono solo alcuni modi per calcolare questa sequenza in Element. Ho trovato una soluzione a 9 caratteri, ma ho pensato che questa soluzione a 10 caratteri fosse in realtà più difficile. Il# sono personaggi nascosti.

#_####@^#`

Per comodità, ecco il wiki Try It Online ed Esolang pagine .

L'originale era

2_3:~2@^^`

Pyth , 18 byte

# segna i caratteri non rivelati.

L?Jtb##5#m##S#2 #y

Uscite (inizia da 1):

1 -> 2
2 -> 3
3 -> 5
4 -> 7

Interprete online

05AB1E , 5 byte, incrinato

Spero che questa presentazione non sia facile come le mie altre: p. Uscite:

a(0) = 0
a(1) = 1
a(2) = 6
a(3) = 24
a(4) = 80
a(5) = 240

Codice offuscato:

####O

Contiene alcuni caratteri non ASCII, tuttavia codifica CP-1252 .

Provalo online! potrebbe tornare utile: p.

Jolf , 11 byte, incrinato .

Produzione:

a(10) = 4
a(20) = 6
a(30) = 8

E il codice parzialmente nascosto:

####xd###x#

Suggerimento:

Quando ho guardato le sequenze in ordine, non sono andato molto lontano prima di trovare questo.

The cracked version isn't quite the same as my original code. I'm not currently at my computer, so I don't have it exactly, but it was something like this:

l fzxd!m%xH

(The only part I'm unsure about is the !m. It's whatever checks if a variable is zero.)

Pyke, 6 bytes, Cracked

###X#s

Output:

a(2) = 8
a(8) = 80
a(10) = 120

This doesn't work with N<1

Original solution:

hSmX$s