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

Nel thread di poliziotti, il compito era quello di scrivere un programma / funzione che accetta un numero intero positivo (o non negativo) e genera / restituisce un altro numero (non necessariamente intero). Il compito dei ladri è di decodificare il codice usato dai poliziotti per produrre questo output.

Il codice crackato non deve essere identico, purché abbia la stessa lunghezza e tutti i caratteri rivelati siano nelle posizioni corrette. Anche la lingua deve essere la stessa (i numeri di versione possono essere diversi). L'output deve ovviamente essere identico.

Nessuna operazione può essere utilizzata nella soluzione di rapinatore.

Il vincitore del thread dei ladri sarà l'utente che ha superato il maggior numero di richieste entro il 7 maggio 2016. In caso di pareggio, vincerà l'utente che ha infranto le richieste con il codice combinato più lungo.

L'invio deve essere formattato in questo modo:

Lingua, nn caratteri (incluso il link per rispondere), nome utente di Cop

Codice:

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

Produzione

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

Spiegazione e commenti opzionali.

MATL, 5 byte, Luis Mendo

H5-*|

Questo codice calcola abs((2-5)*input)quale è solo a(n)=3*nper i numeri positivi, che è http://oeis.org/A008585

Esagonia , 7 byte, Adnan , A005843

?{2'*!@

o

 ? {
2 ' *
 ! @

Provalo online!

Raddoppia semplicemente l'ingresso (e assume un input positivo). Il codice viene (per una volta) semplicemente eseguito in ordine di lettura. Il codice utilizza tre fronti di memoria A , B , C con il puntatore di memoria che inizia come mostrato:

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

Codice

2+*:@p:

Produzione

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

Da provare con J.js .

Come funziona

La sequenza A061725 è definita come a (n): = p _n ² + 2 , dove p _n è il (n + 1) ^th numero 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 byte , Adnan , A001788

Læ€OO

Provalo online! Questo utilizza una definizione alternativa fornita nella pagina. Spiegazione:

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

JavaScript, 10 byte , user81655 , A033999

Penso di averlo capito. Si. Questo è stato davvero difficile. Mi piace la presentazione perché si basa fortemente sulle precedenti.

È la sequenza A033999 :

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

fonte

t=>~t.z**t

Spiegazione

Se si divide questo codice in base alle precedenti dell'operatore JavaScript, si ottiene:

1. .(precedenza 18 ) viene valutato per primo e t.ztornerà undefined.
2. ~(precedenza 15 ) tenta di eseguire il cast undefined, risultando 0e ritorna -1dopo bit a bit no.
3. **(precedenza 14 ) tornerà -1 ^ t, dove tè dispari o persino , con conseguente -1o 1.

dimostrazione

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

Prova prima di acquistare

Assegnerò una ricompensa di 100 rappresentanti per questa fantastica presentazione da poliziotto.

Elemento , 7 byte , PhiNotPi , A000042

_'[,1`}

Note: Sono stato ingannato dal }per così tanto tempo. Quindi corrisponde anche [.

Provalo online!

Come funziona:

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

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

Restituisce 1 se il suo argomento è un multiplo di 3 e 0 altrimenti. Non molto oltre.

MATL , 9 byte, becher , A022844

Codice (con uno spazio bianco alla fine):

3x2xYP*k 

Provalo online!

Ho trovato le seguenti tre corrispondenze con una sceneggiatura che ho scritto:

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

Ho provato a fare il primo, che sostanzialmente è fatto 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 byte , Easterk Irk , A001477

axx

È costituito da un gatto semplice ( ax) seguito da una no-op. Non sono sicuro di cosa stesse andando a finire il poliziotto.

Java, 479 byte , Daniel M. , A000073

Codice:

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

Se perdi personaggi non rivelati, vengono sostituiti con spazi.

Rubino, 38 byte, istocratico , A008592

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

Potrebbe essere diverso dalla soluzione prevista come l'ho trovato a mano.

05AB1E , 4 byte, Paul Picard , A001317

Codice:

$Fx^

Provalo online!

Spiegazione:

$      # 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 sequenza è fondamentalmente un triangolo binario di 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

E si traduce nella formula a (n) = a (n - 1) XOR (2 × a (n - 1))

Per fortuna, mi sono ricordato questo :)

SILOS , betseg , A001844

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

Provalo online!

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

Codice:

!K!8x

Produzione:

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

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

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

Produzione

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

Spiegazione

Ho completamente ignorato i comandi prespecificati, tranne il )perché non avevo abbastanza spazio.

I comandi effettivamente utili sono qui:

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

Allungato su una linea retta:

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

Con spiegazione:

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

05AB1E, 3 byte , Adnan , A000292

LLO

Produzione

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

Come funziona

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'equivalente matematico è sum(sum(n)), dove sumè summation.

Jolf, 11 byte, QPaysTaxes , A000005

aσ0xxdxxxxx

Abbastanza semplice: a avvisa il σ0(numero di divisori di) x, quindi metti cose inutili alla fine.

Provalo online! Il pulsante della suite di test è un po 'rotto, ma mostra ancora risultati corretti.

(Avresti potuto giocare a golf fino a due byte! Avresti semplicemente σ0fatto bene.)

Python 2, 87 byte , Sp3000 , A083054

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

Non così difficile, in realtà. Ho solo cercato sequenze che soddisfacessero i vincoli fino a quando non ne ho trovato uno che poteva essere generato nello spazio indicato.

Jolf , 11 byte, RikerW , A011551

Codice:

c*mf^+91x~P

Spiegazione:

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

Provalo qui .

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

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

Sono sicuro che il codice effettivo genera una sequenza più complicata di questa, ma con solo i due output, questa sequenza OEIS è semplice e corrisponde a loro.

Senza tutti i caratteri ignorati, l'algoritmo è giusto x=>x?Math.pow(10,x-1):0.

05AB1E , 5 byte, Luis Mendo , A051696

Codice:

Ðms!¿

Spiegazione:

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

Quindi, fondamentalmente, questo calcola gcd (n !, n ⁿ ) , che è A051696 .

Provalo online! .

PHP, 18 byte, insertusernamehere , A023443

Codice:

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

Produzione:

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

Octave (34 byte) di Stewie Griffin

La sequenza è A066911 .

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

PHP, 137 byte, insertusernamehere , A000959

Codice:

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

Produzione:

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

05AB1E, 10 byte, George Gibson , A003215

Codice:

Ds3*s1+*1+

Spiegazione:

Calcola 3 * n * (n + 1) +1 che è la sequenza di oeis A003215.

Elemento , 10 byte , PhiNotPi , A097547

2_4:/2@^^`

Provalo online!

Produzione

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

Pyke, 6 byte , muddyfish , A005563

0QhXts

Yay hack! I 0Qhe snon sono operativi. hXtcalcola e basta (n + 1) ^ 2 - 1.

J, 8 byte, Kenny Lau , A057427

Codice:

(-%- )\.

Produzione:

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

Non penso che sia previsto. E non so perché J abbia avuto questo comportamento. Ma funziona

Pyth , 70 byte, FliiFe , A070650

Codice (con la versione offuscata di seguito):

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)

Questo sostanzialmente fa:

=^Q6%Q27

Calcola a (n) = n ⁶ % 27 , che è A070650 . Spiegazione:

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

Provalo qui

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

Codice offuscato:

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

Uscite:

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