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

Der letzte Cops-and-Robbers- Thread war bereits vor 4 Monaten .

Die Aufgabe des Polizisten

• Der Cop hat die Aufgabe, ein Programm / eine Funktion zu schreiben, die eine positive (oder nicht negative) Ganzzahl verwendet und eine andere Ganzzahl ausgibt / zurückgibt.
• Der Polizist muss es angeben, wenn das Programm gegen Null intolerant ist.
• Der Cop stellt mindestens 2 Sample-Ein- / Ausgänge zur Verfügung.
• Wenn ich zum Beispiel beschlossen hätte, die Fibonacci-Sequenz zu schreiben , würde ich dies in meine Antwort schreiben:

a (0) gibt 0 zurück
a (3) gibt 2 zurück

• Die Anzahl der Beispiele liegt im Ermessen des Polizisten.
• Die Sequenz muss jedoch tatsächlich in der On-Line Encyclopedia of Integer Sequences® vorhanden sein , sodass Sie keinen Pseudozufallszahlengenerator benötigen.:(
• Der Cop kann beliebig viele Zeichen verstecken.
• Zum Beispiel, wenn mein Programm ist:

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

• Dann würde ich diese Zeichen verstecken, wie ich will:

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

Die Aufgabe des Räubers

• ist natürlich der original quellcode zu finden.
• Jeder vorgeschlagene Quellcode, der dieselbe Ausgabe erzeugt, gilt jedoch auch als gültig, sofern er auch in OEIS enthalten ist.

Tipps für die Bullen

• Die Suchfunktion im OEIS funktioniert nur bei aufeinanderfolgenden Begriffen. Wenn Sie also Ihre Sequenz verbergen möchten, lassen Sie einfach irgendwo ein Loch frei.
• Anscheinend gibt es keine Möglichkeit, die Sequenz zu verbergen. Denken Sie daran, wenn Sie die Reihenfolge auswählen.

Ihre Punktzahl ist die Anzahl der Bytes in Ihrem Code.

Der Gewinner ist die Einsendung mit der niedrigsten Punktzahl, die seit 7 Tagen nicht geknackt wurde.

Nur Einsendungen, die im April 2016 veröffentlicht wurden, sind für den Gewinn berechtigt. Später eingereichte Beiträge sind willkommen, können aber nicht gewinnen.

Um den Gewinn zu beanspruchen, müssen Sie den vollständigen Code und die OEIS-Sequenz (nach 7 Tagen) offenlegen.

Dein Beitrag sollte folgendermaßen formatiert sein (NN ist die Anzahl der Zeichen):

Lua, 98 Bytes

Ausgabe:

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

Code ( #kennzeichnet nicht aufgedeckte Zeichen):

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

Wenn der Code geknackt ist, fügen Sie ihn [Cracked](link to cracker)in die Kopfzeile ein. Wenn die Übermittlung sicher ist, fügen Sie "Sicher" in die Kopfzeile ein und geben Sie den vollständigen Code in Ihrer Antwort an. Nur Antworten, die den vollständigen Code enthüllt haben, sind für den Gewinn berechtigt.

Vim, 36 Tastenanschläge - Sicher!

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

(Hinweis: <n>Hier geben Sie Ihre Eingabe ein.)

Hier ist der Code, der nichts mit der Nummerngenerierung zu tun hat:

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

Das heißt, ich zeige 5 von 19 Zeichen.

<n>ist der Eingang. Hier sind einige Beispielausgaben:

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

Antworten

Dieser Code gibt die Lucas-Nummern ( A000032 ) aus, die genau wie die Fibonnaci-Sequenz sind, mit der Ausnahme, dass sie am 2, 1statt beginnen 1, 1. Hier sind die ersten 15 Zahlen:

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

Hier ist der aufgedeckte Code:

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

Erläuterung:

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

Erklärung des Makros:

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

Jetzt müssen wir nur noch die zweite Zahl entfernen, da die erste Zahl die von uns gewünschte Lucas-Zahl ist. So machen wir es

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

Wenn ich mich nicht irre, ist dies auch die erste sichere Einreichung! Das ist irgendwie cool.

05AB1E , 5 Byte, sicher

Letzter für heute: p. Ausgabe:

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

Code:

___m_

Verschleierte Zeichen sind mit gekennzeichnet _. Probieren Sie es online! -Verknüpfung. Verwendet die CP-1252- Codierung.

Lösung:

žhžm‡

Erläuterung:

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

Probieren Sie es online! oder Für alle Testfälle testen! .

Element , 7 Bytes, geknackt

Ausgabe:

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

Das #sind versteckte Zeichen, und sie sind alle druckbare ASCII-Zeichen. Ich denke, dass dies einigermaßen schwierig ist (da nur 5 Zeichen fehlen).

###,##}

Der Einfachheit halber finden Sie hier die Wiki- Seiten Try It Online und Esolang .

Mein ursprüngliches Programm war:

_'[,$ ` }

Der Trick ist das

]und }sind funktional identisch (beide werden }in Perl übersetzt). Außerdem habe ich ,$eine zu produzieren 1als zusätzliche Schicht von Verwirrung, obwohl es möglich ist , das zu ignorieren ,vollständig , indem Sie ,1statt.

Jolf , 5 Bytes, geknackt

Ausgabe:

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

Alles ist entscheidend, und ich habe 1 von 5 gezeigt.

####x

Originalcode:

mPm$x
mP     cube
  m$   catalan number
    x  input

Probieren Sie es online!

JavaScript (ES7), 10 Bytes, Gebrochen

Ausgabe

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

Code

t=>~t##**#

Teste es jeden Abend in Firefox. Der Code ist eine anonyme Funktion. Dies wird wahrscheinlich einfach sein, da nur drei Zeichen versteckt sind, aber zumindest ist es kurz! : P

Mein ursprünglicher Code war:

t=>~top**t

aber nachdem ich meinen eigenen Code für eine Lösung brachial durchgesetzt hatte, wurde mir bald klar

t=>~t.x**t(Wo xkann ein beliebiger Variablenname stehen?)

könnte auch verwendet werden. Das funktioniert weil

In der ursprünglichen ES7-Exponentiationsoperatorspezifikation hatte der Operator eine niedrigere Priorität als unäre Operatoren (im Gegensatz zu konventioneller Mathematik und den meisten anderen Sprachen). ~führt ein bitweises NOT auf t.x( undefined) oder top( Object) aus, das sie in eine 32-Bit-Ganzzahl mit Vorzeichen umwandelt (Uncastables wie diese werden 0), bevor das NOT ausgeführt wird (so 0wird es -1). Ich habe mir das genauer angesehen und vor kurzem hat sich die Spezifikation dahingehend geändert, dass mehrdeutige Referenzen wie diese nicht mehr zugelassen werden (nicht gut für künftiges Golfen D:), jedoch haben die meisten ES7-Motoren noch nicht auf die neueste Version der Spezifikation aktualisiert.

05AB1E, 4 Bytes ( geknackt )

Beispielausgabe:

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

Und für den Code:

###^

Ich habe den letzten aufgedeckt. Sollte aber einfach genug sein, hatte ich es ziemlich schwer, eine Sequenz zu finden :(

Alle versteckten Zeichen können ausgedruckt werden.

MATL , 5 Bytes, geknackt

Versteckte Zeichen sind durch gekennzeichnet %.

%5%*%

Ausgabe:

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

Die Eingabe 0ist gültig.

Originalcode:

35B*s

das ist,

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

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

* markiert ein verstecktes Zeichen

Ausgabe:

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

Funktion akzeptiert 0

Ruby, 46 Bytes, sicher

Bearbeiten, um Haftungsausschluss / Entschuldigung hinzuzufügen: Diese Sequenz beginnt mit f [0], während der OEIS-Eintrag mit f [1] beginnt. Die Werte sind gleich.

Verschleierter Code ( #ist ein beliebiges Zeichen):

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

Rufen Sie gerne an

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

Ausgabe:

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

Lösung:

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

Reihenfolge:

http://oeis.org/A029858

Erläuterung:

Der kleine Trick dabei ist, dass wir den Parameter als *xund nicht als deklarieren x. Dies bedeutet, dass, wenn Sie übergeben 2, zunächst xauf [2]... eingestellt ist. Der Haupt Trick ausnutzt bizarre, und mit Recht verdunkeln, Rubin - Syntax , wo man den Iterator in einer for - Schleife zu jeder gültigen linken Seite einer Zuweisung Ausdruck wie anstelle einer Iteratorvariable einstellen kann i. Dies durchläuft also eine Schleife von 0 bis (in diesem Beispiel) 2, wobei jede Zahl zugewiesen wird x[-1], was bedeutet, dass der letzte Wert von x überschrieben wird. Dann x*=3mutiert der Schleifenkörper x weiter, indem er es dreimal mit sich selbst verkettet. Also wird zuerst x [0], dann [0,0,0]. Auf der nächsten Schleife wird es [0,0,1]dann [0,0,1,0,0,1,0,0,1]. Schließlich übergeben wir 2 und es wird [0,0,1,0,0,1,0,0,2]dann[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]. Wir addieren dann das Ergebnis mit der injectMethode, die das Array reduziert, indem wir +die übergebene Methode nacheinander auf jedes Element anwenden . Wenn man bedenkt , wie jede Iteration die Summe ändert, sehen wir , dass wir effektiv 1 hinzufügen (durch das letzte Element mit einem Elemente einer höheren Überschreiben), dann mit 3 multiplizieren Da 3*(n+1) = 3*n + 3, Implementiert Alexandre Wajnberg der Rekursion für die Sequenz als auf dem beschriebenen Seite.

05AB1E , 3 Bytes, geknackt

Ausgabe:

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

Versteckter Code:

##O

Versuchen Sie es online könnte sich als nützlich erweisen.

Hexagony , 7 Bytes, geknackt

Ausgabe:

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

Versteckter Code:

?#####@

Oder alternativ:

 ? #
# # #
 # @

Versuchen Sie es online könnte sich als nützlich erweisen.

PHP, 41 Bytes, geknackt

Ja, endlich eine weitere Herausforderung für Cops and Robbers. Hoffe, ich habe es nicht zu einfach gemacht.

Ausgabe

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

Quelle

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

Anmerkungen

• Es ist ein volles Programm, keine Funktion.
• Liest die Eingabe von der Befehlszeile (offensichtlich).
• Enthält kein PHP-Eröffnungstag .

Geknackt

Ich habe es offensichtlich zu einfach gemacht und nicht genug Beispiele geliefert. Die Sequenz, die ich mir vorgestellt hatte, war A010054 :

a (n) = 1, wenn n eine Dreieckszahl ist, sonst 0.

Hier ist mein ursprünglicher Quellcode:

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

Es prüft, ob die Eingabe eine Dreieckszahl ist und gibt sie aus 1oder 0dementsprechend.

Jolf, 11 Bytes, Gebrochen , A011551

c*______x__

c*mf^+91x~P

Originalcode:

c*^c"10"x~P

Beispiele:

0 -> 1

12 -> 1618033988749

MATL, 9 Bytes, Gebrochen

Code:

3#2###*##

Ausgabe:

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

a(0) ist gültig.

Geknackt

Originalsequenz: A059563

Originalcode:

3L2^Ze*sk
3L          % Push [1 -1j] from the clipboard
  2^        % square
    Ze      % exp
      *     % times input
       s    % sum
        k   % floor

Java, 479 Bytes, Gebrochen

Ausgänge:

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

(Eingaben werden über Befehlszeilenargumente bereitgestellt)

Code ( #markiert versteckte Zeichen):

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

Das Programm startet bei Index 0.

(Beachten Sie, dass SE alle \tEinrückungen durch 4 Leerzeichen ersetzt und die Bytesumme auf 569 erhöht. Klicken Sie hier , um das Programm mit \tEinrückungen anstelle von Leerzeichen anzuzeigen.)

Originalcode:

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

(Gleicher Code, aber normal formatiert):

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

Oktave, 34 Bytes, geknackt

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

Ausgänge:

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

Die Sequenz beginnt um ans(1)in OEIS.

C, 71 Bytes geknackt

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

Ausgabe:

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

Dies funktioniert mit gcc und ist ein volles Programm. Es akzeptiert 0 als Eingabe.

Pyth, 70 Bytes, Gebrochen

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

# sind die versteckten Zeichen

Wurde geknackt, so ist hier die versionn ohne versteckte Zeichen:

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

Beispielausgaben:

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

Viel Glück, dies auf OEIS zu finden, ich persönlich habe es aus diesen Beispielen nicht herausgefunden (auch wenn die Sequenz ziemlich leicht zu erkennen ist.)

Ruby, 38 Bytes, geknackt

Verschleierter Code ( #kann ein beliebiges Zeichen sein):

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

Ausgabe:

Multipliziert die Eingabe mit 10 (A008592). Funktioniert für jede Ganzzahl, einschließlich 0. zB

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

05AB1E , 5 Bytes, geknackt

Ausgabe:

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

Verschleierter Code:

_____

Probieren Sie es online! -Verknüpfung.

05AB1E , 4 Bytes, geknackt

Nun, ich glaube, ich bin süchtig nach CnRs ... Verschleierter Code ( _zeigt einen Joker an):

____

Reihenfolge:

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

Die Sequenz in OEIS beginnt bei a (1) = 2.

Probieren Sie es online! -Verknüpfung

Lua, 45 Bytes, Gebrochen

Ein kleiner Hinweis:

a(0) will make the program crash :)

Ausgabe

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

Code

Verwendet #, um den Code zu verbergen :).

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

Ich habe den OEIS A007814 mit dem folgenden Code verwendet:

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

Pyke , 15 Bytes, SICHER

Ausgabe

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

Aufgedeckter Code:

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

Lösung:

OEIS A038822
wR}DSR_Q*L+#P)l
Ich habe hier ein paar rote Heringe verwendet wR}, um die Zahl 100 zu generieren und das Zeichen anzuzeigen,R das normalerweise zum Drehen des Stapels verwendet wird. Ich habe auch #P)lanstelle der einfacheren verwendet, mPsum die Anzahl der Primzahlen in der Sequenz zu zählen.

C, 82 Bytes, sicher

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

Funktioniert mit gcc und ist ein vollständiges Programm, das seine Eingabe von stdin liest und seine Ausgabe an stdout ausgibt. Hier ist die Sequenz A004526, Etage (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

Lösung:

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

Dies funktioniert nur auf kleinen Endian-Rechnern und nur, wenn die Größe char1 Byte beträgt.
Und nur wenn das höherwertige Byte den aWert 0 hat. Ich denke, dies gilt für gcc, da standardmäßig nicht initialisierte globale Variablen in das Segment bss und initialisierte globale Variablen in das Datensegment gehen (siehe https: // stackoverflow.com/questions/8721475/if-a-global-variable-is-initialized-to-0-will-it-go-to-bss ). Geht
also nur ain bss (die einzige andere globale Variable bwird initialisiert und geht somit in das Datensegment). Befindet asich das Byte nicht am Ende von bss, dann befindet sich auch das Byte, das höher als das höchstwertige Byte von aist, in bss und hat somit den Wert 0.

05AB1E, 1 Byte, geknackt

_

_ bezeichnet versteckten Code.

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

Element , 10 Bytes, geknackt

Ausgabe:

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

Es gibt wahrscheinlich nur wenige Möglichkeiten, diese Sequenz in Element zu berechnen. Ich habe eine 9-Zeichen-Lösung gefunden, aber ich dachte, diese 10-Zeichen-Lösung ist tatsächlich schwieriger. Das #sind versteckte Zeichen.

#_####@^#`

Der Einfachheit halber finden Sie hier die Wiki- Seiten Try It Online und Esolang .

Das Original war

2_3:~2@^^`

Pyth , 18 Bytes

# markiert nicht aufgedeckte Zeichen.

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

Ausgänge (ab 1):

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

Online-Dolmetscher

05AB1E , 5 Bytes, geknackt

Ich hoffe, dass diese Einreichung nicht so einfach ist wie meine anderen: p. Ausgänge:

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

Verschleierter Code:

####O

Enthält jedoch einige Nicht-ASCII-Zeichen, die verwendet werden CP-1252- Codierung.

Probieren Sie es online! könnte sich als nützlich erweisen: p.

Jolf , 11 Bytes, Gebrochen .

Ausgabe:

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

Und der teilweise versteckte Code:

####xd###x#

Hinweis:

Als ich die Sequenzen der Reihe nach durchgesehen habe, bin ich nicht sehr weit gegangen, bis ich diese gefunden habe.

Die geknackte Version stimmt nicht ganz mit meinem ursprünglichen Code überein. Ich bin zurzeit nicht an meinem Computer, habe ihn also nicht genau, aber er war ungefähr so:

l fzxd!m%xH

(Der einzige Teil, bei dem ich mir nicht sicher bin, ist der !m. Es wird geprüft, ob eine Variable Null ist.)

Pyke , 6 Bytes, Gebrochen

###X#s

Ausgabe:

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

Dies funktioniert nicht mit N <1

Ursprüngliche Lösung:

hSmX$s