Este es el hilo conductor de la policía. El hilo de los ladrones va aquí .

El último hilo de policías y ladrones ya fue hace 4 meses .

La tarea del policía

• La tarea del policía es escribir un programa / función que tome un entero positivo (o no negativo) y genere / devuelva otro entero.
• El policía debe indicarlo si el programa es intolerante hacia cero.
• El policía proporcionará al menos 2 entradas / salidas de muestra.
• Por ejemplo, si he decidido escribir la secuencia de Fibonacci , escribiría esto en mi respuesta:

a (0) devuelve 0
a (3) devuelve 2

• El número de ejemplos depende del criterio del policía.
• Sin embargo, la secuencia debe existir en la Enciclopedia en línea de secuencias enteras® , por lo que no hay un generador de números pseudoaleatorio para usted.:(
• El policía puede ocultar tantos personajes como desee.
• Por ejemplo, si mi programa es:

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

• Entonces escondería estos personajes como quiera:

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

La tarea del ladrón

• obviamente es encontrar el código fuente original.
• Sin embargo, cualquier código fuente propuesto que produzca el mismo conjunto de resultados también cuenta como válido, siempre que también se encuentre en OEIS.

Consejos para la policia

• La función de búsqueda en el OEIS solo funciona para términos consecutivos, por lo que si desea ocultar su secuencia, simplemente deje un agujero en cualquier lugar.
• Aparentemente no hay forma de ocultar la secuencia. Tenga esto en cuenta cuando elija la secuencia.

Su puntaje es el número de bytes en su código.

El ganador será la presentación con el puntaje más bajo que no se haya descifrado en 7 días.

Solo los envíos publicados en abril de 2016 son elegibles para la victoria. Las presentaciones que se publiquen después de esto son bienvenidas, pero no pueden ganar.

Para reclamar la victoria, debe revelar el código completo y la secuencia OEIS (después de 7 días).

Su publicación debe tener el siguiente formato (NN es el número de caracteres):

Lua, 98 bytes

Salida:

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

Código ( #marca caracteres no revelados):

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

Si el código está descifrado, insértelo [Cracked](link to cracker)en el encabezado. Si el envío es seguro, inserte "Seguro" en el encabezado y muestre el código completo en su respuesta. Solo las respuestas que hayan revelado el código completo serán elegibles para la victoria.

Vim, 36 pulsaciones de teclas - ¡Seguro!

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

(Nota: <n>es donde escribe su entrada)

Aquí está el código no relacionado con la generación de números:

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

Lo que significa que estoy revelando 5 de 19 caracteres.

<n>es la entrada Aquí hay algunos resultados de muestra:

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

Responder

Este código imprime los números de Lucas ( A000032 ), que son como la secuencia de Fibonnaci, excepto que comienza en 2, 1lugar de 1, 1. Aquí están los primeros 15 números:

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

Aquí está el código revelado:

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

Explicación:

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

Explicación de la 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.

Ahora, solo necesitamos eliminar el segundo número, ya que el primer número es el número de lucas que queremos. Entonces hacemos

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

Además, si no me equivoco, ¡esta es la primera presentación segura! Eso es genial.

05AB1E , 5 bytes, seguro

El último para hoy: p. Salida:

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

Código:

___m_

Los caracteres ofuscados se indican con _. Pruébalo en línea! -enlazar. Utiliza la codificación CP-1252 .

Solución:

žhžm‡

Explicación:

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

Pruébalo en línea! o ¡ Prueba todos los casos de prueba! .

Elemento , 7 bytes, agrietado

Salida:

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

El #son personajes ocultos, y todos ellos son ASCII imprimible. Creo que este en realidad es bastante difícil (por tener solo 5 caracteres faltantes).

###,##}

Para mayor comodidad, aquí están las páginas wiki de Try It Online y Esolang .

Mi programa original fue:

_'[,$ `` }

El truco es que

]y }son funcionalmente idénticos (ambos se traducen }en Perl). Además, solía ,$producir una 1capa adicional de confusión, aunque es posible ignorarla ,completamente haciendo en su ,1lugar.

Jolf , 5 bytes, agrietado

Salida:

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

Todo es crucial, y he mostrado 1 de 5.

####x

Código original:

mPm$x
mP     cube
  m$   catalan number
    x  input

Pruébalo en línea!

JavaScript (ES7), 10 bytes, Agrietado

Salida

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

Código

t=>~t##**#

Pruébalo en Firefox todas las noches. El código es una función anónima. Esto probablemente será fácil ya que solo hay tres caracteres ocultos, ¡pero al menos es corto! :PAGS

Mi código original fue:

t=>~top**t

pero después de forzar mi propio código para una solución, pronto me di cuenta

t=>~t.x**t(donde xpuede haber cualquier carácter de nombre variable)

También podría ser utilizado. Esto funciona porque

en la especificación original del operador de exponenciación ES7, el operador tenía una precedencia menor que los operadores unarios (a diferencia de las matemáticas convencionales y la mayoría de los otros lenguajes). ~realiza un NOT a nivel de bit en t.x( undefined) o top( Object) que los convierte en un entero con signo de 32 bits (se vuelven inestables como estos 0) antes de hacer el NOT (así se 0convierte -1). Investigué más sobre esto, y muy recientemente, la especificación ha cambiado para no permitir referencias ambiguas como esta (no es bueno para el futuro golf D:), sin embargo, la mayoría de los motores ES7 aún no se han actualizado a la última versión de la especificación.

05AB1E, 4 bytes ( agrietado )

Salida de muestra:

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

Y para el código:

###^

Revelé el último. Sin embargo, debería ser bastante fácil, me costó bastante encontrar una secuencia :(

Todos los personajes ocultos son imprimibles.

MATL , 5 bytes, agrietado

Los caracteres ocultos se indican con %.

%5%*%

Salida:

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

La entrada 0es válida.

Código original:

35B*s

es decir,

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, agrietado

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

* marca un personaje oculto

Salida:

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

La función acepta 0

Ruby, 46 bytes, seguro

Editar para agregar descargo de responsabilidad / disculpa: Esta secuencia comienza con f [0], mientras que la entrada OEIS comienza con f [1]. Los valores son iguales.

Código ofuscado ( #es cualquier carácter):

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

Llamar como

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

Salida:

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

Solución:

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

Secuencia:

http://oeis.org/A029858

Explicación:

El truco menor aquí es que declaramos el parámetro en *xlugar de hacerlo x. Esto significa que si pasa 2, xse establece en [2]... al principio. El truco principal explota la sintaxis de Ruby extraña y justamente oscura, donde puede establecer el iterador en un bucle for en cualquier lado izquierdo válido de una expresión de asignación, en lugar de una variable de iterador como i. Entonces esto recorre de 0 a (en este ejemplo) 2, asignando cada número a x[-1], lo que significa que sobrescribe el último valor de x. Luego, el cuerpo del bucle x*=3, muta más x concatenando a sí mismo 3 veces. Entonces primero x se convierte [0], entonces [0,0,0]. En el siguiente ciclo se convierte [0,0,1], entonces [0,0,1,0,0,1,0,0,1]. Finalmente pasamos 2 y se convierte[0,0,1,0,0,1,0,0,2] , luego[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]. Luego sumamos el resultado usando el injectmétodo, que reduce la matriz aplicando +(el método pasado) a cada elemento a su vez. Si consideramos cómo cada iteración cambia la suma, vemos que efectivamente agregamos 1 (sobrescribiendo el último elemento con un elemento uno más alto), luego multiplicamos por 3. Como 3*(n+1) = 3*n + 3esto implementa la relación de recurrencia de Alexandre Wajnberg para la secuencia como se describe en el página.

05AB1E , 3 bytes, agrietado

Salida:

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

Código oculto:

##O

Pruébelo en línea puede ser útil.

Hexagonía , 7 bytes, agrietada

Salida:

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

Código oculto:

?#####@

O alternativamente:

 ? #
# # #
 # @

Pruébelo en línea puede ser útil.

PHP, 41 bytes, agrietado

Sí, finalmente otro desafío de policías y ladrones. Espero no haberlo hecho fácil.

Salida

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

Fuente

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

Notas

• Es un programa completo, no una función.
• Lee la entrada de la línea de comando (obviamente).
• No contiene ninguna etiqueta de apertura de PHP .

Agrietado

Obviamente lo hice fácil y no proporcioné suficientes ejemplos. La secuencia que tenía en mente era A010054 :

a (n) = 1 si n es un número triangular más 0.

Aquí está mi código fuente original:

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

Comprueba si la entrada es un número triangular y las salidas 1o en 0consecuencia.

Jolf, 11 bytes, agrietado , A011551

c*______x__

c*mf^+91x~P

Código original:

c*^c"10"x~P

Ejemplos:

0 -> 1

12 -> 1618033988749

MATL, 9 bytes, Agrietado

Código:

3#2###*##

Salida:

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

a(0) es válido.

Agrietado

Secuencia 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, agrietado

Salidas:

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

(Las entradas se proporcionan a través de argumentos de línea 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#####)));
    }
}

El programa comienza en el índice 0.

(Tenga en cuenta que SE reemplaza todas las \tsangrías con 4 espacios, con lo que el total de bytes es de 569. Haga clic aquí para ver el programa con\t sangrías en lugar de sangrías de espacio).

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

(Mismo código, pero formateado 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)));
    }
}

Octava, 34 bytes, agrietada

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

Salidas:

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

La secuencia comienza ans(1)en OEIS.

C, 71 bytes agrietados

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

Salida:

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

Esto funciona con gcc y es un programa completo. Acepta 0 como entrada.

Pyth, 70 bytes, agrietado

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

# son los personajes ocultos

Se ha descifrado, así que aquí está la versión sin caracteres ocultos:

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

Resultados de muestra:

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

Buena suerte para encontrar esto en OEIS, personalmente no pude encontrarlo en esos ejemplos (aunque la secuencia es bastante fácil de detectar).

Ruby, 38 bytes, agrietado

Código ofuscado ( #puede ser cualquier carácter):

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

Salida:

Multiplica la entrada por 10 (A008592). Funciona para cualquier número entero, incluido 0. ej.

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

05AB1E , 5 bytes, agrietado

Salida:

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:

_____

Pruébalo en línea! -enlazar.

05AB1E , 4 bytes, agrietado

Bueno, entonces, creo que soy adicto a CnR ... Código ofuscado ( _indica un comodín):

____

Secuencia:

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

La secuencia en OEIS comienza en a (1) = 2.

Pruébalo en línea! -enlazar

Lua, 45 bytes, agrietada

Una pequeña pista:

a(0) will make the program crash :)

Salida

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

Código

Utiliza #para ocultar el código :).

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

Estaba usando el OEIS A007814 , con el siguiente código:

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

Pyke , 15 bytes, SEGURO

Salida

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

Código revelado:

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

Solución:

OEIS A038822
wR}DSR_Q*L+#P)l
un par de aquí wR}para generar el número 100 y revelar el personaje Rque normalmente se usa para rotar la pila. También usé en #P)llugar del más simple mPspara contar el número de primos en la secuencia.

C, 82 bytes, seguro

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

Funciona con gcc, y es un programa completo, que lee su entrada desde stdin e imprime su salida en stdout. Aquí la secuencia es 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

Solución:

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

Esto funciona solo en pequeñas máquinas endian, y solo si el tamaño chares de 1 byte.
Y solo si el byte más alto que el byte de orden más alto de atiene valor 0. Creo que esto es cierto para gcc ya que por defecto las variables globales no inicializadas van al segmento bss, y las variables globales inicializadas van al segmento de datos (ver https: // stackoverflow.com/questions/8721475/if-a-global-variable-is-initialized-to-0-will-it-go-to-bss ).
Por lo tanto, solo aentra en bss (la única otra variable global bse inicializa y, por lo tanto, entra en el segmento de datos). Si ano está al final de bss, entonces el byte más alto que el byte de orden más alto atambién está en bss y, por lo tanto, tiene el valor 0.

05AB1E, 1 byte, agrietado

_

_ denota código oculto.

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

Elemento , 10 bytes, agrietado

Salida:

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

Probablemente solo haya algunas formas de calcular esta secuencia en Element. Encontré una solución de 9 caracteres, pero pensé que esta solución de 10 caracteres es en realidad más difícil. El #son personajes ocultos.

#_####@^#`

Para mayor comodidad, aquí están las páginas wiki de Try It Online y Esolang .

El original era

2_3:~2@^^`

Pyth , 18 bytes

# marca caracteres no revelados.

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

Salidas (comienza desde 1):

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

Intérprete en línea

05AB1E , 5 bytes, agrietado

Espero que esta presentación no sea tan fácil como las otras: p. Salidas:

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

Código ofuscado:

####O

Sin embargo, contiene algunos caracteres no ASCII, utiliza la codificación CP-1252 .

Pruébalo en línea! podría ser útil: p.

Jolf , 11 bytes, agrietado .

Salida:

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

Y el código parcialmente oculto:

####xd###x#

Insinuación:

Cuando miré las secuencias en orden, no fui muy lejos antes de encontrar esta.

La versión descifrada no es la misma que mi código original. Actualmente no estoy en mi computadora, así que no la tengo exactamente, pero era algo así:

l fzxd!m%xH

(La única parte de la que no estoy seguro es: !mes lo que verifica si una variable es cero).

Pyke , 6 bytes, agrietado

###X#s

Salida:

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

Esto no funciona con N <1

Solución original:

hSmX$s