Das ist der Räuberfaden. Der Faden der Bullen geht hier .

Im cops-Thread bestand die Aufgabe darin, ein Programm / eine Funktion zu schreiben, die eine positive (oder nicht negative) Ganzzahl annimmt und eine andere Zahl ausgibt / zurückgibt (nicht unbedingt eine Ganzzahl). Die Aufgabe des Räubers besteht darin, den Code zu entschlüsseln, mit dem die Cops diese Ausgabe erstellt haben.

Der geknackte Code muss nicht identisch sein, solange er dieselbe Länge hat und sich alle offenbarten Zeichen an den richtigen Positionen befinden. Die Sprache muss auch gleich sein (Versionsnummern können unterschiedlich sein). Die Ausgabe muss natürlich identisch sein.

No-Ops können in der Räuberlösung verwendet werden.

Der Gewinner des Räuber-Threads ist der Benutzer, der bis zum 7. Mai 2016 die meisten Beiträge geknackt hat. Bei einem Gleichstand gewinnt der Benutzer, der Beiträge mit dem längsten kombinierten Code geknackt hat.

Die Einreichung sollte folgendermaßen formatiert sein:

Sprache, nn Zeichen (einschließlich Link zur Antwort), Cop's Benutzername

Code:

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

Ausgabe

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

Optionale Erklärung und Kommentare.

MATL, 5 Bytes, Luis Mendo

H5-*|

Dieser Code berechnet, abs((2-5)*input)was nur a(n)=3*nfür positive Zahlen gilt, also http://oeis.org/A008585

Hexagony , 7 Bytes, Adnan , A005843

?{2'*!@

oder

 ? {
2 ' *
 ! @

Probieren Sie es online!

Verdoppelt einfach die Eingabe (und setzt positive Eingabe voraus). Der Code wird (einmalig) einfach in Lesereihenfolge ausgeführt. Der Code verwendet drei Speicherflanken A , B , C, wobei der Speicherzeiger wie folgt beginnt:

?    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ʀɪᴇɴ

Code

2+*:@p:

Ausgabe

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

Probieren Sie es mit J.js .

Wie es funktioniert

Sequence A061725 ist definiert als A (n): = p _n ² + 2 , wobei p _n ist der (n + 1) ^-ten Primzahl.

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

Probieren Sie es online! Dies verwendet eine alternative Definition, die auf der Seite angegeben ist. Erläuterung:

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

Ich glaube, ich habe es verstanden. Ja. Dieser war wirklich schwer. Ich mag die Einreichung, weil sie stark von Präzedenzfällen abhängt.

Es ist die Sequenz A033999 :

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

Quelle

t=>~t.z**t

Erläuterung

Wenn Sie diesen Code gemäß den Prioritäten des JavaScript-Operators aufteilen, erhalten Sie:

1. .(Priorität 18 ) wird zuerst ausgewertet und t.zkehrt zurück undefined.
2. ~(Vorrang 15 ) versucht zu casten undefined, was dazu führt 0, und kehrt -1nach bitweisem nicht zurück.
3. **(Priorität 14 ) zurückkehren -1 ^ t, wo tist ungerade oder sogar , was zu -1oder 1.

Demo

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

Versuchen Sie es vor dem Kauf

Ich werde eine Prämie von 100 Wiederholungen für diese coole Cop-Einreichung vergeben.

Element , 7 Bytes , PhiNotPi , A000042

_'[,1`}

Anmerkungen: Ich wurde }soooooo lange von der irregeführt. So passt es auch [.

Probieren Sie es online!

Wie es funktioniert:

_'[,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    ;

Gibt 1 zurück, wenn das Argument ein Vielfaches von 3 ist, andernfalls 0. Nicht viel darüber hinaus.

MATL , 9 Bytes, Becher , A022844

Code (mit einem Leerzeichen am Ende):

3x2xYP*k 

Probieren Sie es online!

Die folgenden drei Übereinstimmungen wurden mit einem von mir geschriebenen Skript gefunden:

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

Ich habe versucht, die erste zu machen, was im Grunde genommen geschieht mit 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

Besteht aus einer einfachen Katze ( ax), gefolgt von einem No-Op. Ich bin mir nicht sicher, was der Polizist hier vorhatte.

Java, 479 Bytes , 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 )));
    }
}

Wenn Sie nicht aufgedeckte Zeichen vermissen, werden diese durch Leerzeichen ersetzt.

Ruby, 38 Bytes, Histokrat , A008592

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

Könnte sich von der beabsichtigten Lösung unterscheiden, da ich dies von Hand fand.

05AB1E , 4 Bytes, Paul Picard , A001317

Code:

$Fx^

Probieren Sie es online!

Erläuterung:

$      # 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

Die Folge ist im Grunde ein binäres Sierpinski-Dreieck:

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

Und übersetzt in die Formel a (n) = a (n - 1) XOR (2 × a (n - 1))

Zum Glück erinnerte ich mich an dieses :)

SILOS , Betseg , A001844

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

Probieren Sie es online!

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

Code:

!K!8x

Ausgabe:

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

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

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

Ausgabe

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

Erläuterung

Ich habe die vorgegebenen Befehle vollständig ignoriert, außer den, )weil ich nicht genügend Speicherplatz hatte.

Die eigentlich nützlichen Befehle sind hier:

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

Zu einer geraden Linie gestreckt:

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

Mit Erklärung:

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

Die Formel lautet a(n) = n(3n+1)/2.

05AB1E, 3 Bytes , Adnan , A000292

LLO

Ausgabe

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

Wie es funktioniert

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

Das mathematische Äquivalent ist sum(sum(n)), wo sumist summation.

Jolf, 11 Byte, QPaysTaxes , A000005

aσ0xxdxxxxx

Einfach genug: alass die σ0(Anzahl der Teiler von) x, dann setze nutzloses Zeug am Ende.

Probieren Sie es online! Die Testsuite-Schaltfläche ist ein bisschen kaputt, zeigt aber immer noch die richtigen Ergebnisse.

(Du hättest es auf zwei Bytes reduzieren können! Hätte es einfach σ0gut gemacht.)

Python 2, 87 Bytes , Sp3000 , A083054

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

Eigentlich nicht so schwer. Ich habe nur nach Sequenzen gesucht, die die Einschränkungen erfüllten, bis ich eine gefunden habe, die in dem angegebenen Raum generiert werden konnte.

Jolf , 11 Bytes, RikerW , A011551

Code:

c*mf^+91x~P

Erläuterung:

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

Probieren Sie es hier aus .

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####`

Ich bin sicher, dass der eigentliche Code eine schwierigere Sequenz als diese generiert, aber mit nur den zwei Ausgaben ist diese OEIS-Sequenz einfach und stimmt mit ihnen überein.

Ohne alle ignorierten Zeichen ist der Algorithmus gerecht x=>x?Math.pow(10,x-1):0.

05AB1E , 5 Bytes, Luis Mendo , A051696

Code:

Ðms!¿

Erläuterung:

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

Im Grunde berechnet dies also gcd (n !, n ⁿ ) , was A051696 ist .

Probieren Sie es online! .

PHP, 18 Bytes, insertusernamehere , A023443

Code:

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

Ausgabe:

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

Oktave (34 Bytes) von Stewie Griffin

Die Sequenz ist A066911 .

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

PHP, 137 Bytes, 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];

Ausgabe:

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

05AB1E, 10 Bytes, George Gibson , A003215

Code:

Ds3*s1+*1+

Erläuterung:

Berechnet 3 * n * (n + 1) +1, was die oeis-Sequenz A003215 ist.

Element , 10 Bytes , PhiNotPi , A097547

2_4:/2@^^`

Probieren Sie es online!

Ausgabe

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

Pyke, 6 Bytes , Schlammfisch , A005563

0QhXts

Yay Hacks! Die 0Qhund ssind No-Ops. hXtrechnet einfach (n + 1) ^ 2 - 1.

J, 8 Bytes, Kenny Lau , A057427

Code:

(-%- )\.

Ausgabe:

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

Ich denke nicht, dass das beabsichtigt ist. Und ich weiß nicht, warum J dieses Verhalten hatte. Aber es funktioniert.

Pyth , 70 Bytes, FliiFe , A070650

Code (mit verschleierter Version unten):

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)

Dies macht im Grunde:

=^Q6%Q27

Es berechnet a (n) = n ⁶ % 27 , was A070650 ist . Erläuterung:

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

Probieren Sie es hier aus

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

Verschleierter Code:

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

Ausgänge:

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