Ceci est le fil des voleurs. Le fil des flics va ici .

Dans le fil de la police, la tâche consistait à écrire un programme / une fonction qui prend un entier positif (ou non négatif) et génère / renvoie un autre nombre (pas nécessairement entier). La tâche des voleurs consiste à déchiffrer le code utilisé par les flics pour produire cette sortie.

Le code craqué ne doit pas être identique, tant qu'il a la même longueur et que tous les caractères révélés sont dans les bonnes positions. La langue doit également être la même (les numéros de version peuvent être différents). La sortie doit bien sûr être identique.

Aucune opération ne peut être utilisée dans la solution de voleur.

Le gagnant du fil de voleurs sera l'utilisateur qui a craqué le plus de soumissions d'ici le 7 mai 2016. S'il y a égalité, l'utilisateur qui a craqué les soumissions avec le code combiné le plus long gagnera.

La soumission doit être formatée comme suit:

Langue, nn caractères (y compris le lien vers la réponse), nom d'utilisateur du cop

Code:

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

Production

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

Explication et commentaires facultatifs.

MATL, 5 octets, Luis Mendo

H5-*|

Ce code calcule abs((2-5)*input)ce qui est juste a(n)=3*npour les nombres positifs, qui est http://oeis.org/A008585

Hexagonie , 7 octets, Adnan , A005843

?{2'*!@

ou

 ? {
2 ' *
 ! @

Essayez-le en ligne!

Double simplement l'entrée (et suppose une entrée positive). Le code est (pour une fois) simplement exécuté dans l'ordre de lecture. Le code utilise trois bords de mémoire A , B , C avec le pointeur de mémoire commençant comme indiqué:

?    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 octets, Cᴏɴᴏʀ O'Bʀɪᴇɴ

Code

2+*:@p:

Production

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

Essayez avec J.js .

Comment ça fonctionne

La séquence A061725 est définie comme un (n): = p _n ² + 2 , où p _n est le (n + 1) ^ème nombre premier.

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 octets , Adnan , A001788

Læ€OO

Essayez-le en ligne! Cela utilise une autre définition donnée sur la page. Explication:

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

JavaScript, 10 octets , user81655 , A033999

Je pense que je l'ai. Ouais. Celui-ci était vraiment dur. J'aime le mémoire parce qu'il s'appuie fortement sur les précédents.

C'est la séquence A033999 :

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

La source

t=>~t.z**t

Explication

Si vous divisez ce code en fonction des priorités de l'opérateur JavaScript, vous obtenez:

1. .(priorité 18 ) est évalué en premier et t.zrevient undefined.
2. ~(priorité 15 ) essaie de transtyper undefined, ce qui entraîne 0, et renvoie -1après pas au niveau du bit.
3. **(priorité 14 ) reviendra -1 ^ t, où test impair ou pair , résultant en -1ou 1.

Démo

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

Essayez avant d'acheter

Je vais attribuer une prime de 100 rep sur cette soumission de flic cool.

Élément , 7 octets , PhiNotPi , A000042

_'[,1`}

Remarques: J'ai été induit en erreur }pendant trop longtemps. Donc ça correspond aussi [.

Essayez-le en ligne!

Comment ça fonctionne:

_'[,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 octets , insertusernamehere , A079978

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

Renvoie 1 si son argument est un multiple de 3 et 0 sinon. Pas grand-chose au-delà.

MATL , 9 octets, bécher , A022844

Code (avec un espace à la fin):

3x2xYP*k 

Essayez-le en ligne!

J'ai trouvé les trois correspondances suivantes avec un script que j'ai écrit:

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.",

J'ai essayé de faire le premier, qui se fait essentiellement avec 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 octets , Easterly Irk , A001477

axx

Se compose d'un simple chat ( ax) suivi d'un no-op. Je ne sais pas ce que voulait le flic ici.

Java, 479 octets , Daniel M. , A000073

Code:

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 vous manquez des personnages non révélés, ils sont remplacés par des espaces.

Rubis, 38 octets, histocrate , A008592

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

Cela pourrait être différent de la solution prévue car j'ai trouvé cela à la main.

05AB1E , 4 octets, Paul Picard , A001317

Code:

$Fx^

Essayez-le en ligne!

Explication:

$      # 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 séquence est essentiellement un triangle binaire 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

Et se traduit par la formule a (n) = a (n - 1) XOR (2 × a (n - 1))

Heureusement, je me suis souvenu de celui-ci :)

SILOS , betseg , A001844

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

Essayez-le en ligne!

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

Code:

!K!8x

Production:

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

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

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

Production

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

Explication

J'ai complètement ignoré les commandes prédéfinies, sauf )parce que je n'avais pas assez d'espace.

Les commandes réellement utiles sont ici:

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

Étiré en ligne droite:

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

Avec explication:

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 formule est a(n) = n(3n+1)/2.

05AB1E, 3 octets , Adnan , A000292

LLO

Production

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

Comment ça fonctionne

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

L'équivalent mathématique est sum(sum(n)), où sumest summation.

Jolf, 11 octets, QPaysTaxes , A000005

aσ0xxdxxxxx

Assez simple: alert le σ0(nombre de diviseurs de) x, puis mettez des trucs inutiles à la fin.

Essayez-le en ligne! Le bouton de la suite de tests est un peu cassé, mais affiche toujours des résultats corrects.

(Vous auriez pu le jouer à deux octets! Cela σ0aurait bien fonctionné.)

Python 2, 87 octets , Sp3000 , A083054

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

Pas si difficile, en fait. Je viens de rechercher des séquences qui respectent les contraintes jusqu'à ce que j'en trouve une qui puisse être générée dans l'espace donné.

Jolf , 11 octets, RikerW , A011551

Code:

c*mf^+91x~P

Explication:

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

Essayez-le ici .

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

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

Je suis sûr que le code réel génère une séquence plus délicate que cela, mais avec seulement les deux sorties, cette séquence OEIS est simple et leur correspond.

Sans tous les caractères ignorés, l'algorithme est juste x=>x?Math.pow(10,x-1):0.

05AB1E , 5 octets, Luis Mendo , A051696

Code:

Ðms!¿

Explication:

Ð      # 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.

Donc, fondamentalement, cela calcule le pgcd (n !, n ⁿ ) , qui est A051696 .

Essayez-le en ligne! .

PHP, 18 octets, insertusernamehere , A023443

Code:

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

Production:

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

Octave (34 octets) par Stewie Griffin

La séquence est A066911 .

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

PHP, 137 octets, insertusernamehere , A000959

Code:

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];

Production:

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

05AB1E, 10 bytes, George Gibson, A003215

Code:

Ds3*s1+*1+

Explanation:

Computes 3*n*(n+1)+1 which is the oeis sequence A003215.

Element, 10 bytes, PhiNotPi, A097547

2_4:/2@^^`

Try it online!

Output

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

Pyke, 6 bytes, muddyfish, A005563

0QhXts

Yay hacks! The 0Qh and s are no-ops. hXt just computes (n + 1) ^ 2 - 1.

J, 8 bytes, Kenny Lau, A057427

Code:

(-%- )\.

Output:

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

I don't think this is intended. And I don't know why J had this behavior. But it works.

Pyth, 70 bytes, FliiFe, A070650

Code (with obfuscated version below):

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)

This basically does:

=^Q6%Q27

It calculates a(n) = n⁶ % 27, which is A070650. Explanation:

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

Try it here

Python, 108, CAD97, 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

Obfuscated code :

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

Outputs:

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