Wie gut kennst du die Seite? Lass es uns herausfinden.

Dies ist eine Herausforderung für Bullen und Räuber . Räuberfaden.

Als Polizist müssen Sie:

1. Suchen Sie auf dieser Website nach einer nicht gelöschten, nicht geschlossenen Aufforderung, die beantwortet werden soll. Die Herausforderung kann nicht die folgenden Tags enthalten: Bullen und Räuber , Beliebtheitswettbewerb , Code-Trolling , hinterhältig , beschäftigt-Biber , König des Hügels , Tipps , Verkettung der Antworten . Die Challenge muss Einschränkungen bezüglich der gültigen Ausgabe haben.
2. Schreiben Sie eine gültige Einsendung für die Challenge in einer freien Sprache auf Wikipedia oder esolangs.org oder tryitonline . Die Einsendung muss nicht wettbewerbsfähig sein, sondern nur gültig. BEARBEITEN: Hashing in Ihrem Beitrag ist nicht erlaubt
3. Veröffentliche den Beitrag hier und halte die Herausforderung geheim. Sie müssen den gesamten Beitrag sowie die Sprache (und ggf. die Version) posten.

Wenn nach einer Woche niemand die von Ihnen beantwortete Frage gefunden hat, können Sie die Frage posten, auf die Ihre Eingabe antwortet. Zu diesem Zeitpunkt ist Ihre Eingabe sicher . Es ist N Punkte wert, wobei N die Anzahl der Upvotes für die Challenge ist (Stand: 17.11.2016 ) (Höher ist besser)

Um Ihre Herausforderung zu knacken, muss ein Räuber eine Herausforderung finden, für die die Vorlage eine gültige Vorlage ist.

Anmerkungen:

• Wenn eine Herausforderung eine Leistung von erfordert X, und Sie Ausgang XYoder YXwo Yist etwas anderes als Leerzeichen, ist die Vorlage für diese Herausforderung nicht gültig.
• Eine Herausforderung, die neuer als der 17.11.2016 ist, ist nicht zulässig.
• Sprachen, die neuer sind als die versteckte Herausforderung, sind erlaubt.
• Ich behalte mir das Recht vor, bestimmte Einwände zu verbieten, wenn sie allgemein anwendbar sind (könnte auf die Mehrheit aller Einwände angewendet werden).
• Vielen Dank an Daniel für die erste Idee!

Nicht geknackte Einsendungen:

<script>site = 'meta.codegolf'; postID = 5686; isAnswer = false; QUESTION_ID = 100357;</script><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

Pip , 9 Bytes ( sicher , 15 Punkte)

(q`\w+`1)

Was es tut, sollte leicht herauszufinden sein, aber die Frage ist, warum ... ( TIO )

Die Herausforderung war: Was ist die Sprache? Das Ziel: Analysieren Sie den Namen der Programmiersprache aus einem PPCG-Antwortheader. Zum Beispiel:

Input: <h1>JavaScript, 13 chars / 32 bytes</h1>
Desired Output: JavaScript

Ich bin nicht sicher, ob dies gegen "Die Herausforderung muss Einschränkungen für die gültige Ausgabe haben" verstößt, da es sich um eine Test-Batterie- Herausforderung handelt, die durch "Prozent der Tests, die Sie korrekt durchführen" bewertet wird , und daher keine korrekte Ausgabe erforderlich ist für alle eingaben. Ich werde jedoch sagen, dass der obige Code ungefähr 60% der korrekten Rate erhält, was für etwas so Einfaches nicht schlecht ist.

Perl - Gebrochen von DLosc

Lassen Sie uns ein einfaches für die Nicht-Esolang-Leute geben

Laufen Sie mit -nl

say $_ ~~ reverse y-"({[]})"-")}][{("-r;;r-")}][{("-"({[]})"-y esrever ~~ _$ yas

Herausforderung: Praktischer Palindrome Checker

Der Code stürzt nach dem Drucken der Wahrheit ab, aber laut diesem Meta-Beitrag ist es eine gültige Lösung , solange die korrekte Ausgabe vor dem Absturz erfolgt und alle Fehler an STDERR ausgegeben werden.

Hexagony , 548 Bytes, Gebrochen

69;{108;\_1$;;;/0;108\56;19|1^\6/15\;72_$23371<};;!;6;33|;;015><;;7;@3?;43+1586;2_3219><11;;'_8;;;2_|3;81|2<|8517;327}1_23;1;4$%;_4{5.1;1332_3;029&;'_};;1..527;2'..35;5212_>97;$;2/0;-;3_2;/233;08.._\901;0/13'}92...>/>/57\53;633;4'22;/|~>;441;45;;$161;371;3/;3.7026;`208;1<}>27;140;217;11.0;/2;692;<01/2;301;18;31/;10;/3;44<1914/111;{98;38;;;13/4;<;3;1;;/;112;<.$13032;..27;1;222/1;0<6..1;0;'..933721389/9<6;.;3;37..;;875;*;;0[1;287]59..902;;2;12;1;59;;3#..4;;1=249$345249;...;012}021#>/;44>114/4201;;;3>0;>;24;3/;;116._4>337;237/$5_>1{32;102;255;'_

Probieren Sie es online!

Perl, sicher , 18 Punkte

Bearbeiten : Ich habe das Ende des Codes geändert (siehe Bearbeitungsverlauf), um einen Randfall zu behandeln (die Abfrage sagt nichts darüber aus, und der Autor hat nicht geantwortet, als er danach gefragt wurde, aber dieser Code behandelt es zumindest). . Der Algorithmus und die Logik des Codes bleiben jedoch gleich.

perl -n0E '/.*/;s/(^0|A)(.{@{+}})?0/A$2A/s||s/0(.{@{+}})?A/A$1A/s?redo:say/A$/+0'

Dieser Code ist nicht verschleiert (nur Golf). (Dies bedeutet, dass dies -n0Enicht optional ist.)

Ich weiß nicht, ob das schwierig ist oder nicht, aber ich denke, ich werde repariert, wenn jemand es knackt.

Die Herausforderung war Kann Labyrinth gelöst werden? .

Dieser Code findet jede erreichbare Zelle des Labyrinths (und markiert sie mit einem A): Wenn eine Zelle eine mit einem markierte Zelle berührt A, ist sie erreichbar und wir markieren sie mit einem Aebenfalls; und das machen wir nochmal ( redo). Dies geschieht dank zweier regulärer Ausdrücke: s/(^0|A)(.{@{+}})?0/A$2A/sÜberprüft, ob sich ein Leerzeichen rechts oder unten von einem befindet A, während s/0(.{@{+}})?A/A$1A/süberprüft wird, ob sich ein Leerzeichen links oder oben von einem befindet A. Am Ende enthält , wenn die letzte Zelle , die einen Aes ist erreichbar, ansonsten ist es nicht (das ist , was say/A$/+0überprüft, der +0hier ist , um sicherzustellen , dass das Ergebnis wird sein , 0oder 1statt leeren String und 1).
Beachten Sie, dass dies /.*/mit einer gesamten Zeile übereinstimmt und somit einstellt@+zum Index des Endes der ersten Zeile, der zufällig die Größe einer Zeile hat, mit der .{@{+}}genau so viele Zeichen gefunden werden können, wie in einer Zeile enthalten sind. ( @{+}entspricht, @+kann aber nur in regulären Ausdrücken verwendet werden)

Um es auszuführen:

$ perl -n0E '/.*/;s/(^0|A)(.{@{+}})?0/A$2A/s||s/0(.{@{+}})?A/A$1A/s?redo:say 1-/0$/' <<< "0000001
0000010
1111011
0000000"
1

(und wenn Sie die 1111011Zeile durch ersetzen 1111111, ist sie nicht mehr lösbar und die Ausgabe erfolgt 0stattdessen 1)

Perl, 56 Bytes, Sicher (14 Punkte)

undef$/;print+(<>^<>)=~y/\x81-\xff\x00-\x80/\x01-\xff/dr

Die Herausforderung war dies ein , die Sie auffordert , einen diffing Algorithmus zu schaffen; Sie müssen in der Lage sein, zwei Dateien einzugeben und ein Diff auszugeben, oder eine Datei und ein Diff einzugeben und die andere Datei auszugeben. Das Ergebnis dieser Herausforderung ist eine Code-Herausforderung , bei der der kleinste Unterschied zum Gewinner wird. Für diese Herausforderung ist es jedoch nicht erforderlich, dass die Antwort konkurrenzfähig ist, sondern einfach der Spezifikation entspricht. Deshalb habe ich stattdessen ein anderes Programm auf spielerische Weise geschrieben, bei dem die Eingaben einfach durch XOR kombiniert werden (dh, dasselbe Programm funktioniert für diffing und nicht abweichend).

Am schwierigsten ist es, die Länge der Originaldateien zu reproduzieren. Die Eingabe wird als ASCII-Zeichen angegeben. Dies ist ein 7-Bit-Zeichensatz, sodass ich das achte Bit verwenden kann, um die Länge der Datei zu verfolgen. Wenn wir differenzieren, setzen wir das High-Bit jedes Bytes mithilfe eines y///Befehls (der etwas mehr verschleiert ist als eine bitweise Arithmetik). Wenn die Differenzierung aufgehoben wird (dies wird dadurch erkannt, dass für den Eingang bereits das hohe Bit gesetzt ist), werden NULs aus dem Ausgang entfernt. (Ich habe gerade festgestellt, dass dies fehlschlagen würde, wenn die Eingabe NUL-Bytes enthalten würde. Die Herausforderung wird jedoch in Form einer Testbatterie definiert, und zum Glück glaube ich nicht, dass die Batterie NUL-Bytes enthält. Wenn ja, dann Dieses Programm wäre falsch und müsste disqualifiziert werden - ein Problem mit Bullen und Räubern ist, dass niemand sonst genug Informationen hat, um auf leicht zu behebende Fehler in Ihrer Antwort hinzuweisen!)

Oktave, 15 Punkte! SICHER

@(x,y)find((v=((z=cumsum(x.^2))(y:end)-[0,z(1:end-y)]))==max(v),1)-1

Probieren Sie es hier online aus .

Erläuterung:

Der Code akzeptiert eine Eingabezeichenfolge xmit Einsen und Nullen 10010110110101sowie eine Ganzzahl y.

So ermitteln Sie den gleitenden Durchschnitt einer Sequenz in MATLAB / Octave:

z = cumsum(x);
movmean = z(y:end) - [0 z(1:end-y)];

Da wir nur am Ort des Maximums interessiert sind, nicht an den tatsächlichen Werten, müssen wir uns nicht darum kümmern, den String in Zahlen umzuwandeln. (x.^2)quadriert alle ASCII-Werte 48,49für 0,1. Dies ist notwendig, da Octave keine cumsumdirekten Zeichen verwenden kann. cumsum(+x)wäre zwei Bytes kürzer, würde aber offenbaren, dass dies xeine Zeichenfolge ist.

Das ist eigentlich ganz gut golfen (bis auf die .^2statt +). Natürlich wäre die Faltung einfacher.

MATL . Geknackt

&:"@FYAYm7>vs

Probieren Sie es online!

Ich habe Input und Output angegeben, auch wenn es nicht notwendig ist. Da es sowieso in der Bearbeitungshistorie ist: Das Programm gibt zwei Zahlen ein und gibt eine Zahl aus.

C #, 590 Bytes, Gebrochen

(I,N)=>{string R="",p="`1234567890-=",P="~!@#$%^&*()_+",q="qwertyuiop[]\\",Q="QWERTYUIOP{}|",a="asdfghjkl;\'",A="ASDFGHJKL:\"",z="zxcvbnm,./",Z="ZXCVBNM<>?";foreach(var c in I){var f=c+"";if(p.Contains(f))R+=p[(p.IndexOf(c)+N)%13];else if(P.Contains(f))R+=P[(P.IndexOf(c)+N)%13];else if(q.Contains(f))R+=q[(q.IndexOf(c)+N)%13];else if(Q.Contains(f))R+=Q[(Q.IndexOf(c)+N)%13];else if(a.Contains(f))R+=a[(a.IndexOf(c)+N)%11];else if(A.Contains(f))R+=A[(A.IndexOf(c)+N)%11];else if(z.Contains(f))R+=z[(z.IndexOf(c)+N)%10];else if(Z.Contains(f))R+=Z[(Z.IndexOf(c)+N)%10];else R+=c;}return R;};

Wahrscheinlich ziemlich einfach, auch ein ziemlich langes Programm, _,

05AB1E , 27 Bytes, geknackt!

Für diese Übermittlung ist auch eine Eingabe erforderlich, damit sie funktioniert. Sollte nicht zu schwer zu knacken sein.

ávyl•B;£¡´•54B•2ît•‡y.li(}O

Erklärung (für die Herausforderung):

á                             # Keep all the letters of the input string
 vy                           # For each letter...
   l                          #   Convert to lowercase
    •B;£¡´•54B                #   String that turns into 'pnbrqk'
              •2ît•           #   Compressed int: 133591
                   ‡          #   Transliterates the following:
                                    p -> 1
                                    n -> 3
                                    b -> 3
                                    r -> 5
                                    q -> 9
                                    k -> 1
                    y.li }    #   If the current letter is lowercase...
                        (     #     Negate that number
                          O   # Sum up the result

Verwendet die CP-1252- Codierung. Probieren Sie es online!

아희 (Aheui) , 0 Bytes, Gebrochen

Probieren Sie es hier aus! (Das Programm ist bereits für Sie eingetippt: p)

Python, 935 Bytes

def oo000 ( num ) :
 return - ~ num
def ii ( num ) :
 return - ( oo000 ( oo000 ( ~ num ) ) )
def oOOo ( num1 , num2 ) :
 while num2 > 0 :
  num1 = oo000 ( num1 )
  num2 = ii ( num2 )
 return num1
 if 59 - 59: Oo0Ooo . OO0OO0O0O0 * iiiIIii1IIi . iII111iiiii11 % I1IiiI
def IIi1IiiiI1Ii ( num1 , num2 ) :
 I11i11Ii = num2
 oO00oOo = 0
 while I11i11Ii > 0 :
  oO00oOo = oOOo ( oO00oOo , num1 )
  I11i11Ii = ii ( I11i11Ii )
  if 92 - 92: O0O / oo000i1iIi11iIIi1 % Iii1IIIiiI + iI - Oo / o0O
 return oO00oOo
def hgj ( num1 , num2 ) :
 I11i11Ii = num2
 oO00oOo = 1
 while I11i11Ii > 0 :
  oO00oOo = IIi1IiiiI1Ii ( oO00oOo , num1 )
  I11i11Ii = ii ( I11i11Ii )
  if 48 - 48: iII111i % IiII + I1Ii111 / ooOoO0o * o00O0oo
 return oO00oOo
def O0oOO0o0 ( num1 , num2 ) :
 return oOOo ( num1 , - num2 )
 if 9 - 9: o0o - OOO0o0o
 if 40 - 40: II / oo00 * Iii1IIIiiI * o0o . ooOoO0o
print(hgj ( 9 , 9999 ))
# dd678faae9ac167bc83abf78e5cb2f3f0688d3a3

Tut mir leid, ich habe einen Verschleierer benutzt, aber es ist nicht verboten und viel einfacher. (Und ich hatte nicht die ganze Zeit, es selbst zu tun ...)

Ruby ( geknackt von DLosc )

p n = gets.to_i
p n = n*(3*n-1)/2 until n % 7 == 0

MATL . Sicher , 93 Punkte

dP7EGn:q^1J2/h)ts_hX=Gs[BE]Wd=~>~GBz*

Probieren Sie es online!

Erläuterung

Die Herausforderung war der ökologische Fußabdruck des Quellcodes .

Der Code berechnet das Hamming-Gewicht (Anzahl der Einsen) in der binären Darstellung der ASCII-Codes der Eingabezeichenfolge. mit der Ausnahme, dass die Zeichenfolge testausgegeben wird 0(anstelle der Hamming-Gewichtung 17).

Die spezielle Hülle dieser Saite ist etwas verschleiert. Das Programm berechnet zuerst das Array aufeinanderfolgender Unterschiede der ASCII-Codes der Eingabe und kehrt es um. Dafür testgibt es [1 14 -15].

Dann wird das durch die ersten nPotenzen von gebildete Array 14berechnet ( [1 14 196 ...]), wobei ndie Eingangslänge ist; und die ersten floor(n/2)Werte bleiben erhalten. Also für die Eingabe testgibt dies [1 14]. Die negierte Summe wird an dieses Array angehängt, das [1 14 -15]zur Eingabe dient test. Dies wird auf Gleichheit mit dem zuvor erhaltenen umgekehrten Array aufeinanderfolgender Differenzen getestet.

Andererseits wird die Summe der ASCII-Codes der eingegebenen Zeichen berechnet und verglichen 448und als (aufeinanderfolgende) Differenz der Elemente im Array [2^6 2^9](wobei ^Leistung bezeichnet wird) erzeugt.

Die Eingabe testist die einzige Zeichenfolge mit umgekehrten aufeinanderfolgenden Differenzen von Form [1 14 -15]und Summe 448. Differenzen []oder [1](für kürzere Inoyt-Strings) sind nicht kompatibel mit einer Gesamtsumme von 448. Unterschiede [1 14 196]oder größer können mit ASCII-Zeichen nicht erreicht werden.

Der Code prüft, ob das Ergebnis des Tests für die erste Bedingung (aufeinanderfolgende Differenzen) nicht kleiner ist als das negierte Ergebnis der zweiten Bedingung (Gesamtsumme). Dies ist 0genau dann der Fall, wenn beide Bedingungen erfüllt waren. Schließlich wird dies mit der Anzahl der Einsen in der binären Darstellung der ASCII-Codes des Eingangs multipliziert.

CJam ( sicher , 21 Punkte)

{W+W%~1{1$)}{)a1${\(+W%{1$1$-2=>}{+}w}{\;}?)_@*\+~}w+}

Dies ist ein anonymer Block (Funktion).

Python 3, ~ 2000 Bytes (sicher: 23 Punkte)

Ursprüngliches Programm

exec("\n))o0000o000o<)]))]00000o000o[0o0o0o0o0o0o0o0o0o(00000000000000o0o(000000000000000o0o ni oooo0oooo rof)))0o0o0o0o0o0o0o0o0o(00000000000000o0o(000000000000000o0o ni 00oo00oo00oo00oo00oo rof]oooo0oooo[]00oo00oo00oo00oo00oo[0o0o0o0o0o0o0o0o0o(000ooo000ooo000o[ +]0o0o0o0o0o0o0o0o0o ni 00oo00oo00oo00oo00oo rof)00oo00oo00oo00oo00oo(000ooo000ooo000o[ni ooo000ooo000o rof)ooo000ooo000o(o0o0o0o0o-o0000o000o(000ooo000ooo000o(00o00o00o(tnirp\n)00000o000o,00000o000o(tresni.o0o0o0o0o0o0o0o0o0o:))00000000000000o0o=yek,0o0o0o0o0o0o0o0o0o(xam(00000000000000o0o<)o0o0o0o0o0o0o0o0o0o(00000000000000o0o elihw \n:)]00000o000o[]o0oooo,0o0o0o0o0o0o0o0o0o[( ni o0o0o0o0o0o0o0o0o0o rof\n;'=01NgwiNgwSNbBibpBybw8GMwAzbw8GM'b,]0o0o0o0o00oo ni ooooo0o00oo rof]]::0oooooo0oooo[))ooooo0o00oo(0oooooo(o0oooo ni ooo000ooo000o rof)ooo000ooo000o(00o00o00o[[=ooooo00oo,0o0o0o0o0o0o0o0o0o\n)'=kSZsBXd0BCLn5WayR3cgwCdulGK'b(0o0o.)(0o0ooo0o00ooo.o000oo esle o0000o000o fi o0000o000o+o0000o000o=0oooooo0oooo;)000000000000000o0o(o00oo00o=000000000000000o0o;)))(edoced.)o0o(0oo000o(000000o(o000oo,))(]o0000o000o[]edoced.)'==QbhRHa'b(0oo000o,'oo0o0o00o'[(oo0o0oo=o0o0o0o0o,oo0o0o0oo\n;)00000000000000o0o(o00oo00o,))(edoced.)'vJHZ'b(0oo000o(o00oo00o,)'bin'(o00oo00o=00000000000000o0o,0oooooo,o0oooo;))0000o0o0o(000000o(o000oo:0000o0o0o adbmal = o00oo00o ;)))(0o0oo00o(0oooooo(0o0oo0oo=0o0o0o0o00oo\n00000000000001**o0000o000o=o0000o000o;))(edoced.)'=cSbhRHanwCd1BnbpxyXfRncvBXbp91Xs4WavpmLnAyJ'b(0oo000o(o000oo=o0oo0oo00o,0o0oo00o,o0oo0oo,0o0oo0oo;edoced46b.)000oo0o(oo0o0oo=0oo000o\n;'==QYsxGKb92bwADMvVCN8EDIm9mcg8GMvBSauBybw82bwADMvBzbdliKq4SN'b ,))0o0oo00oo(000000o(__tropmi__ :0o0oo00oo adbmal,'base64',]0o0oo00oo[:0o0oo00oo adbmal = oo00oo00oo00oo00oo00oo,oo0o0oo,000oo0o,0oooooo\n;tni,'range','len','==Abh1mYkFGIv9GMwAzb682bwADMvBSYuRGIv9GMvBzbw82buYWYjR3bylWYshybvBDMw8WLxkiKqITJv9GMwAzb'b,lave,0**0000000000000009,0 ,]1-::[0o0ooo0o00o0oo:0o0ooo0o00o0oo adbmal,mus = 00o00o00o,000000000000000o0o,00000000000000o0o,o0o,o000oo,o0000o000o,00000o000o,000000o,000ooo000ooo000o\n"[::-1])

Herausforderung

Dies ist in der Tat eine Antwort auf meine eigene Herausforderung, Primenary Strings . Ich habe dies gewählt, da fast alles ausgegeben wird 0, abgesehen von ein paar Eingaben, die ein Räuber wahrscheinlich nicht eingeben würde. Der Code ist ein einfacher Algorithmus, der jedoch (von Hand) stark verschleiert ist.

Pip , 13 Bytes

V$.C(A*a-A9)a

Probieren Sie es online aus (geben Sie Input als Argumente ein, nicht Input).

JavaScript, 533 Bytes, Gebrochen! von Dave

_=this;[490837,358155,390922].map(y=function(M,i){return _[[
U=[y+[]][+[]]][+[]][i]]=_[M.toString(2<<2<<2)]});function g(
s){return Function("a","b","c","return "+s)};e=g(u(["","GQ9\
ZygiYTwyPzE6YSpk","C0tYSki","SkoYSkvZChhLWIpL2QoYikg"].join(
"K")));h=g("A=a,B=b,g('A(a,B(a))')");j=g("a/b");L=g("Z=a,Y=\
b,g('Z(a,Y)')");k=L(j,T=2);F=g(u("KScpKWIsYShFLCliLGEoQyhEJ\
yhnLGM9RSxiPUQsYT1D").split("").reverse().join(""));RESULT=F
(h(e,k),j,g("_[U[10]+[![]+[]][+[]][++[+[]][+[]]]+[!+[]+[]][\
+[]][+[]]+17..toString(2<<2<<2)].pow(T,a)"));

Nicht meine Lieblingsverschleierung von mir, aber es ist ein bisschen ordentlich. Anrufen als RESULT(inputs).

Ich kann eine Prämie von +50 Punkten gewähren, wenn Sie im Detail erklären, was mein Code zusammen mit Ihrem Riss tut. (Sie müssen nicht zusammen sein, also wenden Sie sich an FGITW, wenn dies Ihren Wünschen entspricht.)

Pyke, 3458 Bytes, SAFE , 99 Punkte

wB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddnwB"["R";7m"ddddddddddddddddddddddddddwE"["R";7m"ddddddddddddddddddddddddddw?"["R";7m"ddddddddddddddddddddddddddsQI30>Q%)

Probieren Sie es hier aus!

Es gibt einige (30) 0x1bBytes, die anscheinend von SE gefressen wurden.

Oktave, 40 Punkte. SICHER

Etwas verschleierte Antwort auf eine ziemlich beliebte Herausforderung.

y=find((x=mod(input('')*2,32))>12);sign(sum(x.*[1-y:nnz(x+8)-y]))

Ich empfehle dies auf Octave-Online zu testen . Ideone ist nicht so gut, wenn es um STDIN geht.

Dies war die Hebel Simulator 2015 Herausforderung. Eingabe im Formular '123^32. Die Ausgabe erfolgt -1 0 1für Left-Heavy, Balanced und Right-Heavy in dieser Reihenfolge.

Es sieht so aus, wenn es voll bespielt ist :

s=mod(input(''),16);i=find(s>9);s*[1-i:numel(s)-i]'*inf

Dies wird jeweils -Inf, NaN, Inffür L, B, R ausgegeben.

Haskell, sicher

m f=map(f<$>)
g=reverse.("":)
f s|(f:c:s)<-m fromEnum.g.words$s,
    (f:c:s)<-init.unwords.g.m(\s->toEnum$if c!!0==s||s==sum(-32:c)then(last$f)else s)$s=init$s

Probieren Sie es auf Ideone . "Verwendungszweck":

Prelude> f "Programming Puzzles & Code Golf"
"rogramming Puzzles "

In der String Shenanigans Challenge erhält man einen String und zwei Zeichen und sollte dann jedes Vorkommen des ersten Zeichens durch das zweite ersetzen. Die Eingabe besteht jedoch nur aus einer Zeichenfolge, die die eigentliche Zeichenfolge in Anführungszeichen und die zwei durch Leerzeichen getrennten Zeichen enthält:

Prelude> f "\"Hello, World!\" l r"
"Herro, Worrd!"

TeX, 240 Bytes, SAFE , Punktzahl 129

\let\N\newcount\let\I\ifnum\let\A\advance\let\E\else\N\a\N\b\N\c\def\D#1:#2:#3:{\I#1>#2\A#1by-#2\D#1:#2:#3:\E\I#1=#2 #3=1\E#3=0\fi\fi}\def\P#1:#2:{\I#1>#2\a=#1\D\a:#2:\c:\I\c=0\b=#2\A\b by1\P#1:\the\b:\E N\fi\E\I#1=1 N\E Y\fi\fi}\P1:2:\end

Speichern unter jeopardy.tex, dann ausführen pdftex jeopardy.texund öffnen jeopardy.pdf.

Ergebnis: ein PDF mit dem Text N(und der Seitenzahl 1).

Python 3, geknackt!

Das zu schreiben war lustig, obwohl es am Ende leicht zu knacken war :)

Z,O=__import__('time').strftime,401*5;from base64 import*;Q,I=(Z('%Y')),(O/401)*2;_=int(Q);D,P=(O,-~_),int(Q[~1:]);Q,I=(6+(P-eval(b64decode(b'KHN1bShbeCU0PDEgZm9yIHggaW4gcmFuZ2UobWluKEQpLG1heChEKSldKSk=').decode()+'*-1'*(O>_)))/10,'3'+repr(((P-10)*3)+10));print(Q,I)

Pyth - von Maltysen geknackt

Wenn es hilft, war Pyth keine der Antworten auf die versteckte Herausforderung.

u=.+G.*A

Versuch es!

C #, 91 Bytes

_=>{int b=0,w=0;for(;1>w||0<*(_-1);b+=++w**_++<<(9*w));return b%(3<w?903302656:41458688);};

Mathematica, 161 Bytes

Which[LetterQ@#,If[UpperCaseQ@#,ToUpperCase,#&][FromLetterNumber~Array~LetterNumber@#],DigitQ@#,Array[IntegerString,FromDigits@#+1,0],True,#]&/@Characters@#<>""&

BrainFuck - 140 Bytes, Cracked von daHugLenny

,>,>,>-[>+<-----]>---[<+>-]<[<<<->>>->+<]>[<<<->>>->+<]>[<<<->>>-]<<<[>+<-]<[>>++++++++++<<-]<[>>>>++++++++++[<++++++++++>-]<<<<-]>>>[>.+<-]

Probieren Sie es hier aus!

C ++ 14, geknackt

#include<vector>

auto h(auto i){return 0;}
auto h(auto i, auto x, auto...p){
 return x+(i-1?h(i-1,p...):0);
}

auto g(auto v){return v;}
auto g(auto v,auto x, auto...p){
 v.push_back(h(x,x,p...));
 return g(v,p...);
}

auto f(auto...p){
 return g(std::vector<int>{},p...);
}

Nimmt eine unterschiedliche Anzahl von Parametern und gibt a zurück vector<int>.

Verwendungszweck:

int main() {
 auto v = f(4,7,3,4,5);
 for (auto i:v) std::cout << i << ", ";
 std::cout << std::endl;
}

Mathematica, 34 Bytes, Gebrochen

±1={±0={}};±n_:=Array[±#&,n,0]

Benannte Funktion ( ±).

Ruby, 50 Bytes

count = 0; 400.times do count +=1; end; puts count

Ausgabe: 400

Python 2.7, 45 Bytes

import numpy;lambda a,n,t:numpy.arange(a,t,n)

Hinweis (oder vielleicht auch nicht): "Der Fisch benutzt Numpy."

23.11.2016 - Zweiter Tipp: "Lass nichts herumschweben !"