Bedeutendes Leerzeichen: Cops

51

Für diese Herausforderung definieren wir Leerzeichen als nur Zeilenvorschübe (0x0A) und Leerzeichen (0x20). Beachten Sie, dass die meisten Sprachen und Regex-Varianten auch viele andere Zeichen als Leerzeichen betrachten, sowohl innerhalb als auch außerhalb des ASCII-Bereichs, sodass Sie möglicherweise nicht in der Lage sind, die entsprechenden integrierten Funktionen zu verwenden.

Die Herausforderung der Polizei

Sie sollten ein Programm oder eine Funktion in einer Sprache Ihrer Wahl schreiben, die eine Zeichenfolge aus ASCII-Zeichen (außer NUL-Zeichen) als Eingabe und Ausgabe verwendet, wobei alle Leerzeichen entfernt werden. Zum Beispiel, wenn Sie die folgende Eingabe erhalten haben:

H e l l o,
 W o r l  d!

Sie sollten ausgeben

Hello,World!

Ihre Übermittlung ist dann Ihr Quellcode, wobei alle Leerzeichen entfernt werden (der gleiche Vorgang wie das Übergeben Ihrer Lösung als Eingabe an sich selbst, obwohl Ihre Lösung auch Zeichen außerhalb des ASCII-Bereichs enthalten kann). Ihr Ziel ist es, es so schwierig wie möglich zu machen, herauszufinden, wo Leerzeichen eingefügt werden müssen, um eine gültige Lösung in der Sprache Ihrer Wahl zu finden. Beachten Sie, dass Räuber möglicherweise weniger Leerzeichen einfügen, als Sie entfernt haben, jedoch nicht mehr. Denken Sie auch daran, dass Räuber nicht unbedingt Ihren genauen Code angeben müssen, sondern lediglich eine gültige Lösung finden müssen.

Ihre Antwort sollte Folgendes enthalten:

  • Die Sprache (und ggf. die Version), in der Sie Ihre Lösung geschrieben haben.
  • Die Byteanzahl Ihrer Lösung, bevor Leerzeichen entfernt werden.
  • Ihre Lösung mit Leerzeichen entfernt.

Ihre Lösung kann entweder ein Programm oder eine Funktion sein, aber kein Snippet, und Sie dürfen keine REPL-Umgebung annehmen. Sie können Eingaben über STDIN, Befehlszeilenargument oder Funktionsargument und Ausgaben über STDOUT, Funktionsrückgabewert oder Funktionsparameter (out) vornehmen.

Im Interesse der Fairness muss es einen frei verfügbaren Dolmetscher oder Compiler für die von Ihnen gewählte Sprache geben.

Sie dürfen keine integrierten Funktionen zum Hashing, zur Verschlüsselung oder zur Generierung von Zufallszahlen verwenden (auch wenn Sie den Zufallszahlengenerator auf einen festen Wert setzen). Ihre Lösung muss in der Lage sein, Zeichenfolgen mit maximal 100 Zeichen in weniger als 10 Sekunden auf einem vernünftigen Desktop-Computer zu verarbeiten.

Wenn Ihre Antwort nicht innerhalb von 7 Tagen (168 Stunden) geknackt wurde, können Sie Ihre eigene Lösung aufzeigen, zu welchem ​​Zeitpunkt Ihre Antwort als sicher eingestuft wird . Solange Sie Ihre Lösung nicht preisgeben, kann sie auch dann von Räubern geknackt werden, wenn die sieben Tage bereits verstrichen sind. Die kürzeste sichere Antwort gewinnt (gemessen vor dem Entfernen von Leerzeichen).

Wenn Ihre Antwort geknackt wird, geben Sie dies bitte in der Kopfzeile Ihrer Antwort zusammen mit einem Link zur Antwort des entsprechenden Räubers an.

Gehen Sie hier für die Räuber.

Uncracked Submissions

<script>site = 'meta.codegolf'; postID = 5686; isAnswer = false; QUESTION_ID = 103182;</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>

Martin Ender
quelle
Verbunden. (Inspiration, in der Tat.)
Martin Ender
7
Scheint, als würde Whitespace diese Herausforderung brechen ...
NoOneIsHere
8
@SeeOneRhino Warum? Der Räuber muss nur das Problem in Whitespace lösen und verwendet nicht mehr Bytes als der Cop. Wenn ein Cop keine verrückte, gut golfene Whitespace-Antwort findet, mit der niemand mithalten kann, sind Whitespace-Antworten bei dieser Herausforderung im Allgemeinen am anfälligsten.
Martin Ender
1
@SeeOneRhino Tabs werden auch nicht als Leerzeichen gezählt, sodass sie nicht entfernt werden.
mbomb007
4
Ich denke, diesmal gibt es keine Hexagony-Einreichungen
MildlyMilquetoast

Antworten:

17

Haskell, 100 Bytes, geknackt von Nimi

main=interact$iddoidlinesidwordsdoidoidoid=doiddoid<-dooiidoid<-dooiddoiddodoid

Dies ist ein volles Programm und ein dadaistisches Gedicht.


Code mit withspace (Online ausprobieren !)

main=interact$id doid lines id words
doid oi d o id=do
 iddoid<-do oi id
 oid<-do o iddoid
 do d oid

Sieht immer noch ziemlich poetisch aus, wenn Sie mich fragen.

Enttarnt

main = interact f
f s = do
 l <- lines s
 w <- words l
 id w

Erläuterung

Die do-Notation ist nur syntaktischer Zucker, fkann also gleichbedeutend als geschrieben werden

f s = lines s >>= words >>= id

Für Listen ist der >>=-operator definiert als concatMap, so fwird

f = concat . map id . concat . map words . lines

Wenn Sie also eine Eingabe machen "a b\nc", linesteilen Sie die Eingabe in Zeilenumbrüche ["a b","c"]und teilen Sie wordsjede Zeile in Leerzeichen auf [["a","b"],["c"]](wie mir erst jetzt klar wurde, enthält diese Eingabe Zeilenumbrüche, wird also lineseigentlich nicht benötigt). Verketten gibt einmal ["a","b","c"], idist die Identitätsfunktion und als solche keine Auswirkungen haben und die endgültige Verkettung ergibt die Zeichenfolge "abc".

Laikoni
quelle
3
Muss ich sagen , dass Ich mag dada ministische Gedichte?
Dada
@nimi ja, gut gemacht.
Laikoni
12

C, 475 Bytes, geknackt von Riley

Bestimmte Teile von C machen es wirklich sehr einfach zu sehen, wohin Whitespace gehen soll. Der c-Preprozessor tut dies jedoch nicht. Dieser Code besteht also aus zwei Teilen: Bis zur Zeile 17 (236 Zeichen mit Leerzeichen) ist der Code praktisch nicht verschleiert, und danach (239 Zeichen mit Leerzeichen) viel Glück!

Ich werde diesen Wettbewerb bei weitem nicht gewinnen, aber ich wollte sehen, was mit dem c-Preprozessor alles möglich ist.

#include<unistd.h>#defineachar#defineb*#definecwrite#definedstdin#defineestdout#definefread#defineg(#defineh)#defineiwhile#definejif#definek0#definel&#definem,#definen=#defineo;#definep1#definegpmlmlh#defineabo#definemldmp#definejgdoabo#definelbabod#definegfhaboc#definejgmben#definepmlfg#definegpmlbintmain(){ajgajgmljgigpmlkmlgpmlhjgd!=''&&gpm!='\n'gfgpmlgpmlo}

Kompiliert (mit Warnungen, wenn Sie sie aktivieren) mit gcc -std=c89 -ansiund funktioniert wiecat file | ./a.out


Dies wurde viel schneller geknackt als ich dachte, Glückwunsch! Meine Strategie bestand darin #defines, offensichtliche Token-Grenzen (wie ';') zu entfernen und dann mehr #defineszu verwenden, um es WIRKLICH unintuitiv zu machen, wie sie herumgemischt wurden.

Übrigens sieht der Code so aus, nachdem nur das offensichtliche Leerzeichen hinzugefügt wurde:

#include <unistd.h>
#define a char
#define b *
#define c write
#define d stdin
#define e stdout
#define f read
#define g (
#define h )
#define i while
#define j if
#define k 0
#define l &
#define m ,
#define n =
#define o ;
#define p 1
// thus begins the obfuscation
#define gpmlmlh
#define abo
#define mldmp
#define jgdoabo
#define lbabod
#define gfhaboc
#define jgmben
#define pmlfg
#define gpmlb
int main(){
    ajgajgmljgigpmlkmlgpmlhjgd!=''&&gpm!='\n'gfgpmlgpmlo
}
rexroni
quelle
5
Willkommen bei PPCG! :)
Martin Ender
1
Cracked Das macht so richtig Spaß.
Riley
9

Oktave, 69 Bytes, SICHER!

@(U)eval([85329685312682956148388531268295156241''])

Eingabeformat: Zeilenumbrüche können nicht direkt in die Eingabeaufforderung eingegeben werden. Erstellen Sie die Zeichenfolge durch Verketten wie folgt:

str = ['This is ',10,'a',10,'string']
str = This is
a
string

Rufen Sie die Funktion wie folgt auf (fügen Sie Leerzeichen hinzu):

f=@(U)eval([85329685312682956148388531268295156241''])  
f(['This is ',10,'a',10,'string'])

Originalcode:

Sie brauchten dafür nur 66 Bytes, aber ich habe 69 in den Header geschrieben, um nicht zu viele Informationen preiszugeben.

Der ursprüngliche Code sieht folgendermaßen aus:

@(U)eval([853 296 853 126 829 561 48 38 853 126 829 51 562 41 ''])

Erläuterung:

@(U)eval(.....)    % Anonymous function taking U as the input variable

Uist ein Codepunkt 85in der ASCII-Tabelle, sodass es so aussieht, als ob das erste Leerzeichen dahinter stehen sollte 85. Falsch!

Wenn wir 853stattdessen das Leerzeichen nach einfügen , sollten wir die Zeichennummer erhalten 853, richtig ..? Verwenden Sie char, um zu überprüfen, ob das ein erkennbares Zeichen ist:

char(853)
warning: range error for conversion to character value

Wir verwenden jedoch nicht charden Code, sondern die kürzere Version, in der wir die Zahlen mit einer leeren Zeichenfolge verketten [853 '']. Anstatt einen Fehler außerhalb des Bereichs anzugeben, verwendet die kürzere Version einfach den Zahlenmodul 256.

Es ist einfach so 85+3*256 = 853. Während char(853)eine Warnung gibt, [853,'']kehrt zurück U.

Der naheliegende Weg, um diese Aufgabe in Octave zu erledigen, ist:

@(U)U(U~=10&U~=32)

Wir wissen, dass es nach dem ersten eine öffnende Klammer (Code-Punkt 40) geben muss U. 29Offensichtlich passt das nicht, also verschieben wir den Raum ein Stück weiter nach rechts und kommen an 296. mod(296,256) = 40. Bingo!

Fahren Sie wie folgt fort und beenden Sie die Sequenz:

[853 296 853 126 829 561 48 38 853 126 829 51 562 41 '']
ans = U(U~=10&U~=32)

Schließlich verwenden wir eval, um den String in Code umzuwandeln.

Stewie Griffin
quelle
3
+1 für die Erklärung des Eingabeformats in 2 Zeilen, während ich 10 :-D
Luis Mendo
1
Nun, immer noch keine Ahnung, außer dass ich jetzt Buchstaben Uunter diesen Zahlen wiedererkenne :-)
Luis Mendo
2
Sehr guter Trick! Es ist verrückt, dass Octave das mit Zeichencodes macht. Ich hatte keine Ahnung davon. Aber was können Sie dann erwarten, wenn der offizielle Doc sagt, dass Octave Unicode aus Versehen unterstützt ... :-P
Luis Mendo
7

JavaScript ES6, 199 Bytes, geknackt von SLuck49

Ein ziemlich sperriger Eintrag mit 33 Bytes Leerzeichen.

s=>eval(atob`ISYgJiAtOkI8Qk97BRBeaxZFShoUZSsiOGkMenNy`.replace(/./g,(c,i)=>String.fromCharCode(c.charCodeAt()^(k+="SecretCode".split(/\w/)[i%11].length)),k=0)).join``
Arnauld
quelle
Nizza .. Ich denke, wir müssen die richtige Menge an Leerzeichen zu "SecretCode" hinzufügen, um die verschlüsselte Zeichenfolge xor und die richtige Quelle zu erhalten ~
Patrick Roberts
@PatrickRoberts Ja, genau.
Arnauld
Ich habe schon ein automatisiertes Skript alle möglichen Kombinationen zu testen, es ist nur eine Frage der Zeit ... wringt die Hände zusammen, seinen bösen Plan zu wissen , arbeitet
Patrick Roberts
Puh ... das dauert länger als ich dachte. Ich denke darüber nach, eine Code-Golf-Challenge zu schreiben, um die Anzahl der möglichen Permutationen zu berechnen, vorausgesetzt, ein Array von Länge N und eine Summe S, zu der die Elemente summieren müssen. Im Moment bin ich [ 10, 0, 0, 0, 0, 9, 8, 1, 5, 0, 0 ]für die Lückensequenz und meine Iterationsfunktion für das Array ist (a)=>{for(var x=0;!a[x];x++);if(a.length-x>1){a[0]=a[x]-1;a[x]=(x==0?a[x]:0);a[x+1]++;}else{a[0]=a[x]+1;a[x]=0;i=0}}. Ich fing an bei [ 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ].
Patrick Roberts
6

Befunge-93, 58 Bytes, Sicher!

_vv$v<~:!`:<#^0*@-:0*5|845\+`-v0,<#-^<

Probieren Sie es online!

Ursprüngliches Programm

_vv
 $ v<
 ~:!`
 :<#^0
*  @
-:0
*5 |
8
45
\+`
-
v0,<
#-
^<

Probieren Sie es online!

Der Trick dabei war, dass der Ausführungspfad eher vertikal als horizontal war. Dann wurden verschiedene Leerzeichen nach dem Zufallsprinzip in den Code eingefügt, um die vertikalen Pfade weiter zu mischen. Nachdem die Zeilenumbrüche und Leerzeichen endlich entfernt worden waren, gab es hoffentlich nur sehr wenige Hinweise darauf, wie sich die Vorgänge zueinander verhalten.

Für den Fall, dass das nicht schwierig genug war, habe ich auch ein wenig Interleaving eingesetzt, sodass eine Reihe von Operationen von verschiedenen, senkrecht zueinander verlaufenden Codepfaden ausgeführt wurden. Die Idee ist, dass Sie, wenn Sie dachten, Sie hätten die richtige Position für einen bestimmten Befehl gefunden, nicht erkennen würden, dass Sie ihn später im Code möglicherweise erneut verwenden müssen.

Ich bin mir nicht sicher, ob es die Mühe wert war, die Dinge kompliziert zu machen, oder ob sich die Leute überhaupt nicht darum gekümmert haben, es zu lösen. :)

Code-Erklärung

_      Since an empty stack is treated as zero, this initially just branches right.
v      The program flow is then directed downwards.
$      And this drop command initially does nothing because the stack is still empty.
~      A character is read from stdin.
::     Two duplicates are created.
55+-   We subtract 10 from the first copy (the 0- is just a nop to confuse things).
\48*-  And subtract 32 from the second copy.
*      The product of those two will be zero if the character is a newline or space.
_      So if we got whitespace, our branch goes right again repeating the loop.

v      If not, we go left, wrapping around till we hit the down arrow in column 3.
:<:    Again we make two duplicates of the character.
0`!|   One copy is used to compare if it's not greater than zero.
@      If it's not (i.e. it's the EOF), the branch goes up and we terminate.
<      Otherwise we go down and to the left.
,      Output the second copy of the character, leaving one remaining on the stack.
0      Push a zero to force the next branch right.
v      Redirect the flow down, wrapping to the top again.
_      Back at our initial branch, the zero we pushed forces us right.
v      Again the program flow is directed downwards.
$      And the drop command gets rid of the last duplicate character.
~      So now we're back reading the next character and the loop repeats.
James Holderness
quelle
5

C # 6, 201 Bytes, Cracked by Link Ng

usingSystem.Linq;_=>string./**/#iftrueJoin(/*"*//*/""/**//*/"*/",#elseConcat(//*/,#endiffrommin""letp=$@"{@""[1]}"fromiin(_.Replace(p,@""))where!new[]{p[0]^32^10}.Contains(i)select@i);

184 Bytes sind zusammengebrochen, so dass Sie 17 Bytes Leerzeichen haben.

Gebrochene Lösung unter Verwendung der, Concatwährend meine beabsichtigte Lösung die verwendete Join, hier ist die beabsichtigte Lösung:

_=>string./**/
#if true
Join(/*"* //*/""/**//*/"* /",#elseConcat(//*/,
#endif
from m in" "let p=$@"{@"  "[1]}"from i in(_.Replace(p,@"
"))where!new[]{p[0]^32^10}.Contains(i)select@i);
Milch
quelle
Das braucht c # 6+ um zu funktionieren, kannst du das hinzufügen?
TheLethalCoder
Dies wurde von @Link Ng geknackt: codegolf.stackexchange.com/a/103233/38550
TheLethalCoder
5

MATL , 22 Bytes. Gebrochen und geknackt .

Dies ist ein Programm, das Eingaben über STDIN entgegennimmt und die Ausgabe über STDOUT erzeugt.

Code ohne Leerzeichen oder Zeilenumbrüche:

t'@*'dm1e5%Mdw%Y(

Das Eingabeformat ist aufgrund der Art und Weise, wie MATL Zeichenfolgen eingibt, etwas umständlich. Zeichenfolgen mit Zeilenumbrüchen können nicht direkt über STDIN eingegeben werden, da jede Eingabe eine einzelne Zeile sein muss (Zeilenumbruch markiert das Ende der Eingabe). Das Format ist also wie folgt:

  1. Eine Zeichenfolge wird in einfache Anführungszeichen eingeschlossen . Wenn der Zeichenfolgeninhalt einfache Anführungszeichen enthält, werden diese durch Duplizieren maskiert . Beispiel:'I''m a string'

  2. Um eine Zeichenfolge mit Zeilenumbrüchen einzugeben, müssen Sie die Zeichenfolge in Zeilenumbrüche aufteilen und alles (in eckigen Klammern) verketten, einschließlich Zahlen als ASCII-Codes . Betrachten Sie beispielsweise die Zeichenfolge, die aus meinem Vor- und Nachnamen mit einem Zeilenumbruch dazwischen besteht. Es würde als eingegeben werden ['Luis' 10 'Mendo'].

    Dies ermöglicht die Eingabe anderer (möglicherweise nicht druckbarer) ASCII-Codes. So könnte die Zeichenfolge in Punkt 1 oben alternativ als eingegeben werden ['I' 39 'm ' 97 32 'string']. Überprüfen Sie es hier .

    Die einzige Bedingung ist, dass mindestens einer der Teile in den Klammern eine Zeichenfolge ist. Das erzwingt, dass beliebige Zahlen bei der Verkettung als ASCII-Codes interpretiert werden.

Entschuldigung für die Ungeschicklichkeit Viel Glück bei der Verwendung dieses Formats!

Originelle Lösung

t' @ *'dm1e 5%
Mdw%Y
(

Jedes %ist ein Kommentarsymbol und der Rest der Zeile wird ignoriert.

Leerzeichen tun nichts, sondern dienen als Trennzeichen. Beispielsweise 1e5würde ohne das Leerzeichen als die Zahl interpretiert 100000.

t Nimmt die Eingabe und dupliziert sie.

' @ *'pusht diese Zeichenkette und dberechnet ihre aufeinanderfolgenden Differenzen, was ergibt [32 -32 10](das -32ist nutzlos).

mgibt ein logisches Zeilenarray an, das angibt, welche Zeichen 32oder 10(oder -32) sind.

1gefolgt von eFormänderungen in einer Reihe. Dies ist hier nicht möglich.

5gefolgt von Merneutem Drücken 1(letzte Eingabe für die letzte Funktion mit mehreren Eingaben, d. h. e).

dberechnet aufeinanderfolgende Differenzen von 1und gibt so [](leeres Array).

wswappt und (ordnet schließlich []Leerzeichen zu, dh entfernt sie.

Luis Mendo
quelle
1
Du lügst! Auf keinen Fall funktioniert das! (+1) ...
Stewie Griffin
2
geknackt?
MickyT
2
Mist ... Ich habe nicht bemerkt, dass es bereits geknackt war ... Nun, doppelt geknackt .
Stewie Griffin
Gute Arbeit ihr beide! :-) Nicht genau meine beabsichtigte Lösung, aber es funktioniert perfekt
Luis Mendo
4

RProgN , 15 Bytes geknackt !

''`R""`R

Sie können Spielzeug mit dem Code hier . Eine relativ einfache Lösung, die hoffentlich aufgrund der nervigen Art, wie RProgN mit Zeichenfolgen umgeht, ungerissen bleibt.

Ursprüngliches Programm

' ' ` R
"
" ` R

Explination

Erstens wird die Eingabe implizit in den Stapel verschoben. Stapel:<INPUT>

Dann verwenden wir '', um ein Leerzeichen auf den Stapel zu schieben. Stapel:<INPUT> " "

Das `versucht tatsächlich, einen String zu pushen, der durch` (WORD) dargestellt wird, aber da dahinter ein Leerzeichen steht, pusht es nur einen leeren String. Stapel:<INPUT> " " ""

Das R hier ist Zucker für den Befehl Ersetzen. Stapel:<INPUTWITHOUTSPACES>

Als nächstes drückt die "NEWLINE" eine Zeichenkette, die eine Newline enthält. Das ist schön, weil RProgN keine Escape-Zeichen verwendet, sondern nur eine solche Zeichenkette direkt nach oben drückt. Stapel<INPUTWOSPACES> "\n"

Dann verwenden wir wieder den Trick `und Replace, was unsere Ausgabe ergibt.

Ein Taco
quelle
Soll das in Firefox funktionieren?
Conor O'Brien
Ich verwende es in Firefox, gibt es ein Problem? Kannst du einen Screenshot bekommen?
ATaco
geknackt?
MickyT
Na das ging ja schnell. Ich habe fast eine halbe Stunde gedauert!
ATaco
4

Ruby, 86 Bytes + 1 Flag = 87 ( geknackt von Dom Hastings )

Erfordert ein Befehlszeilenflag -p.

eval"(T$}{(!//;:678?32.&&)".gsub(/|(.)/){$1&&$&.ord.^($'.count('')).chr}

Der Code ist in dieser Form tatsächlich gültig, es ist nur ein No-Op.

Histokrat
quelle
Das ist großartig, ich liebe es! Also meine ...
Dom Hastings
Geknackt!
Dom Hastings
4

Strahl , 72 Bytes, sicher!

Nun zu einer 2d Sprache. Kann mit dem TIO Nexus gespielt werden .

s'''>`+++)+Ss`n\
 n`sS+(+++`<``/
 >rgn\
 ^ @<(\  
     H         <
 ^    /

Ein ziemlich einfaches Programm ohne viel zu tun, um die Leute zum Narren zu halten.

s'''>`+++)+Ss`n\ # Sets the memory slot 0 to 0, 10 to 10 and 32 to 32. n will redirect down
 n`sS+(+++`<``/  # since memory != store. \ is a red herring and not hit.
 >rgn\           # read in from input and set store to memory value. For all characters
 ^ @<(\          # other than space, LF and end of input this will be different and n will 
     H         < # redirect down then through to the print and back to read. Space, LF and  
 ^    /          # end of input get directed to the ( which tests for 0. This will redirect 
                 # space and LF to path back to read, otherwise it will skip over and halt
MickyT
quelle
1
Ich denke, ich werde den Interpreter auf Node verschieben, wenn ich Zeit habe, damit Dennis ihn zu TIO hinzufügen kann ...
ETHproductions
1
Ich habe einen Node-Klon des Interpreters erstellt und Dennis hat ihn jetzt zu TIO hinzugefügt !
ETHproductions
4

Labyrinth , 127 Bytes

);""{"".@"-;,""""":"##"*"(:"+":}-;{";;"*#{:;"#""+("-;"";;"})"";""""""""

Hoffentlich habe ich das richtig gemacht :) Dies ist mein erster Eintrag für Polizisten und Räuber.

Ursprünglicher Code

 ) ;""{"".@
"-;, "" ""
"  :
" ##
" *
" (:
"  +
"  :}-;{
"    ; ;
" *#{: ;
" #    "
" +("-;"
"    ; ;
"    })"
"      ;
""""""""
Robert Hickman
quelle
Ihre Antwort ist jetzt sicher, Sie können Ihren ursprünglichen Code und eine Erklärung hinzufügen.
Laikoni
4

Java, 3241 + 28 Bytes für einen großen Integer-Import

Dieser Eintrag dient ausschließlich dem Nachweis der Möglichkeit eines rein kryptografisch gesicherten Eintrags. Ich glaube, dass dies innerhalb der Regeln liegt, aber wenn es gegen den Geist ist, lassen Sie es mich bitte wissen und ich werde aus Fairness streichen. Ich werde dies "unsicher" auf unbestimmte Zeit belassen, bis (und falls) ein Riss gefunden wird. Dies ist eine Monstrosität und könnte sicherlich weiter optimiert werden, aber hier ist es.

interfacer{staticvoidmain(String[]A){Strings=",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,",q=",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,",a="",b="";for(Stringt:s.split(",")){a+=t.length();}for(Stringt:q.split(",")){b+=t.length();}if((newBigInteger(a).multiply(newBigInteger(b)).toString()).equals("3649760552772806991406184564114682549877113954361462782925976763675666255653486225665808494957477900238166874367635068317805381406282572366371821972593595701388544127398102379288357379612333197280663769935384647844344358594407966485992727383589962048236726744715096711312156760311643104858212670342667229690568585229658813910569607411855770280546861422837629553847973043531578541545436967345783407835402474562087790816775240815912495599135241317")){System.out.println(A[0].replaceAll("","").replaceAll("\n",""));}}}

Aus Fairness gegenüber Räubern wird hier das "offensichtliche" Leerzeichen hinzugefügt.

interface r {

    static void main(String[] A) {
        String s = ",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,", q = ",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,", a = "", b = "";
        for (String t : s.split(",")) {
            a += t.length();
        }
        for (String t : q.split(",")) {
            b += t.length();
        }
        if ((new BigInteger(a).multiply(new BigInteger(b)).toString()).equals("3649760552772806991406184564114682549877113954361462782925976763675666255653486225665808494957477900238166874367635068317805381406282572366371821972593595701388544127398102379288357379612333197280663769935384647844344358594407966485992727383589962048236726744715096711312156760311643104858212670342667229690568585229658813910569607411855770280546861422837629553847973043531578541545436967345783407835402474562087790816775240815912495599135241317")) {
            System.out.println(A[0].replaceAll("", "").replaceAll("\n", ""));
        }
    }
}

Viel Glück, ich würde es lieben, wenn dies geknackt würde. Tatsächlich werde ich dafür sogar ein unbegrenztes Kopfgeld erheben. Wenn Sie dies irgendwann knacken, erhalten Sie beim Stapelaustausch eine unbegrenzte Anzahl von 500 Wiederholungen (sowie wahrscheinlich eine wunderbare mathematische Arbeit).


Rohan Jhunjhunwala
quelle
2
Ihre und meine Lösung werden wahrscheinlich ungerissen durch die Jahrhunderte gehen.
Joshua
1
Hat diese Submission für den Downvoter etwas Unzulässiges?
Rohan Jhunjhunwala
1
Es gibt tatsächlich eine triviale Lösung für dieses
Problem
1
@ SLuck49 kannst du es mir kommentieren?
Rohan Jhunjhunwala
1
@ SLuck49 wow! Mir ist gerade klar geworden, was Sie sich angesehen haben! Ich habe fast 500 Ruf verloren.
Rohan Jhunjhunwala
3

C, 140 Bytes, geknackt von Riley

Beginnen wir mit einem einfachen.

#include<stdio.h>intmain(){inta=getchar();while(a!=EOF){//\a=getchar();if(a!=10&&a!=32)//\\putchar(a^10^32);putchar(a);a=getchar();}}

(Ich hoffe, ich mache das richtig.)

betseg
quelle
1
Geknackt Nicht die Lösung, da ich 1 Byte weniger habe.
Riley
@ Riley fügen Sie eine zusätzliche Zeile am Ende und es wird alles gut;)
Alfie Goodacre
2

V , 37 Bytes Gebrochen von nmjcman101

OVrS200@"kIi|D@"Aüî|D@"

Da dies nicht druckbar ist, ist hier die lesbare Version:

O<esc>Vr<C-a>S200<esc>@"kIi<C-v><C-v><esc>|D@"<esc>Aüî<esc>|D@"

Oder wenn Sie es vorziehen, ein Hexdump:

00000000: 4f1b 5672 0153 3230 301b 4022 6b49 6916  O.Vr.S200.@"kIi.
00000010: 161b 7c44 4022 1b41 fcee 1b7c 4440 22    ..|D@".A...|D@"
DJMcMayhem
quelle
Cracked Das war ein wirklich cooles Puzzle
nmjcman101
2

JavaScript ES6, 380 Byte, sicher

Dies ist die Art von Eintrag, die ich ursprünglich veröffentlichen wollte. Es ist riesig und hat fast keine Gewinnchance, aber ich denke, es sollte kryptografisch stark genug sein, um 7 Tage zu überstehen. Nun kann ich mich irren!

67 Bytes Leerzeichen zum Hinzufügen.

s=>{for(k=`|||`.split`|`.map(s=>s.replace(/\s/g,c=>(k-=(c<'')+1,n=n<<2|k&3),k=n=0)&&n),x=10106050295,y=-4955405499,i=32,d=2654435769,t=d*i;i--;y-=(x<<4^x>>>5)+x^t+k[t>>>11&3],t-=d,x-=(y<<4^y>>>5)+y^t+k[t&3]);returns[atob(([x,y].map(n=>String.fromCharCode(n&255,n>>8&255,n>>16&255,n>>24)).join``))](/[\n]/).join``}

Lösung

Dies ist eine Implementierung des Extended Tiny Encryption Algorithmus . Der 64-Bit-Whitespace-codierte Schlüssel wird auf den folgenden 128-Bit-Schlüssel erweitert:

K = [0xd224de37, 0x89e34e79, 0xe34e7748, 0x939e2789]

Bildbeschreibung hier eingeben

Quelle: Wikipedia

Sobald der 64-Bit-Block entschlüsselt und in ASCII konvertiert wurde, wird er [x, y]als gelesen. c3BsaXQ=Dies ist die Base64-codierte Darstellung von split.

Arnauld
quelle
1
Ich habe brachial angefangen, dieses Denken zu erzwingen. Vielleicht habe ich Glück und Sie haben dafür gesorgt, dass jeder der 4 Schlüsselwerte dieselbe Länge hat (8 Bits). Außer es wären jeweils 16 Bits ... woops. Brute Force wird nicht passieren, Zeit für einen anderen Ansatz.
SLuck49
2

Vitsy , 73 Bytes, sicher

Das ist absolut böse.

5mW3m7m7m2mD&EPamX}<m15mEnl9mZD\[4m]^P-cm(D_2-3*bmD1-dmrnu-'

Viel Glück! 13 Elemente mit Leerzeichen zum Hinzufügen.

Originalcode:

5m
W3m7m
7m
2m
D&EPamX}
<m1
5mEn
l9mZ
D
\[4m]
^P-cm(D
_2-3*
bmD1-dmrnu-
'

Probieren Sie es online!

Dies vereinfacht sich grob auf:

<m1
W2\[2m]Z
l\[D&EP^P-_2-3*D1-rnu-(DX}]
Addison Crump
quelle
Bitte schauen Sie nicht in den Bearbeitungsverlauf, da ich noch einen Fehler in meinem Code hatte.
Addison Crump
Du kennst das Böse nicht. Ich kenne das Böse.
Joshua
Für mich ist es kurz nach 03:00 Uhr, daher füge ich morgens eine Erklärung hinzu.
Addison Crump
1

C #, 159 Bytes, Gebrochen von Milch

usingSystem.Linq;s=>string.Join("",string.Join("",s.Split(@"".Replace(newstring((char)0x0D,1),"").ToCharArray())).Select(c=>c+""!=""?c+"":"").ToArray());

153 zusammengebrochen, so dass nur 6 Bytes Whitespace zu finden sind, sollte nicht zu schwer sein ...

TheLethalCoder
quelle
1
Cracked
Milch
1

netzförmig, 43 bytes, geknackt

ISBqv<>>$$4jE:d/v$v?c+91d/v?E;!?l$/o$

Die Version auf TIO ist veraltet, aber Sie können sich eine Kopie vom Github besorgen .

Conor O'Brien
quelle
Die Version auf Nexus war bereits aktuell. Ich habe auch v1 gezogen.
Dennis
Funktioniert das nur, wenn die Eingabe zwei aufeinanderfolgende Zeilenvorschübe enthält?
Martin Ender
@MartinEnder sollte es. Es hängt davon ab, ob der Eingang weitergeleitet wird oder nicht. Wenn es weitergeleitet wird, sollte es das ganze stdin lesen.
Conor O'Brien
@ Tennis danke! Ich wollte dich im Chat fragen.
Conor O'Brien
Gebrochen
James Holderness
1

Wolfram, 132

Hat wahrscheinlich mehr als eine Lösung (Hinweis: Mersenne)

StringReplace[#,""->"",Limit[x/(x-1),x->Boole[PrimeQ[
212821282128228281282128228821282128212821282-1]]]]&

Lösung

StringReplace[#," "->"",Limit[x/(x-1),x->Boole[PrimeQ[
2 128 2 128 2 128 2 2 8 2 8 128 2 128 2 2 8 8 2 128 2 128 2 128 2 128 2-1]]]]&
Swish
quelle
> Ihr
Beitrag
@KritixiLithos Es ist entfernt
swish
Was ist mit den Leerzeichen vor der zweiten Zeile und dem Zeilenumbruch zwischen der ersten und der zweiten Zeile?
Kritixi Lithos
Nun, Sie haben Recht, es ist nur für die Lesbarkeit ...
swish
Ich denke, Sie können die Lösung jetzt posten.
CalculatorFeline
1

Leerzeichen , 81 74 Bytes

																					

Vom Menschen lesbare Version:

ttttttttttttttttttttt (21 tab characters)

Ich weiß, dass dies eine alte Herausforderung ist, aber hoffentlich ist jemand bereit, dies zu knacken. Ich habe versucht, für bytecount zu optimieren, aber es ist möglicherweise möglich, etwas mit der gleichen Anzahl von Tabulatorzeichen zu verkürzen.

Ephphatha
quelle
0

tcc, 850 bytes

Um zu vermeiden, dass eine sehr lange Zeile eingefügt wird, habe ich diese mit tr -d '\ n' | übergeben fold -b -w 60.

#!/usr/bin/tcc-run#include<stdio.h>typedefunsignedcharu;um[]
={104,105,16,152,94,131,43,42,112,214,53,207,116,170,185,210
};intmain(){uS[256];uk[256];ui,j,t;intc,n=0;FILE*f;f=fopen(_
_FILE__,"r");/*cannotfail*/while(-1!=(c=fgetc(f)))if(c==''||
c==10)k[++n]=c;fclose(f);i=0;do{S[i]=i;}while(++i!=0);j=0;i=
0;do{j=j+S[i]+k[i%n];t=S[i];S[i]=S[j];S[j]=t;}while(++i!=0);
i=0;do{if(S[i]!=m[i])j=1;}while(++i<sizeof(m));if(j==1){i=0;
do{printf("%d,",(int)S[i]);}while(++i<sizeof(m));printf("\n"
);}else{while(-1!=(c=fgetc(stdin)))if(c!=''&&c!=10)fputc(c,s
tdout);}returnj;}
Joshua
quelle
Link zum Dolmetscher?
Addison Crump
@VoteToClose: apt-get install tcc hat es für mich getan.
Joshua
0

SILOS , 159 Bytes Sicher!

loadLinedef:lblgetagetzzzz/za=256:aX=getax=Xy=Xz=xx-10x|ifxbGOTOx:by-32y|ifycGOTOx:cprintCharX:xa+1z+1x=getaifxa:b

Sollte ziemlich trivial sein. Es ist mein erster Eintrag für Bullen und Räuber.

Niemand griff es an, wahrscheinlich aufgrund der Esoterik meiner eigenen Sprache. Scheint eine schmierige Art zu sein, vorbei zu rutschen, aber das ist eigentlich egal, da kürzere sicher sind.

loadLine
def : lbl geta get z zz
z/z
a=256
:a
X=get a
x=X
y=X
z=x
x-10
x |
if x b
GOTO x
:b
y-32
y|
if y c
GOTO x
:c
printChar X
:x
a+1
z+ 1
x=get  a
if x a
:b

Probieren Sie es einfach online aus

Rohan Jhunjhunwala
quelle