Este é o tópico dos policiais. O fio dos ladrões vai aqui .

O último tópico de policiais e ladrões já foi há 4 meses .

A tarefa do policial

• A tarefa do policial é escrever um programa / função que pega um número inteiro positivo (ou não negativo) e gera / retorna outro número inteiro.
• O policial deve indicá-lo se o programa for intolerante em relação a zero.
• O policial fornecerá pelo menos 2 entradas / saídas de amostra.
• Por exemplo, se eu decidisse escrever a sequência de Fibonacci , escreveria isso na minha resposta:

a (0) retorna 0
a (3) retorna 2

• O número de exemplos fica a critério do policial.
• No entanto, a sequência deve realmente existir na Enciclopédia On-line de Sequências Inteiras® , portanto, nenhum gerador de números pseudo-aleatórios para você.:(
• O policial pode ocultar quantos caracteres desejar.
• Por exemplo, se meu programa for:

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

• Então eu ocultaria esses caracteres como eu quero:

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

A tarefa do ladrão

• é obviamente encontrar o código fonte original.
• No entanto, qualquer código-fonte proposto que produz o mesmo conjunto de saída também conta como válido, desde que também seja encontrado no OEIS.

Dicas para a polícia

• A função de pesquisa no OEIS funciona apenas por termos consecutivos; portanto, se você deseja ocultar sua sequência, deixe um buraco em qualquer lugar.
• Aparentemente, não há como ocultar a sequência. Lembre-se disso quando escolher a sequência.

Sua pontuação é o número de bytes no seu código.

O vencedor será a finalização com a pontuação mais baixa que não tenha sido quebrada em 7 dias.

Somente envios publicados em abril de 2016 são elegíveis para a vitória. Os envios publicados posteriormente são bem-vindos, mas não podem vencer.

Para reivindicar a vitória, você precisa revelar o código completo e a sequência OEIS (após 7 dias).

Sua postagem deve ter o seguinte formato (NN é o número de caracteres):

Lua, 98 bytes

Saída:

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

Código ( #marca caracteres não revelados):

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

Se o código estiver quebrado, insira [Cracked](link to cracker)no cabeçalho. Se o envio for seguro, insira "Seguro" no cabeçalho e revele o código completo em sua resposta. Somente respostas que revelaram o código completo serão elegíveis para a vitória.

Vim, 36 pressionamentos de tecla - Seguro!

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

(Nota: <n>é onde você digita sua entrada)

Aqui está o código não relacionado à geração de números:

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

Ou seja, estou revelando 5 dos 19 caracteres.

<n>é a entrada. Aqui estão alguns exemplos de saídas:

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

Responda

Esse código imprime os números de Lucas ( A000032 ), que são exatamente como The Fibonnaci Sequence, exceto que ele inicia em 2, 1vez de 1, 1. Aqui estão os 15 primeiros números:

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

Aqui está o código revelado:

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

Explicação:

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

Explicação da 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.

Agora, só precisamos remover o segundo número, pois o primeiro número é o número de lucas que queremos. Então nós fazemos

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

Além disso, se não me engano, este é o primeiro envio seguro! Isso é legal.

05AB1E , 5 bytes, seguro

Última de hoje: p. Saída:

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

Código:

___m_

Caracteres ofuscados são indicados com _. Experimente online! -ligação. Usa a codificação CP-1252 .

Solução:

žhžm‡

Explicação:

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

Experimente online! ou Tente para todos os casos de teste! .

Elemento , 7 bytes, quebrado

Saída:

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

Os #caracteres são ocultos e todos são ASCII imprimíveis. Eu acho que este é realmente razoavelmente difícil (por ter apenas 5 caracteres ausentes).

###,##}

Por conveniência, aqui estão as páginas wiki do Try It Online e Esolang .

Meu programa original era:

_'[,$ ` }

O truque é que

]e }são funcionalmente idênticos (ambos são traduzidos }em Perl). Além disso, eu costumava ,$produzir um 1como uma camada adicional de confusão, embora seja possível ignorar ,completamente fazendo isso ,1.

Jolf , 5 bytes, quebrado

Saída:

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

Tudo isso é crucial, e eu mostrei 1 de 5.

####x

Código original:

mPm$x
mP     cube
  m$   catalan number
    x  input

Experimente online!

JavaScript (ES7), 10 bytes, Cracked

Saída

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

Código

t=>~t##**#

Teste no Firefox todas as noites.O código é uma função anônima. Provavelmente será fácil, pois há apenas três caracteres ocultos, mas pelo menos é curto! : P

Meu código original era:

t=>~top**t

mas depois de forçar brutalmente meu próprio código para uma solução, logo percebi

t=>~t.x**t (Onde x pode haver qualquer caractere de nome de variável)

também pode ser usado. Isso funciona porque

nas especificações originais do operador de exponenciação do ES7, o operador tinha uma precedência menor do que os operadores unários (ao contrário da matemática convencional e da maioria dos outros idiomas). ~executa um NOT bit a bit em t.x( undefined) ou top( Object) que os converte em um número inteiro assinado de 32 bits (não podem ser convertidos como esses 0) antes de executar o NOT (assim 0se torna -1). Analisei mais a fundo e, recentemente, a especificação mudou para não permitir referências ambíguas como essa (não é bom para o futuro golfe D:), no entanto, a maioria dos motores ES7 ainda não atualizou a versão mais recente da especificação.

05AB1E, 4 bytes ( Cracked )

Saída de amostra:

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

E para o código:

###^

Eu revelei o último. Deve ser fácil, porém, tive muita dificuldade em encontrar uma sequência :(

Todos os caracteres ocultos são imprimíveis.

MATL , 5 bytes, quebrado

Caracteres ocultos são indicados por %.

%5%*%

Saída:

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

A entrada 0é válida.

Código original:

35B*s

isso é,

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 bytes, Rachado

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

* marca um caractere oculto

Saída:

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

Função aceita 0

Ruby, 46 bytes, seguro

Editar para adicionar isenção de responsabilidade / desculpas: Esta sequência começa com f [0], enquanto a entrada OEIS começa com f [1]. Os valores são os mesmos.

Código ofuscado ( #qualquer caractere):

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

Ligue como

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

Saída:

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

Solução:

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

Seqüência:

http://oeis.org/A029858

Explicação:

O truque menor aqui é que declaramos o parâmetro como *xmelhor que x. Isso significa que, se você entrar 2, xserá definido como [2]... primeiro. O principal truque explora a sintaxe Ruby bizarra e justamente obscura, na qual é possível definir o iterador em um loop for para qualquer lado esquerdo válido de uma expressão de atribuição, em vez de uma variável iteradora como i. Portanto, isso passa de 0 a (neste exemplo) 2, atribuindo cada número a x[-1], o que significa que substitui o último valor de x. Em seguida, o corpo do loop x*=3muda ainda mais x ao concatená-lo para si mesmo 3 vezes. Então, primeiro x se torna [0], então [0,0,0]. No próximo loop, torna-se [0,0,1]então [0,0,1,0,0,1,0,0,1]. Finalmente passamos em 2 e torna-se [0,0,1,0,0,1,0,0,2], então[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] . Em seguida, somamos o resultado usando oinject método, que reduz a matriz aplicando +(o método passado) a cada elemento por vez. Se considerarmos como cada iteração altera a soma, veremos que adicionamos efetivamente 1 (substituindo o último elemento por um elemento um mais alto) e multiplicamos por 3. Como 3*(n+1) = 3*n + 3isso implementa a relação de recorrência de Alexandre Wajnberg para a sequência, conforme descrito no página.

05AB1E , 3 bytes, quebrado

Saída:

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

Código oculto:

##O

Experimente online pode ser útil.

Hexagonia , 7 bytes, rachada

Saída:

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

Código oculto:

?#####@

Ou alternativamente:

 ? #
# # #
 # @

Experimente online pode ser útil.

PHP, 41 bytes, quebrado

Sim, finalmente outro desafio de Policiais e Ladrões. Espero não ter facilitado as coisas.

Saída

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

Fonte

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

Notas

• É um programa completo, não uma função.
• Lê a entrada da linha de comando (obviamente).
• Não contém nenhuma tag de abertura do PHP .

Rachado

Obviamente, facilitei e não forneci exemplos suficientes. A sequência que eu tinha em mente era A010054 :

a (n) = 1 se n for um número triangular mais 0.

Aqui está o meu código fonte original:

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

Ele testa se a entrada é um número triangular e gera 1ou não 0.

Jolf, 11 bytes, Rachado , A011551

c*______x__

c*mf^+91x~P

Código original:

c*^c"10"x~P

Exemplos:

0 -> 1

12 -> 1618033988749

MATL, 9 bytes, Rachado

Código:

3#2###*##

Saída:

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

a(0) é válido.

Rachado

Sequência original: A059563

Código original:

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

Java, 479 bytes, Rachado

Saídas:

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

(As entradas são fornecidas por meio de argumentos de linha de comando)

Código ( #marca caracteres ocultos):

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#####)));
    }
}

O programa inicia no índice 0.

(Observe que o SE substitui todos os \trecuos por 4 espaços, elevando o total de bytes para 569. Clique aqui para ver o programa com\t recuos em vez de recuos de espaço.)

Código original:

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)));
    }
}

(Mesmo código, mas formatado 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)));
    }
}

Oitava, 34 bytes, quebrada

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

Saídas:

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

A sequência começa ans(1)em OEIS.

C, 71 bytes rachados

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

Saída:

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

Isso funciona com o gcc e é um programa completo. Aceita 0 como entrada.

Pitão, 70 bytes, Rachado

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

# são os caracteres ocultos

Foi quebrado, então aqui está a versão sem caracteres ocultos:

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

Saídas de amostra:

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

Boa sorte para encontrar isso no OEIS, pessoalmente não consegui encontrá-lo nesses exemplos (mesmo que a sequência seja bastante fácil de identificar).

Ruby, 38 bytes, quebrado

Código ofuscado ( #pode ser qualquer caractere):

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

Saída:

Multiplica a entrada por 10 (A008592). Funciona para qualquer número inteiro, incluindo 0. por exemplo

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

05AB1E , 5 bytes, quebrado

Saída:

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

Código ofuscado:

_____

Experimente online! -ligação.

05AB1E , 4 bytes, quebrado

Bem, então, eu acho que sou viciado em CnR's ... Código ofuscado ( _indica um curinga):

____

Seqüência:

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

A sequência no OEIS começa em (1) = 2.

Experimente online! -ligação

Lua, 45 Bytes, Rachado

Uma pequena dica:

a(0) will make the program crash :)

Saída

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

Código

Usa #para ocultar o código :).

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

Eu estava usando o OEIS A007814 , com o seguinte código:

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

Pyke , 15 bytes, SEGURO

Saída

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

Código revelado:

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

Solução:

OEIS A038822
wR}DSR_Q*L+#P)l
Usei alguns arenques vermelhos aqui wR}para gerar o número 100 e revelar o caractere Rque normalmente é usado para girar a pilha. Eu também usei, em #P)lvez do mais simples, mPspara contar o número de números primos na sequência.

C, 82 bytes, seguro

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

Funciona com o gcc e é um programa completo, que lê sua entrada de stdin e imprime sua saída em stdout. Aqui a sequência é A004526, piso (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

Solução:

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

Isso funciona apenas em pequenas máquinas endian e apenas se o tamanho de char1 byte.
E somente se o byte mais alto que o byte de ordem mais alta ativer valor 0. Acho que isso é verdade para o gcc, pois, por padrão, variáveis ​​globais não inicializadas entram no segmento bss e variáveis ​​globais inicializadas entram no segmento de dados (consulte https: // stackoverflow.com/questions/8721475/if-a-global-variable-is-initialized-to-0-will-it-go-to-bss ).
Portanto, apenas aentra em bss (a única outra variável global bé inicializada e, portanto, entra no segmento de dados). Se anão estiver no final de bss, o byte superior ao byte de ordem mais alta atambém estará em bss e, portanto, terá o valor 0.

05AB1E, 1 byte, Rachado

_

_ denota código oculto.

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

Elemento , 10 bytes, quebrado

Saída:

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

Provavelmente, existem apenas algumas maneiras de calcular essa sequência no Element. Encontrei uma solução de 9 caracteres, mas achei que essa solução de 10 caracteres é realmente mais difícil. o# são caracteres ocultos.

#_####@^#`

Por conveniência, aqui está o wiki do Try It Online e do Esolangpáginas .

O original era

2_3:~2@^^`

Pyth , 18 bytes

# marca caracteres não revelados.

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

Saídas (começa em 1 ):

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

Intérprete online

05AB1E , 5 bytes, quebrado

Espero que este envio não seja tão fácil quanto os meus outros: p. Saídas:

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

Código ofuscado:

####O

Contém alguns caracteres não ASCII, porém, usa o CP-1252 codificação .

Experimente online! pode ser útil: p.

Jolf , 11 bytes, Rachado .

Saída:

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

E o código parcialmente oculto:

####xd###x#

Dica:

Quando examinei as seqüências em ordem, não fui muito longe antes de encontrar esta.

A versão crackeada não é exatamente igual ao meu código original. Atualmente, não estou no meu computador, então não o tenho exatamente, mas era algo assim:

l fzxd!m%xH

(A única parte da qual não tenho certeza é a !m. É o que verifica se uma variável é zero.)

Pyke , 6 bytes, Rachado

###X#s

Saída:

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

Isso não funciona com N <1

Solução original:

hSmX$s