Với mục đích của thử thách này, chúng tôi sẽ xác định khoảng trắng là chỉ các nguồn cấp dữ liệu (0x0A) và khoảng trắng (0x20). Lưu ý rằng hầu hết các ngôn ngữ và hương vị regex đều coi nhiều ký tự khác là khoảng trắng, cả bên trong và bên ngoài phạm vi ASCII, do đó bạn có thể không sử dụng được các phần tử tương ứng.

Thử thách của cảnh sát

Bạn nên viết một chương trình hoặc hàm bằng ngôn ngữ bạn chọn, lấy một chuỗi, bao gồm các ký tự ASCII (trừ NUL), làm đầu vào và xuất nó với tất cả khoảng trắng được loại bỏ. Ví dụ: nếu bạn nhận được đầu vào sau:

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

Bạn nên xuất

Hello,World!

Việc gửi của bạn sau đó sẽ là mã nguồn của bạn với tất cả khoảng trắng được loại bỏ (quá trình tương tự như chuyển giải pháp của bạn làm đầu vào cho chính nó, mặc dù giải pháp của bạn cũng có thể chứa các ký tự bên ngoài phạm vi ASCII). Mục tiêu của bạn là làm cho nó càng khó càng tốt để tìm ra nơi cần chèn khoảng trắng để khôi phục một giải pháp hợp lệ trong ngôn ngữ bạn chọn. Lưu ý rằng những tên cướp có thể chèn ít khoảng trắng hơn bạn đã xóa, nhưng không nhiều hơn. Cũng nên nhớ rằng những tên cướp không cần phải khớp mã chính xác của bạn, chúng chỉ cần tìm bất kỳ giải pháp hợp lệ nào.

Câu trả lời của bạn nên có những điều sau đây:

• Ngôn ngữ (và phiên bản nếu cần thiết) mà bạn đã viết giải pháp của mình.
• Số byte của giải pháp của bạn trước khi xóa khoảng trắng.
• Giải pháp của bạn với khoảng trắng được loại bỏ.

Giải pháp của bạn có thể là chương trình hoặc chức năng, nhưng không phải là đoạn trích và bạn không được sử dụng môi trường REPL. Bạn có thể nhận đầu vào thông qua STDIN, đối số dòng lệnh hoặc đối số chức năng và đầu ra thông qua STDOUT, giá trị trả về của hàm hoặc tham số hàm (out).

Vì lợi ích của sự công bằng, phải có một trình thông dịch hoặc trình biên dịch có sẵn miễn phí cho ngôn ngữ bạn chọn.

Bạn không được sử dụng các hàm dựng sẵn để băm, mã hóa hoặc tạo số ngẫu nhiên (ngay cả khi bạn chọn trình tạo số ngẫu nhiên cho một giá trị cố định). Giải pháp của bạn phải có thể xử lý bất kỳ chuỗi nào từ 100 ký tự trở xuống trong vòng dưới 10 giây trên một máy tính để bàn hợp lý.

Nếu câu trả lời của bạn không bị bẻ khóa trong vòng 7 ngày (168 giờ), bạn có thể tiết lộ giải pháp của riêng mình tại thời điểm câu trả lời của bạn được coi là an toàn . Miễn là bạn không tiết lộ giải pháp của mình, nó vẫn có thể bị bọn cướp bẻ khóa, ngay cả khi 7 ngày đã trôi qua. Câu trả lời an toàn ngắn nhất sẽ thắng (được đo trước khi xóa khoảng trắng).

Nếu câu trả lời của bạn bị bẻ khóa, vui lòng cho biết điều này trong tiêu đề câu trả lời của bạn, cùng với liên kết đến câu trả lời của tên cướp tương ứng.

Tới đây cho phần của bọn cướp.

Đệ trình không bị xáo trộn

<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 byte, bị bẻ khóa bởi nimi

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

Đây là một chương trình đầy đủ và một bài thơ dadaistic.

Mã với không gian (Hãy thử trực tuyến!)

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

^{Vẫn trông khá thơ mộng, nếu bạn hỏi tôi.}

Khử nhiễu

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

Giải trình

Chú dothích chỉ là đường cú pháp, do đó fcó thể được viết tương đương là

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

Đối với danh sách, trình điều khiển >>=được định nghĩa là concatMap, vì vậy ftrở thành

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

Vì vậy, được cung cấp một đầu vào "a b\nc", linesphân tách đầu vào tại các dòng mới ["a b","c"], wordsphân tách từng dòng ở năng suất trắng [["a","b"],["c"]](như tôi nhận ra bây giờ điều này bao gồm các dòng mới, vì vậy linesthực sự không cần thiết). Ghép một lần cho ["a","b","c"], idlà hàm nhận dạng và do đó không có tác dụng và phép nối cuối cùng tạo ra chuỗi "abc".

C, 475 byte, bị bẻ khóa bởi Riley

Một số phần của C làm cho nó thực sự dễ dàng để xem khoảng trắng nên đi đâu. Bộ xử lý trước c, tuy nhiên, không. Vì vậy, mã này được sắp xếp thành hai nửa: lên đến dòng 17 (236 ký tự có khoảng trắng) mã gần như không bị biến dạng và sau đó (239 ký tự có khoảng trắng), chúc may mắn!

Sẽ không chiến thắng trong cuộc thi này bằng một cú sút xa, nhưng tôi muốn xem những gì có thể được thực hiện với bộ xử lý trước 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}

Biên dịch (có cảnh báo, nếu bạn bật chúng) gcc -std=c89 -ansivà hoạt động nhưcat file | ./a.out

Điều này đã bị phá vỡ nhanh hơn nhiều so với tôi nghĩ, xin chúc mừng! Chiến lược của tôi là sử dụng #definesđể xóa các ranh giới mã thông báo rõ ràng (như ';') và sau đó sử dụng nhiều hơn #definesđể làm cho nó THỰC SỰ không trực quan về cách chúng bị xáo trộn xung quanh.

Nhân tiện, đây là mã trông như thế nào chỉ sau khoảng trắng rõ ràng đã được thêm vào:

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

Octave, 69 byte, AN TOÀN!

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

Định dạng đầu vào: Dòng mới không thể được nhập trực tiếp vào dấu nhắc lệnh. Tạo chuỗi bằng cách ghép như thế này:

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

Gọi hàm như thế này (thêm khoảng trắng):

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

Mã gốc:

Bạn chỉ cần 66 byte để làm việc này, nhưng tôi đã viết 69 trong tiêu đề để không cung cấp quá nhiều thông tin.

Mã ban đầu trông như thế này:

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

Giải trình:

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

Ulà điểm mã 85trong bảng ASCII, vì vậy nó sẽ xuất hiện như không gian đầu tiên nên sau 85. Sai lầm!

Nếu chúng ta chèn khoảng trắng sau 853đó, chúng ta sẽ nhận được số ký tự 853, phải không ..? Sử dụng charđể kiểm tra xem đó có phải là một ký tự dễ nhận biết không:

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

Tuy nhiên, chúng tôi không sử dụng charmã, chúng tôi sử dụng phiên bản ngắn hơn để ghép các số với một chuỗi trống [853 '']. Thay vì đưa ra một lỗi ngoài phạm vi, phiên bản ngắn hơn chỉ đơn giản là lấy mô-đun số 256.

Nó chỉ xảy ra như vậy 85+3*256 = 853. Trong khi char(853)đưa ra một cảnh báo, [853,'']trả lại U.

Cách rõ ràng để thực hiện nhiệm vụ này trong Octave là:

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

Chúng tôi biết rằng phải có dấu ngoặc đơn mở (mã điểm 40) sau lần đầu tiên U. 29rõ ràng là không phù hợp vì vậy chúng tôi thay đổi không gian một bên phải và nhận được 296. mod(296,256) = 40. Chơi lô tô!

Tiếp tục như thế này và kết thúc với chuỗi:

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

Cuối cùng, chúng tôi sử dụng evalđể biến chuỗi thành mã.

JavaScript ES6, 199 byte, bị bẻ khóa bởi SLuck49

Một mục khá cồng kềnh với 33 byte khoảng trắng cần thêm.

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

> <>, 40 byte, bị bẻ khóa bởi bồ nông Teal

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

Nhân tiện, tôi đã sử dụng fishl Language.com , chỉ trong trường hợp có sự khác biệt giữa các phiên dịch viên.

Befunge-93, 58 byte, An toàn!

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

Hãy thử trực tuyến!

Chương trình gốc

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

Hãy thử trực tuyến!

Thủ thuật cho điều này là đường dẫn thực thi theo chiều dọc hơn chiều ngang, sau đó các không gian khác nhau được chèn ngẫu nhiên trong mã để tiếp tục xáo trộn các đường dẫn dọc. Khi ngắt dòng và khoảng trắng cuối cùng đã được xóa, hy vọng sau đó rất ít để chỉ ra các hoạt động liên quan đến nhau như thế nào.

Trong trường hợp điều đó không đủ khó, tôi cũng đã ném vào một chút xen kẽ, do đó, một số hoạt động cuối cùng được thực hiện bởi các đường dẫn mã khác nhau chảy vuông góc với nhau. Ý tưởng là nếu bạn nghĩ rằng bạn đã tìm đúng vị trí cho một lệnh cụ thể, bạn sẽ không nhận ra rằng bạn có thể cần phải sử dụng lại nó sau này trong mã.

Không chắc liệu nó có xứng đáng với tất cả những nỗ lực cố gắng làm cho mọi thứ trở nên phức tạp hay không, hoặc mọi người thậm chí không buồn cố gắng giải quyết nó. :)

Giải thích mã

_      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 byte, bị bẻ khóa bởi Link Ng

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

184 byte bị sụp đổ, để lại cho bạn 17 byte khoảng trắng.

Giải pháp bẻ khóa bằng cách sử dụng Concattrong khi giải pháp dự định của tôi đã sử dụng Join, đây là giải pháp dự định:

_=>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 byte. Nứt và nứt .

Đây là một chương trình nhận đầu vào thông qua STDIN và tạo đầu ra thông qua STDOUT.

Mã không có dấu cách hoặc dòng mới:

t'@*'dm1e5%Mdw%Y(

Các định dạng đầu vào là một chút lúng túng vì cách MATL mất chuỗi đầu vào. Các chuỗi có dòng mới không thể được nhập trực tiếp qua STDIN, vì mỗi đầu vào phải là một dòng duy nhất (dòng mới đánh dấu sự kết thúc của đầu vào). Vì vậy, định dạng như sau:

1. Một chuỗi được đính kèm với dấu ngoặc đơn . Nếu nội dung chuỗi bao gồm các trích dẫn đơn, chúng được thoát bằng cách nhân đôi . Thí dụ:'I''m a string'

2. Để nhập một chuỗi có dòng mới, người ta cần tách chuỗi ở dòng mới và nối tất cả mọi thứ (bằng dấu ngoặc vuông), bao gồm các số dưới dạng mã ASCII . Ví dụ, hãy xem xét chuỗi được hình thành bởi tên và họ của tôi với một dòng mới ở giữa. Nó sẽ được nhập vào như ['Luis' 10 'Mendo'].

   Điều này cho phép nhập bất kỳ mã ASCII nào khác (có thể không in được). Vì vậy, chuỗi trong mục 1 ở trên có thể được nhập thay thế là ['I' 39 'm ' 97 32 'string']. Kiểm tra nó ở đây .

   Điều kiện duy nhất là ít nhất một trong các phần trong ngoặc là một chuỗi. Điều đó buộc bất kỳ số nào được hiểu là mã ASCII khi nối.

Xin lỗi về sự may mắn vụng về sử dụng định dạng này!

Giải pháp ban đầu

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

Mỗi cái %là một biểu tượng bình luận, và vì vậy phần còn lại của dòng bị bỏ qua.

Spaces không làm gì cả, nhưng đóng vai trò là dải phân cách. Ví dụ, 1e5không có khoảng trắng, sẽ được hiểu là số 100000.

t lấy đầu vào và nhân đôi nó.

' @ *'đẩy chuỗi đó và dtính toán sự khác biệt liên tiếp của nó, điều này mang lại [32 -32 10](cái -32vô dụng).

mđưa ra một mảng hàng logic cho biết các ký tự 32hoặc 10(hoặc -32).

1tiếp theo là eđịnh hình lại như một hàng. Đây là không-op ở đây.

5tiếp theo là Mđẩy 1một lần nữa (đầu vào cuối cùng cho chức năng nhiều đầu vào gần đây nhất, đó làe ).

dtính toán các khác nhau liên tiếp 1và do đó cho [](mảng trống).

whoán đổi và cuối cùng (gán []cho các ký tự khoảng trắng, nghĩa là loại bỏ chúng.

RProgN , 15 byte bị bẻ khóa !

''`R""`R

Bạn có thể chơi đồ chơi với mã ở đây . Một giải pháp tương đối đơn giản, hy vọng bản chất khó chịu của cách RProgN xử lý các chuỗi sẽ không bị bẻ khóa này.

Chương trình gốc

' ' ` R
"
" ` R

Giải thích

Đầu tiên, đầu vào được ngầm đẩy vào ngăn xếp. Cây rơm:<INPUT>

Sau đó, chúng tôi sử dụng '' để đẩy một khoảng trắng vào ngăn xếp. Cây rơm:<INPUT> " "

`thực sự cố gắng đẩy một chuỗi được biểu thị bởi` (WORD) nhưng vì có khoảng trắng sau nó, nên nó chỉ đẩy một chuỗi rỗng. Cây rơm:<INPUT> " " ""

R ở đây là đường cho lệnh Thay thế. Cây rơm:<INPUTWITHOUTSPACES>

Tiếp theo, "NEWLINE" đẩy một chuỗi chứa một dòng mới, điều này thật tuyệt vì RProgN không sử dụng lối thoát, nó chỉ cần thẳng lên cho phép bạn đẩy một chuỗi như thế. Cây rơm<INPUTWOSPACES> "\n"

Sau đó, chúng tôi sử dụng lại `trick và Thay thế, cho đầu ra của chúng tôi.

Ruby, 86 byte + 1 cờ = 87 ( bị bẻ khóa bởi Dom Hastings )

Yêu cầu cờ dòng lệnh -p.

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

Mã này thực sự hợp lệ trong hình thức này, nó chỉ là không có.

Chùm , 72 byte, An toàn!

Bây giờ cho một ngôn ngữ 2d. Có thể chơi trên TIO Nexus .

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

Một chương trình khá thẳng về phía trước mà không có nhiều trong đó để thử và đánh lừa mọi người.

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

Mê cung , 127 byte

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

Hy vọng tôi đã làm đúng :) đây là lần đầu tiên cảnh sát và tên cướp của tôi.

Mã gốc

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

Java, 3241 + 28 Byte cho nhập số nguyên lớn

Mục nhập này chỉ để chứng minh khả năng của một mục nhập hoàn toàn an toàn về mật mã. Tôi tin rằng điều này nằm trong quy tắc, nhưng nếu nó trái với tinh thần, xin vui lòng cho tôi biết và tôi sẽ xóa bỏ sự công bằng. Tôi sẽ để lại "không an toàn" này vô thời hạn cho đến thời điểm như vậy khi (và nếu) một vết nứt được tìm thấy. Đây là một điều quái dị và chắc chắn có thể được tối ưu hóa hơn nữa, nhưng đây là.

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

Không công bằng cho những tên cướp, đây là tất cả các khoảng trắng "rõ ràng" được thêm vào.

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

Chúc may mắn, tôi rất thích nhìn thấy điều này bị nứt. Trong thực tế, tôi thậm chí sẽ tạo ra một tiền thưởng không giới hạn về điều này. Nếu tại bất kỳ thời điểm nào bạn thực hiện việc này, bạn sẽ được thưởng 500 điểm thưởng vô hạn trong trao đổi ngăn xếp (cũng có thể là một bài báo toán học tuyệt vời).

C, 140 byte, bị bẻ khóa bởi Riley

Hãy bắt đầu với một điều dễ dàng.

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

(Tôi hy vọng tôi đang làm điều này đúng.)

Befunge 98, 65 byte, bị bẻ khóa bởi Pietu1998

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

Chương trình gốc

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

V , 37 byte Được bẻ khóa bởi nmjcman101

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

Vì điều này không thể in được, đây là phiên bản có thể đọc được:

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

Hoặc nếu bạn thích, một 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 byte, đã bị bẻ khóa !

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

Hãy thử trực tuyến!

JavaScript ES6, 380 byte, an toàn

Đây là loại mục mà ban đầu tôi dự định phát hành. Nó rất lớn và gần như không có cơ hội chiến thắng, nhưng tôi nghĩ nó phải đủ mạnh về mặt mật mã để chịu đựng được 7 ngày. Bây giờ, tôi có thể được chứng minh là sai!

67 byte khoảng trắng để thêm.

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

Giải pháp

Đây là một triển khai của Thuật toán mã hóa Tiny mở rộng . Khóa được mã hóa khoảng trắng 64 bit mở rộng thành khóa 128 bit sau:

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

Nguồn: Wikipedia

Sau khi được giải mã và chuyển đổi thành ASCII, khối 64 bit sẽ [x, y]đọc là c3BsaXQ=đại diện được mã hóa Base64 của 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 byte, an toàn

Điều này là hết sức xấu xa.

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

Chúc may mắn! 13 mục của khoảng trắng để thêm.

Mã gốc:

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

Hãy thử trực tuyến!

Điều này gần như đơn giản hóa xuống:

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

C #, 159 byte, Bị nứt bởi sữa

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

153 đã sụp đổ để chỉ có 6 byte khoảng trắng cần tìm, không nên quá khó ...

mặt lưới, 43 byte, bị nứt

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

Phiên bản trên TIO đã lỗi thời, nhưng bạn có thể lấy cho mình một bản sao từ github .

Sói, 132

Có lẽ có nhiều hơn một giải pháp (gợi ý: Mersenne)

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

Giải pháp

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

Khoảng trắng , 81 74 byte

Phiên bản có thể đọc được của con người:

ttttttttttttttttttttt (21 tab characters)

Tôi biết đây là một thách thức cũ nhưng hy vọng ai đó sẵn sàng phá vỡ điều này. Tôi đã cố gắng tối ưu hóa cho bytecount nhưng có thể làm cho một cái gì đó ngắn hơn với cùng số lượng ký tự tab.

tcc, 850 byte

Để tránh dán một dòng rất dài, tôi đã chuyển qua tr -d '\ n' | gấp -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 byte An toàn!

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

Nên khá tầm thường. Đây là cảnh sát và tên cướp đầu tiên của tôi.

Không ai tấn công nó, có lẽ là do bản chất bí truyền của ngôn ngữ của tôi. Có vẻ như một cách nhếch nhác để trượt qua, nhưng nó không thực sự quan trọng vì những cái ngắn hơn là an toàn.

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

Hãy thử trực tuyến