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>

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

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
}

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.

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

> <>, 40 Bytes, Gebrochen von Teal Pelican

v<<i/\:=::a?0/>/1?o-=="?;">^

Ich habe übrigens fishlanguage.com verwendet , nur für den Fall, dass es Unterschiede zwischen den Dolmetschern gibt.

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.

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

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.

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.

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.

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

Labyrinth , 127 Bytes

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

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

Ursprünglicher Code

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

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).

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.)

Befunge 98, 65 Bytes, geknackt von Pietu1998

~v>#@>::':'0--\'[';--!8v1+!*1+j!j,v>#@

Ursprüngliches Programm

~v           >#@
 >::':'0--\'[';--!8v1+!
*1+j !j,     v     >
#@

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@"

Minkolang v0.15 , 88 Bytes, Gebrochen!

$oI[dd""=$r'10'=1J,?1R]r$O3.14$$$Cdollars>$$$Ceverywhere>x

Probieren Sie es online!

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]

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.

let f =

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]);return s[atob(([x,y].map(n=>String.fromCharCode(n&255,n>>8&255,n>>16&255,n>>24)).join``))](/[ \n]/).join``}

console.log(f(`H e l l o
W o r l d`))

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

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

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 .

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

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.

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

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