Na potrzeby tego wyzwania zdefiniujemy białe znaki jako tylko linie (0x0A) i spacje (0x20). Zauważ, że większość języków i smaków wyrażeń regularnych uważa również wiele innych znaków za spacje, zarówno wewnątrz, jak i poza zakresem ASCII, więc możesz nie być w stanie skorzystać z odpowiednich wbudowanych funkcji.

Wyzwanie gliniarzy

Powinieneś napisać program lub funkcję w wybranym przez siebie języku, który pobiera ciąg znaków składający się ze znaków ASCII (oprócz NUL) jako dane wejściowe i wyjściowe, po usunięciu wszystkich białych znaków. Na przykład, jeśli otrzymałeś następujące dane wejściowe:

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

Powinieneś wyjść

Hello,World!

Twoje zgłoszenie będzie wtedy kodem źródłowym z usuniętymi białymi spacjami (ten sam proces, jak przekazanie rozwiązania jako danych wejściowych do siebie, chociaż twoje rozwiązanie może również zawierać znaki spoza zakresu ASCII). Twoim celem jest jak najtrudniejsze ustalenie, gdzie należy wstawić białe znaki, aby odzyskać prawidłowe rozwiązanie w wybranym języku. Pamiętaj, że złodzieje mogą wstawić mniej białych znaków niż usunięto, ale nie więcej. Pamiętaj też, że złodzieje nie muszą dokładnie pasować do twojego kodu, muszą tylko znaleźć prawidłowe rozwiązanie.

Twoja odpowiedź powinna zawierać następujące informacje:

• Język (i wersja, jeśli to konieczne), w którym napisałeś swoje rozwiązanie.
• Liczba bajtów Twojego rozwiązania przed usunięciem białych znaków.
• Twoje rozwiązanie z białymi spacjami zostało usunięte.

Rozwiązaniem może być program lub funkcja, ale nie fragment kodu i nie można zakładać środowiska REPL. Można przyjmować dane wejściowe za pośrednictwem STDIN, argument wiersza polecenia lub argument funkcji i dane wyjściowe za pośrednictwem STDOUT, wartości zwracanej funkcji lub parametru funkcji (wyjściowej).

W trosce o sprawiedliwość musi istnieć darmowy tłumacz lub kompilator dla wybranego przez ciebie języka.

Nie wolno używać wbudowanych funkcji do mieszania, szyfrowania lub generowania liczb losowych (nawet jeśli generator liczb losowych zostanie ustawiony na stałą wartość). Twoje rozwiązanie musi być w stanie przetworzyć dowolny ciąg 100 znaków lub mniej w ciągu 10 sekund na rozsądnej maszynie stacjonarnej.

Jeśli twoja odpowiedź nie zostanie złamana w ciągu 7 dni (168 godzin), możesz ujawnić własne rozwiązanie, w którym to momencie odpowiedź zostanie uznana za bezpieczną . Dopóki nie ujawnisz swojego rozwiązania, może ono zostać złamane przez rabusiów, nawet jeśli minęło już 7 dni. Wygrywa najkrótsza bezpieczna odpowiedź (mierzona przed usunięciem białych znaków).

Jeśli twoja odpowiedź się popsuła, zaznacz to w nagłówku odpowiedzi wraz z linkiem do odpowiedzi odpowiedniego rabusia.

Idź tutaj po część rabusiów.

Nieprzetworzone zgłoszenia

<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 bajtów, złamany przez nich

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

To pełny program i dadaistyczny wiersz.

Kod z withspace (Wypróbuj online!)

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

^{Wciąż wyglądam dość poetycko, jeśli mnie zapytasz.}

Nie zaciemniono

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

Wyjaśnienie

do-Notation jest tylko cukier syntaktyczny, więc frównoważnie można zapisać jako

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

Dla list >>=-operator jest zdefiniowany jako concatMap, więc fstaje się

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

Tak więc biorąc pod uwagę dane wejściowe "a b\nc", linesdzieli dane wejściowe na znaki nowej linii ["a b","c"], wordsdzieli każdą linię na białych znakach, dając [["a","b"],["c"]](jak sobie uświadomiłem, że teraz obejmuje to znaki nowej linii, więc tak linesnaprawdę nie jest potrzebne). Konkatenacja raz daje ["a","b","c"], idjest funkcją tożsamości i jako taka nie ma żadnego efektu, a końcowa konkatenacja daje łańcuch "abc".

C, 475 bajtów, pęknięty przez Riley

Niektóre części C sprawiają, że naprawdę bardzo łatwo jest zobaczyć, gdzie powinny się znajdować białe znaki. Jednak preprocesor c tego nie robi. Tak więc ten kod składa się z dwóch części: do linii 17 (236 znaków z białymi spacjami) kod jest praktycznie nieudostępniony, a potem (239 znaków z białymi spacjami), powodzenia!

Nie wygram tych zawodów długim strzałem, ale chciałem zobaczyć, co można zrobić z preprocesorem c.

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

Kompiluje (z ostrzeżeniami, jeśli je włączysz) zi gcc -std=c89 -ansidziała podobniecat file | ./a.out

To pękło znacznie szybciej, niż myślałem, gratulacje! Moja strategia polegała na #definesusunięciu oczywistych granic tokenów (takich jak „;”), a następnie na użyciu większej liczby, #definesaby NAPRAWDĘ nieintuicyjny był sposób ich tasowania.

Tak przy okazji, tak wygląda kod po dodaniu tylko oczywistych białych znaków:

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

Oktawa, 69 bajtów, BEZPIECZNIE!

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

Format wejściowy: nowych linii nie można wprowadzać bezpośrednio w wierszu polecenia. Utwórz ciąg przez konkatenację w następujący sposób:

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

Wywołaj funkcję w ten sposób (dodaj białe znaki):

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

Oryginalny kod:

Aby to zadziałało, potrzebujesz tylko 66 bajtów, ale napisałem 69 w nagłówku, aby nie podawać zbyt wielu informacji.

Oryginalny kod wygląda następująco:

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

Wyjaśnienie:

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

Ujest punktem kodowym 85w tabeli ASCII, więc wygląda na to, że po nim powinna być pierwsza spacja 85. Źle!

Jeśli 853zamiast tego wstawimy spację , powinniśmy uzyskać numer znaku 853, prawda ..? Używając, charaby sprawdzić, czy jest to rozpoznawalna postać:

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

Jednak nie używamy charw kodzie, używamy krótszej wersji, w której łączymy liczby z pustym ciągiem [853 '']. Zamiast dawać błąd spoza zakresu, krótsza wersja po prostu przyjmuje moduł liczbowy 256.

Tak się po prostu stało 85+3*256 = 853. Gdy char(853)daje ostrzeżenie, [853,'']wraca U.

Oczywistym sposobem wykonania tego zadania w Octave jest:

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

Wiemy, że po pierwszym muszą być nawiasy otwierające (punkt kodu 40) U. 29oczywiście nie pasuje, więc przesuwamy przestrzeń jeszcze bardziej w prawo i dostajemy 296. mod(296,256) = 40. Bingo!

Kontynuuj w ten sposób i zakończ sekwencją:

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

Na koniec używamy evaldo przekształcenia łańcucha w kod.

JavaScript ES6, 199 bajtów, złamany przez SLuck49

Dość obszerny wpis z 33 bajtami białych znaków do dodania.

s=>eval(atob`ISYgJiAtOkI8Qk97BRBeaxZFShoUZSsiOGkMenNy`.replace(/./g,(c,i)=>String.fromCharCode(c.charCodeAt()^(k+="SecretCode".split(/\w/)[i%11].length)),k=0)).join``

> <>, 40 bajtów, Cracked by Teal pelikan

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

Nawiasem mówiąc, korzystałem z fishlanguage.com , na wypadek, gdyby były różnice między tłumaczami.

Befunge-93, 58 bajtów, Bezpiecznie!

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

Wypróbuj online!

Oryginalny program

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

Wypróbuj online!

Sztuczka polegała na tym, że ścieżka wykonania była bardziej pionowa niż pozioma, a następnie w kodzie losowo wstawiano różne spacje, aby dalej tasować ścieżki pionowe. Kiedy linie zostały przerwane i białe znaki zostały w końcu usunięte, mamy nadzieję, że bardzo niewiele wskazywało na to, w jaki sposób operacje były ze sobą powiązane.

W przypadku, gdy nie było to wystarczająco trudne, wrzuciłem trochę przeplatania, więc wiele operacji zakończyło się różnymi ścieżkami kodu przepływającymi prostopadle do siebie. Chodzi o to, że jeśli uważasz, że znalazłeś właściwą pozycję dla konkretnego polecenia, nie zdajesz sobie sprawy, że będziesz musiał użyć go ponownie w kodzie później.

Nie jestem pewien, czy warto było tyle wysiłku, aby skomplikować sprawę, czy ludzie nawet nie zadali sobie trudu, aby to rozwiązać. :)

Objaśnienie kodu

_      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 bajtów, 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 bajty zwinięte, pozostawiając 17 bajtów białych znaków.

Rozwiązanie pęknięte przy użyciu, podczas Concatgdy moje zamierzone rozwiązanie wykorzystało Join, oto zamierzone rozwiązanie:

_=>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 bajty. Popękane i popękane .

Jest to program, który pobiera dane wejściowe przez STDIN i generuje dane wyjściowe przez STDOUT.

Kod bez spacji i znaków nowej linii:

t'@*'dm1e5%Mdw%Y(

Format wejściowy jest trochę niewygodne, ponieważ, jak Mátl zajmuje wejście ciąg. Ciągi znaków nowej linii nie mogą być wprowadzane bezpośrednio przez STDIN, ponieważ każde wejście musi być pojedynczą linią (nowa linia oznacza koniec wprowadzania). Format jest więc następujący:

1. Ciąg jest ujęty w pojedyncze cudzysłowy . Jeśli treść ciągu zawiera pojedyncze cudzysłowy, są one zastępowane przez duplikowanie . Przykład:'I''m a string'

2. Aby wprowadzić ciąg z znakami nowej linii, należy go podzielić na znaki nowego wiersza i połączyć wszystko (za pomocą nawiasów kwadratowych), w tym liczby jako kody ASCII . Rozważmy na przykład ciąg utworzony przez moje imię i nazwisko z nową linią pośrodku. Zostałby wpisany jako ['Luis' 10 'Mendo'].

   Umożliwia to wprowadzanie dowolnych innych (prawdopodobnie niemożliwych do wydrukowania) kodów ASCII. Zatem ciąg w punkcie 1 powyżej można alternatywnie wprowadzić jako ['I' 39 'm ' 97 32 'string']. Sprawdź tutaj .

   Jedynym warunkiem jest to, że co najmniej jedna z części w nawiasach jest łańcuchem. Wymusza to interpretację dowolnych liczb jako kodów ASCII podczas łączenia.

Przepraszamy za niezręczne Powodzenia przy użyciu tego formatu!

Oryginalne rozwiązanie

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

Każdy z nich %jest symbolem komentarza, więc reszta linii jest ignorowana.

Przestrzenie nic nie robią, ale służą jako separatory. Na przykład 1e5bez spacji będzie interpretowany jako liczba 100000.

t pobiera dane wejściowe i kopiuje je.

' @ *'wypycha ten ciąg i doblicza kolejne różnice, co daje [32 -32 10]( -32jest bezużyteczne).

mdaje logiczną tablicę wierszy wskazującą, które znaki są 32lub 10(lub -32).

1a następnie eprzekształca się w wiersz. Tutaj nie ma mowy.

5następnie ponownie Mwypycha 1(ostatnie wejście do najnowszej funkcji wielokrotnego wprowadzania, czyli e).

doblicza kolejne różnice 1, a więc daje [](pusta tablica).

wzamienia, a na koniec (przypisuje []znaki do białych znaków, tzn. usuwa je.

RProgN , 15 Bajtów popękanych !

''`R""`R

Możesz bawić się kodem tutaj . Stosunkowo proste rozwiązanie, miejmy nadzieję, że irytujący sposób, w jaki RProgN obsługuje ciągi znaków, sprawi, że nie będzie on używany.

Oryginalny program

' ' ` R
"
" ` R

Wyjaśnienie

Po pierwsze, dane wejściowe są domyślnie wypychane na stos. Stos:<INPUT>

Następnie używamy „”, aby przesunąć spację na stos. Stos:<INPUT> " "

`faktycznie próbuje wypchnąć ciąg reprezentowany przez` (WORD), ale ponieważ po nim jest spacja, po prostu wypycha pusty ciąg. Stos:<INPUT> " " ""

R oznacza cukier dla polecenia Zamień. Stos:<INPUTWITHOUTSPACES>

Następnie „NEWLINE” wypycha ciąg zawierający znak nowej linii, co jest miłe, ponieważ RProgN nie używa znaków ucieczki, po prostu prosto w górę pozwala popchnąć taki ciąg. Stos<INPUTWOSPACES> "\n"

Następnie ponownie używamy „trick” i Replace, co daje nam wynik.

Rubin, 86 bajtów + 1 flaga = 87 ( pęknięty przez Dom Hastings )

Wymaga flagi wiersza polecenia -p.

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

Kod jest w rzeczywistości prawidłowy w tej formie, to po prostu brak możliwości.

Belka , 72 bajty, Bezpiecznie!

Teraz dla języka 2D. Można grać w TIO Nexus .

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

Dość prosty program, w którym nie ma wiele, aby oszukać ludzi.

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

Labirynt , 127 bajtów

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

Mam nadzieję, że zrobiłem to dobrze :) to mój pierwszy wpis na gliny i złodziei.

Kod oryginalny

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

Java, 3241 + 28 bajtów dla dużego importu Integer

Ten wpis ma jedynie na celu udowodnienie możliwości czysto kryptograficznie bezpiecznego wpisu. Wierzę, że jest to zgodne z zasadami, ale jeśli jest to sprzeczne z duchem, daj mi znać, a usunę się z uczciwości. Pozostawię to „niebezpieczne” na czas nieokreślony do czasu, gdy (i jeśli) pęknięcie zostanie znalezione. Jest to potworność i na pewno można ją dalej optymalizować, ale oto ona.

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

Dla uczciwości wobec rabusiów, oto wszystko z dodaną „oczywistą” białą spacją.

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

Powodzenia, chciałbym zobaczyć to pęknięte. W rzeczywistości ustanowię nawet nieograniczoną nagrodę za to. Jeśli w którymś momencie to zrobisz, otrzymasz 500 powtórzeń nieskończonego wyróżnienia za wymianę stosu (a także prawdopodobnie wspaniały matematyczny papier).

C, 140 bajtów, pęknięty przez Riley

Zacznijmy od łatwego.

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

(Mam nadzieję, że robię to dobrze.)

Befunge 98, 65 bajtów, złamany przez Pietu1998

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

Oryginalny program

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

V , 37 bajtów Pęknięty przez nmjcman101

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

Ponieważ jest to niedrukowalne, oto jego czytelna wersja:

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

Lub jeśli wolisz, zrzut heksowy:

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 bajtów, pęknięty!

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

Wypróbuj online!

JavaScript ES6, 380 bajtów, bezpieczny

Jest to wpis, który początkowo planowałem wydać. Jest ogromny i prawie nie ma szans na wygraną, ale myślę, że powinien być wystarczająco kryptograficznie wytrzymały, aby wytrzymać 7 dni. Teraz może się okazać, że się mylę!

67 bajtów białych znaków do dodania.

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

Rozwiązanie

Jest to implementacja rozszerzonego algorytmu szyfrowania Tiny . 64-bitowy klucz kodowany spacjami jest interpretowany do następującego 128-bitowego klucza:

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

Źródło: Wikipedia

Po odszyfrowaniu i przekonwertowaniu na ASCII, 64-bitowy blok [x, y]odczytuje jako c3BsaXQ=, co stanowi zakodowaną reprezentację Base64 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 bajty, bezpieczny

To jest po prostu zło.

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

Powodzenia! 13 elementów białych znaków do dodania.

Oryginalny kod:

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

Wypróbuj online!

To z grubsza upraszcza do:

<m1
W2\[2m]Z
l\[D&EP^P-_2-3*D1-rnu-(DX}]

C #, 159 bajtów, Pęknięty przez mleko

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

153 upadło, więc znalezienie tylko 6 bajtów białych znaków nie powinno być zbyt trudne ...

siatkowy, 43 bajty, pęknięty

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

Wersja na TIO jest nieaktualna, ale możesz zdobyć kopię z github .

Wolfram, 132

Prawdopodobnie ma więcej niż jedno rozwiązanie (wskazówka: Mersenne)

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

Rozwiązanie

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

Biała spacja , 81 74 bajtów

Wersja czytelna dla człowieka:

ttttttttttttttttttttt (21 tab characters)

Wiem, że to stare wyzwanie, ale mam nadzieję, że ktoś zechce się tym zająć. Próbowałem zoptymalizować pod kątem liczby bajtów, ale może być możliwe utworzenie czegoś krótszego z taką samą liczbą znaków tabulacji.

tcc, 850 bajtów

Aby uniknąć wklejenia bardzo długiej linii, przeszedłem przez tr -d '\ n' | 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 bajtów Bezpiecznie!

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

Powinny być dość trywialne. To mój pierwszy wpis na gliniarzy i złodziei.

Nikt go nie zaatakował, prawdopodobnie z powodu ezoterycznej natury mojego własnego języka. Wydaje się, że jest to obskurny sposób na przemijanie, ale tak naprawdę nie ma to znaczenia, ponieważ krótsze są bezpieczne.

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

Krępuj się próbować go online