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

En el hilo de la policía, la tarea consistía en escribir un programa / función que tomara un número entero positivo (o no negativo) y generara / devuelve otro número (no necesariamente entero). La tarea de los ladrones es descifrar el código que los policías usaron para producir esta salida.

El código descifrado no tiene que ser idéntico, siempre que tenga la misma longitud y los caracteres revelados estén en las posiciones correctas. El idioma también debe ser el mismo (los números de versión pueden ser diferentes). La salida, por supuesto, debe ser idéntica.

No-ops se pueden utilizar en la solución de ladrón.

El ganador del hilo de ladrones será el usuario que haya descifrado la mayor cantidad de envíos antes del 7 de mayo de 2016. Si hay un empate, el usuario que haya descifrado los envíos con el código combinado más largo ganará.

La presentación debe tener el siguiente formato:

Idioma, nn caracteres (incluido el enlace para responder), nombre de usuario del policía

Código:

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

Salida

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

Explicación opcional y comentarios.

MATL, 5 bytes, Luis Mendo

H5-*|

Este código calcula abs((2-5)*input)cuál es solo a(n)=3*npara números positivos, que es http://oeis.org/A008585

Hexagonía , 7 bytes, Adnan , A005843

?{2'*!@

o

 ? {
2 ' *
 ! @

Pruébalo en línea!

Simplemente duplica la entrada (y supone una entrada positiva). El código se ejecuta (por una vez) simplemente en orden de lectura. El código usa tres bordes de memoria A , B , C con el puntero de memoria comenzando como se muestra:

?    Read integer from STDIN into edge A.
{    Move memory pointer forwards to edge B.
2    Set edge B to 2.
'    Move memory pointers backwards to edge C.
*    Multiply edges A and B and store result in C.
!    Print result to STDOUT.
@    Terminate program.

J, 7 bytes, Cᴏɴᴏʀ O'Bʀɪᴇɴ

Código

2+*:@p:

Salida

   f =: 2+*:@p:
   f 0
6
   f 2
27

Prueba con J.js .

Cómo funciona

Secuencia A061725 se define como a (n): = p _n ² + 2 , donde p _n es el (n + 1) ^ésimo número primo.

2+*:@p:  Monadic verb. Argument: n

    @    Atop; combine the verbs to the right and to the left, applying one after
         the other.
     p:  Compute the (n+1)th prime number.
  *:     Square it.
2+       Add 2 to the result.

05AB1E , 5 bytes , Adnan , A001788

Læ€OO

Pruébalo en línea! Esto utiliza una definición alternativa dada en la página. Explicación:

Læ€OO
L     range;      [1..n]
 æ    powerset;   [[], [1], ..., [1..n]]
  €O  mapped sum; [0, 1, ..., T(n)]
    O sum;        [a(n)]

JavaScript, 10 bytes , usuario81655 , A033999

Creo que lo tengo. Si.Este fue realmente difícil. Me gusta la presentación porque se basa en gran medida en las precedentes.

Es la secuencia A033999. :

a (n) = (-1) ^ n.

Fuente

t=>~t.z**t

Explicación

Si divide este código de acuerdo con las precedentes del operador de JavaScript, obtendrá:

1. .(precedencia 18 ) se evalúa primero y t.zregresará undefined.
2. ~(precedencia 15 ) intenta lanzar undefined, lo que resulta en 0, y regresa -1después de bit a bit no.
3. **(precedencia 14 ) regresará -1 ^ t, donde tsea impar o par , resultando en -1o 1.

Manifestación

console.log(
    (t=>~t.z**t)(0),
    (t=>~t.z**t)(1),
);

Probar antes de comprar

Otorgaré una recompensa de 100 repeticiones por esta genial presentación de policía.

Elemento , 7 bytes , PhiNotPi , A000042

_'[,1`}

Notas: Fui engañado por el }por mucho tiempo. Entonces también coincide[ .

Pruébalo en línea!

Cómo funciona:

_'[,1`}
_        main_stack.push(input());
 '       control_stack.push(main_stack.pop());
  [      Object temp = control_stack.pop();
         for(int i=0;i<temp;i++){
   ,         Object a = main_stack.pop(); //is actually zero
             main_stack.push(a.toChars()[0]);
             main_stack.push(a);
    1        main_stack.push(1);
     `       System.out.println(main_stack.pop());
      }  }

PHP, 41 bytes , insertusernamehere , A079978

echo/* does n%3=0 */$argv[1]%3<1?1:0    ;

Devuelve 1 si su argumento es múltiplo de 3 y 0 en caso contrario. No mucho más que eso.

MATL , 9 bytes, vaso de precipitados , A022844

Código (con un espacio en blanco al final):

3x2xYP*k 

Pruébalo en línea!

Encontré las siguientes tres coincidencias con un script que escribí:

Found match: A022844
info: "name": "Floor(n*Pi).",

Found match: A073934
info: "name": "Sum of terms in n-th row of triangle in A073932.",

Found match: A120068
info: "name": "Numbers n such that n-th prime + 1 is squarefree.",

Traté de hacer el primero, que básicamente se hace con YP*k:

3x2x       # Push 3, delete it, push 2 and delete that too
    YP     # Push pi
      *    # Multiply by implicit input
       k   # Floor function

Jolf, 3 bytes , Easterly Irk , A001477

axx

Consiste en un simple cat ( ax) seguido de un no-op. No estoy seguro de qué iba a hacer el policía aquí.

Java, 479 bytes , Daniel M. , A000073

Código:

import java.util.*;
public class A{

    public static int i=0;
    public boolean b;

    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++)if(ix>2){
            l.add(0,l//d
            .get(1)+l.peekFirst()+     l.get(2));
        }

        System.out.println(input<2?0:l.pop()
              +(A.i        +(/*( 5*/ 0 )));
    }
}

Si extrañas personajes no revelados, se reemplazan con espacios.

Ruby, 38 bytes, histocrat , A008592

->o{(s="+o++o"*5).sum==03333&&eval(s)}

Podría ser diferente de la solución prevista ya que encontré esto a mano.

05AB1E , 4 bytes, Paul Picard , A001317

Código:

$Fx^

Pruébalo en línea!

Explicación:

$      # Pushes 1 and input
 F     # Pops x, creates a for-loop in range(0, x)
  x    # Pops x, pushes x and 2x
   ^   # Bitwise XOR on the last two elements
       # Implicit, ends the for-loop
       # Implicit, nothing has printed so the last element is printed automatically

La secuencia básicamente es un triángulo binario de Sierpinski:

f(0)=      1                    =1
f(1)=     1 1                   =3
f(2)=    1 0 1                  =5
f(3)=   1 1 1 1                 =15
f(4)=  1 0 0 0 1                =17

Y se traduce en la fórmula a (n) = a (n - 1) XOR (2 × a (n - 1))

Por suerte, me acordé de este :)

SILOS , betseg , A001844

readIO
a=i
a+1
i*2
i*a
i+1
printInt i

Pruébalo en línea!

Jolf, 5 personajes , Cᴏɴᴏʀ O'Bʀɪᴇɴ , A033536

Código:

!K!8x

Salida:

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

Reng v3.3 , 36 bytes , Cᴏɴᴏʀ O'Bʀɪᴇɴ , A005449

iv:#+##->>)2%æ~¡#~
#>:3*1+*^##</div>

Salida

a(1) = 2
a(3) = 15

Explicación

Ignoré por completo los comandos preespecificados, excepto el ) porque no tenía suficiente espacio.

Los comandos realmente útiles están aquí:

iv      >>)2%æ~
 >:3*1+*^

Estirado en línea recta:

i:3*1+*)2%æ~

Con explicación:

i:3*1+*)2%æ~ stack
i            [1]      takes input
 :           [1,1]    duplicates
  3          [1,1,3]  pushes 3
   *         [1,3]    multiplies
    1        [1,3,1]  pushes 1
     +       [1,4]    adds
      *      [4]      multiplies
       )     [4]      shifts (does nothing)
        2    [4,2]    pushes 2
         %   [2]      divides
          æ  []       prints
           ~ []       halts

La formula es a(n) = n(3n+1)/2.

05AB1E, 3 bytes , Adnan , A000292

LLO

Salida

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

Cómo funciona

LLO Stack
L   [1,2,3,4,5,6,7,8,9]                         range
 L  [1,1,2,1,2,3,1,2,3,4,...,1,2,3,4,5,6,7,8,9] range of range
  O sum all of them

El equivalente matemático es sum(sum(n)), donde sumestá summation.

Jolf, 11 bytes, QPaysTaxes , A000005

aσ0xxdxxxxx

Suficientemente simple: aescribe el σ0(número de divisores de) x, luego coloca cosas inútiles al final.

Pruébalo en línea! El botón del conjunto de pruebas está un poco roto, pero aún muestra los resultados adecuados.

(¡Podrías haberlo reducido a dos bytes! Lo σ0hubiera hecho muy bien).

Python 2, 87 bytes , Sp3000 , A083054

n=input()
_=int(3**.5*n)-3*int(n/3**.5)########################################
print _

No es tan difícil, en realidad. Solo busqué secuencias que cumplieran con las restricciones hasta que encontré una que pudiera generarse en el espacio dado.

Jolf , 11 bytes, RikerW , A011551

Código:

c*mf^+91x~P

Explicación:

     +91     # add(9, 1) = 10
    ^   x    # 10 ** input
  mf         # floor function (no-op)
 *       ~P  # multiply by phi
c            # ¯\_(ツ)_/¯

Probar aquí .

JavaScript (ES6), 119 bytes, Cᴏɴᴏʀ O'Bʀɪᴇɴ , A178501

x=>(n="=>[[["|x|"##r(###f#n###;##")|n?Math.pow("#<1##].c####t.##pl##[####nc#"|10,"y([###(###(#]###)"|x-1|``):0|`#h####`

Estoy seguro de que el código real genera una secuencia más complicada que esta, pero con solo las dos salidas, esta secuencia OEIS es simple y coincide con ellas.

Sin todos los caracteres ignorados, el algoritmo es justo x=>x?Math.pow(10,x-1):0.

05AB1E , 5 bytes, Luis Mendo , A051696

Código:

Ðms!¿

Explicación:

Ð      # Triplicate input.
 m     # Power function, which calculates input ** input.
  s    # Swap two top elements of the stack.
   !   # Calculate the factorial of input.
    ¿  # Compute the greatest common divisor of the top two elements.

Entonces, básicamente esto calcula mcd (n !, n ⁿ ) , que es A051696 .

Pruébalo en línea! .

PHP, 18 bytes, insertusernamehere , A023443

Código:

echo$argv[1]+0+~0;

Salida:

a(0) = -1
a(1) = 0

Octava (34 bytes) por Stewie Griffin

La secuencia es A066911 .

@(m)(mod(m,u=1:m  )&isprime(u))*u'

PHP, 137 bytes, insertusernamehere nombre de , A000959

Código:

for($s=range(1,303);$i<($t=count($s));$s=array_merge($s))for($j=($k=++$i==1?2:$s[$i-1])-1;$j<$t;$j+=$k )unset($s[$j]);echo$s[$argv[1]-1];

Salida:

a(3)  =   7
a(7)  =  21
a(23) =  99

05AB1E, 10 bytes, George Gibson , A003215

Código:

Ds3*s1+*1+

Explicación:

Calcula 3 * n * (n + 1) +1, que es la secuencia oeis A003215.

Elemento , 10 bytes , PhiNotPi , A097547

2_4:/2@^^`

Pruébalo en línea!

Salida

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

Pyke, 6 bytes , pez lodo , A005563

0QhXts

Yay hacks! Los 0Qhy sson no-ops. hXtsolo computa (n + 1) ^ 2 - 1.

J, 8 bytes, Kenny Lau , A057427

Código:

(-%- )\.

Salida:

a(0) = 0
a(1..29) = 1

No creo que esto esté destinado. Y no sé por qué J tuvo este comportamiento. Pero funciona.

Pyth , 70 bytes, FliiFe , A070650

Código (con la versión ofuscada a continuación):

DhbI|qb"#"qb"#"R!1Iqb"#";=^Q6+""s ]%Q27  ;.qlY+Q1Ih+""Z##;.q)=Z+Z1;@YQ
DhbI|qb"#"qb"#"R!1Iqb"#"#####+""s####2###;##lY+Q1Ih+""Z#####)=Z+Z1;@YQ (obfuscated)

Esto básicamente hace:

=^Q6%Q27

Calcula a (n) = n ⁶ % 27 , que es A070650 . Explicación:

=^Q6       # Assign Q to Q ** 6
    %Q27   # Compute Q % 27
           # Implicit output

Pruébalo aquí

Python, 108, 97 CAD , A005132

def a(n):
 if n == 0: return 0
 f=a(n-1)-n
 return f if f>0 and not f in(a(i)for i in range(n))else a(n-1)+n

Código ofuscado:

def a(n):
 ###n####0######n#0
 f=a#######
 return f #f#####a###### f ####a(##f###i#i###a####n##else a#######

Salidas:

>>> a(0)
0
>>> a(4)
2
>>> a(16)
8
>>> a(20)
42