Chủ đề của tên cướp ở đây

Nhiệm vụ cảnh sát là viết một hàm hoặc chương trình, khi được cung cấp một đầu vào của chính nó, đưa ra một chuỗi xác định hữu hạn. Nếu chương trình được cung cấp một đầu vào khác, nó sẽ trả về một đầu ra khác.

Quy tắc:

• Đệ trình bao gồm
  • Tên ngôn ngữ
    • Nếu bất kỳ cờ được sử dụng, chúng nên được tiết lộ.
  • Số byte của chương trình
  • Số lượng byte đầu ra
  • Đầu ra
    • Nếu nó đặc biệt dài, vui lòng cung cấp một pastebin hoặc một cái gì đó tương tự
    • Nếu nó chứa không thể in được, vui lòng cung cấp hexdump.
    • Trailing newlines và khoảng trắng nên được bao gồm trong đầu ra
  • Nơi đầu vào đến từ (STDIN, dòng lệnh, v.v. )
• Nếu có thể, bạn có thể giả sử rằng byte đại diện cho EOF không có trong đầu vào, trừ khi bạn sử dụng byte đó trong chương trình của mình.
• Nếu chương trình của bạn bị bẻ khóa, hãy thêm một liên kết đến câu trả lời tương ứng trong chuỗi của tên cướp trong tiêu đề của bạn.
• Chương trình của bạn không an toàn cho đến khi một tuần trôi qua và bạn đánh dấu nó như vậy.
• Tôi không chấp nhận các kỹ thuật như gieo hạt ngẫu nhiên với các hàm băm đầu vào hoặc mật mã. Tôi không thể ngăn chặn họ, nhưng tôi sẽ không chấp nhận một giải pháp sử dụng một trong hai giải pháp này . Cũng lưu ý rằng một số kỹ thuật này có thể có va chạm, trong đó một chuỗi khác nhau tạo ra cùng một đầu ra.
• Mục tiêu của bạn là có đầu ra ngắn nhất. Giải pháp an toàn ngắn nhất được đăng trong vòng ba tuần sau khi đăng câu hỏi này sẽ thắng!

Nhiệm vụ của tên cướp là tìm ra một chương trình có kích thước bằng hoặc nhỏ hơn bản gốc, cũng tuân theo các quy tắc trên.

Nếu một tên cướp phá vỡ chương trình của bạn bằng một giải pháp khác so với dự định, thì bạn có cơ hội 'giải mã' nó bằng cách chứng minh rằng giải pháp của tên cướp là không chính xác. Bạn có thể làm điều này bằng cách tìm một đầu vào cho chương trình của tên cướp sẽ tạo ra cùng một đầu ra.

Gửi ví dụ:

brainfuck, 10 byte, Điểm: 10

]<.[<],>[,

Giải pháp này là , [>,] <[. <] Đơn giản là đảo ngược đầu vào

Chúc may mắn!

7 , 31 ký tự, điểm 30, an toàn nhưng có thể bị hỏng?

Một chương trình 7 thường chỉ là một số, nhưng nó có thể chứa khoảng trắng, chia nó thành nhiều số. Do đó, đệ trình này bao gồm hai số (được kết nối ngầm bởi 7 trình thông dịch) và chương trình cũng lấy hai số làm đầu vào, thông qua đầu vào tiêu chuẩn. ("31 ký tự" trong tiêu đề là tổng độ dài của hai số, cộng với một ký tự khoảng trắng phân tách; các chữ số tạo thành các số được hiểu là bát phân khi được sử dụng làm chương trình, nhưng thập phân khi được sử dụng làm đầu vào và Đó là các chữ số giống nhau trong hai trường hợp, không phải là số thực. Lưu ý rằng nó không liên quan khi được coi là chương trình hoặc khi được coi là đầu vào, cho dù bạn tách chúng bằng dấu cách hoặc dòng mới; Tôi hy vọng điều đó không 'không hợp lệ trình.)

Đầu ra dự kiến ​​là số sau (được biểu thị ở đây bằng số thập phân, vì đó là định dạng đầu ra mà 7 trình thông dịch sử dụng):

238363505302130098723162537059

Lưu ý rằng 7 trình thông dịch được liên kết từ wiki Esolang lưu trữ các số một cách đơn nhất, có nghĩa là bạn không có đủ bộ nhớ để thực sự chạy chương trình trên chính nó để xem những gì nó làm. Tôi đã xác minh chương trình thông qua việc xử lý hành vi của nó một cách thủ công và thử nghiệm nó trên các đầu vào nhỏ để xác minh rằng nó đã làm những gì tôi mong đợi. Một cách tiếp cận khác là viết một trình thông dịch sử dụng phương pháp lưu trữ số hiệu quả hơn.

Tránh các vết nứt ở đây là một điều khó khăn, nhưng cuối cùng tôi cũng hài lòng rằng không có hai số nào ngoài số đó trong chính chương trình có khả năng tạo ra 238363505302130098723162537059 làm đầu ra. ( EDIT 1 tuần sau: Tôi có thể đã sai, tùy thuộc vào cách bạn diễn giải câu hỏi; xem bên dưới. )

Giải pháp

Chương trình ban đầu là:

71170237403706
111723603700633

Chương trình này lấy hai số $x$ và $y$ và tính kết quả của biểu thức $3xy-y-2$ (tức là $y(3x-1)-2$ ). Nếu chúng tôi thực hiện phép tính này tại $x=711170237403706$ và $y=111723603700633$ , chúng tôi nhận được kết quả $238363505302130098723162537059$ theo yêu cầu .

Dự định rằng không có đầu vào nào khác sẽ cho kết quả mong muốn vì:

Đầu vào phải được chọn sao cho $y(3x-1)-2=238363505302130098723162537059$ , tức là $y(3x-1)=238363505302130098723162537061$ (thêm 2 vào cả hai bên). Con số này là một nửa năm, chỉ có hai yếu tố: $111723603700633$ và $2133510712211117$ . Chỉ một trong những số này, $2133510712211117$ , có thể được biểu thị dưới dạng $3x-1$ (cho $(3 \times 711170237403706)-1=2133510712211117$ ). Vì vậy, chúng ta có thể xác định duy nhất số nào là$x$ và số nào là$y$ , nghĩa là chỉ có một đầu vào hoạt động.

Tuy nhiên, tùy thuộc vào cách bạn diễn giải câu hỏi, có thể có đầu vào thứ hai tạo ra đầu ra mong muốn (do đó làm mất hiệu lực giải pháp này):

Thật không may, có hai phân vùng nhân của một nửa số thành hai yếu tố: một là chia nó thành hai yếu tố chính, nhưng hai là phân vùng tầm thường bao gồm $1$ và chính số đó. $1$ không thể được viết dưới dạng $3x-1$ với số nguyên $x$ , nhưng đầu ra mong muốn có thể là; do đó, một meta-crack tiềm năng liên quan đến việc cung cấp đầu vào là $79454501767376699574387512354$ và $1$ . Tuy nhiên, số đầu tiên ở đây liên quan đến các ký tự ( $8$ và $9$) không có trong bộ ký tự cho 7 chương trình. Vì vậy, nếu đầu vào bị hạn chế ở cùng một bộ ký tự với chương trình, giải pháp này là hợp lệ; nhưng nếu đầu vào chứa các ký tự từ bên ngoài bộ ký tự của chương trình được cho phép, giải pháp này không hợp lệ.

Giải trình

Đây là cách các chức năng giải pháp dự định:

711170237403706 111723603700633
7 7 7 Ngăn cách phần tử ngăn xếp
 111 023 403706 111723603700633 Các phần tử ngăn xếp ban đầu
 111 Số 3, đơn phương
     023 DSL I / O cho "nhập số"
         403706 111723603700633 Chương trình chính
(Ngụ ý: thực hiện một bản sao của phần tử chương trình chính, giữ nguyên bản gốc)
         40 Hoán đổi {023} trên {chương trình}, thoát khỏi nó
           3 Làm I / O bằng {023}; pop {chương trình}
     0 I / O: số
      23 Nhập một số, sao chép {111} nhiều lần
            706 Nối "6" vào số (giảm dần)
                11 Đẩy hai phần tử ngăn xếp trống
                  17236 Đẩy phần tử ngăn xếp "23" (không thoát)
                       0 Escape {23}, tiêu thụ một phần tử trống
                        3 Làm I / O bằng {23}; pop {phần tử bên dưới}
                    23 Sao chép đỉnh đầu vào ngăn xếp nhiều lần
                         7006 Nối "66" (tức là trừ 2)
                             3 Kết quả {dưới dạng số}
                              3 Thoát khỏi chương trình (do ngăn xếp thấp)

17066612345$3$$123451234512345$

V10.9.0 Node.js , 40 byte, Hệ số: 40, Cracked

Đầu vào

Đây là một hàm lấy chính xác một tham số.

Đầu ra

&`nij.9=j.,)r31n=+(=ooj`[o.o.)1.s](>=6>t

Cây lê , 46 byte ASCII, điểm 0, Cracked

Đầu vào được lấy từ đầu vào tiêu chuẩn. Đầu ra dự kiến ​​(trên đầu ra tiêu chuẩn) là một chuỗi trống (nghĩa là khi chương trình được đưa ra làm đối số, không nên in ra đầu ra).

Nói cách khác, thách thức ở đây là viết chương trình A Pear Tree không xuất ra bất cứ thứ gì trên đầu ra tiêu chuẩn khi được cung cấp trên đầu vào tiêu chuẩn và đầu ra một cái gì đó trên đầu ra tiêu chuẩn khi được cung cấp một thứ khác ngoài đầu vào tiêu chuẩn, không sử dụng hơn 46 byte. (Tôi cũng đã quản lý để làm điều này trong khi giữ chương trình thành ASCII có thể in được, mặc dù A Pear Tree thường xuyên sử dụng các ký tự không phải ASCII và không thể in được.) Đây thực sự là nhiệm vụ viết chương trình tự nhận dạng , với định dạng đầu ra cụ thể (tức là chuỗi null khi tự nhận dạng thành công); tuy nhiên, Cây lê có ít nhất hai vòng xoắn khiến cho nhiệm vụ trở nên khó khăn hơn so với khi thực hiện bằng ngôn ngữ cụ thể này (đó là lý do tại sao tôi chọn nó cho trình cảnh sát của mình).

Giải pháp của tôi

Giải pháp của tôi hơi khác so với crack:

eval(k=q(print$\=$_="eval(k=q($k))"ne$_;MZpa))

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

Thay vì sử dụng exit, thay vào đó tôi đặt $_(đầu ra ngầm định) và $\(dòng mới sau đầu ra, bao gồm cả đầu ra ẩn) thành chuỗi null nếu có kết quả khớp (và 1nếu không có kết quả khớp). A printvẫn được yêu cầu vì đầu ra ngầm định chỉ được bật nếu có ít nhất một byte đầu vào (do đó, chúng tôi cần in rõ ràng một cái gì đó nếu chúng tôi cung cấp một chuỗi trống làm đầu vào, khác với chương trình).

Mỗi chương trình Cây lê cần có một tổng kiểm tra ở đâu đó (đó là MZpagiải pháp này). Cả giải pháp của tôi và tên biến chọn crack (và thay đổi các chi tiết nhỏ khác của mã) để làm cho tổng kiểm tra hoàn toàn bao gồm các chữ cái ASCII.

Perl 5 -p0777, 10 byte, điểm 10, an toàn

W)9r46<(k

Ký tự cuối cùng ở đây là "shift out", mã ký tự 14 (thập phân) / 0E (hex). Tất cả những cái khác đều có thể in ASCII.

Bởi vì chúng tôi đang sử dụng đối số I / O ẩn của Perl -p0777, đầu vào đến từ đầu vào tiêu chuẩn và đầu ra sẽ chuyển sang đầu ra tiêu chuẩn.

Giải pháp

Chương trình thực hiện như sau:

NUL-pad đầu vào tối thiểu 10 ký tự, sau đó XOR với chuỗi svgOUT_TOP

có nghĩa là chính chương trình, đầu vào duy nhất tạo ra đầu ra mong muốn, là:

$ _ ^ = abc | $ ^

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

Giải trình

Perl có một số biến mục đích đặc biệt. Ví dụ, khi sử dụng -p0777cho I / O ẩn, $_là đầu vào khi bắt đầu chương trình và đầu ra ở cuối chương trình.

Hầu hết các biến này có giá trị mặc định rất đơn giản. Tuy nhiên, giá trị mặc định của $^, định dạng trên cùng của trang hiện đang được chọn, là chuỗi dài hơn nhiều STDOUT_TOP. Như vậy, chúng ta có thể sử dụng phương pháp này như một phương pháp che giấu rất ngắn gọn thông qua XORing $^với giá trị mà chúng ta muốn che giấu (trong trường hợp này là chương trình).

Để che giấu phần _TOPcuối của câu chuyện, tôi đã tự đệm chương trình lên tới 10 ký tự bằng cách thêm vào một abc|, có nghĩa là tất cả các ký tự STDOUT_TOPsẽ được XOR với một cái gì đó; sự lựa chọn abc|khi bắt đầu là một cách dễ dàng để giữ đầu ra hầu như có thể in được (và làm cho khó phát hiện ra rằng tôi đang XORing với một chuỗi được làm chủ yếu bằng chữ in hoa, bởi vì trong ASCII, chữ thường XOR viết thường là chữ thường).

Python 3, 50 byte bị bẻ khóa

Đầu vào và đầu ra từ / đến stdin / -out. Đầu ra là khác nhau cho mỗi đầu vào khác nhau. Đầu ra duy nhất khi được cung cấp mã nguồn:

218216195196222130136136132192197195196130241204136209197216206130201131244155157154215136138204197216138201138195196138195196218223222130131247131131

(Đó là 150 chữ số)

Chúc may mắn!

05AB1E , 35 byte, Điểm: 7

Đầu vào:
Từstdin

Đầu ra:
QÕ Ƿe

Cubix , 18 byte, Điểm 18, an toàn

Thật xấu hổ khi thử thách này không được chú ý nhiều hơn, nhưng đôi khi nó diễn ra như vậy. Tôi sẽ để lại điều này không an toàn, nhưng quyết định đăng giải pháp trước khi tôi quên nó.

Điều này nên khá dễ dàng để crack.

Đầu vào từstdin

Đầu ra

$`*2aJPJ#74(o);89

Chỉnh sửa: Tôi nên đề cập rằng điều này mong đợi nguồn ở dạng rút ngắn ... và bây giờ tôi nhận thấy rằng có một byte bị thiếu (không thể in được) từ kết quả mà tôi đã phá vỡ khi tôi đăng. Nên sao chép ra ngay. Các giá trị hex là24 60 2a 13 32 61 4a 50 4a 23 37 34 28 6f 29 3b 38 39

Khái niệm này là loại bỏ in ký tự đầu tiên và sau đó xóa chỉ mục nghịch đảo khỏi ký tự, ví dụ [chars] - [0, len ([chars]) .. 2]

Mã là

$r;#AoW\U-@</u.?;;

ánh xạ vào khối sau

    $ r
    ; #
A o W \ U - @ <
/ u . ? ; ; . .
    . .
    . .

Hãy thử nó ở đây

Jelly , 14 byte, Điểm: 21, An toàn

Cả chương trình và kích thước đầu ra đều được tính bằng Jelly codepage.

Đầu vào

Đối số dòng lệnh đầu tiên.

Đầu ra

-§ḋẇ"*YdĖDƘ>Ẉed€Ç+æạɦ

Giải pháp

ØJiⱮÄÆNPḃØ⁵ịØJ

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

JavaScript Firefox, <10 byte, Điểm: 52, từ đầu vào đối số chức năng, Đã bẻ khóa

ZnVuY3Rpb24gYnRvYSgpIHsKICAgIFtuYXRpdmUgY29kZV0KfQ==


btoa

btoa(btoa) mã hóa chuỗi sau:

function btoa() {
    [native code]
}

cung cấp cho:

"ZnVuY3Rpb24gYnRvYSgpIHsKICAgIFtuYXRpdmUgY29kZV0KfQ=="

_{vừa sao chép}

GCC 61-> 61 byte

70 4F 92 73 08 D4 03 E7 65 DC D6 89 B5 AD BA 90 
97 26 31 10 F6 FA 0A 30 8F 24 69 0A A7 8B 59 9E 
A2 42 D5 67 B8 12 3A 1E 9D 25 80 F9 6B 25 32 C2 
EE 46 3F 8D 7E 0C 73 0F F0 93 C6 68 50

Chương trình đầy đủ, lấy đầu vào từ stdin và đầu ra cho thiết bị xuất chuẩn

Perl 6, 43 byte, Điểm: 15, từ stdin

49671296789805

Pepe , 23 byte, điểm: 23, bị bẻ khóa bởi MickyT

Đầu vào:

Tiêu chuẩn

Đầu ra:

RDCbn@?K]<[G98765TSR^PO

J , 26 byte, Điểm: 52, An toàn

Chương trình không phải là REPL, mà là một kịch bản đầy đủ chấp nhận stdinvà in rõ ràng stdout.

Đầu vào

Đầu vào tiêu chuẩn.

Đầu ra

6fc42353c98217ef5a2908a3c63d090aa9a55b2558b61294e06a

Không, nó không phải là một phương thức mã hóa.

Giải pháp

echo]hfd]257x#.3&u:stdin''
                   stdin'' Take the whole input
               3&u:        Convert to codepoints
         257x#.     Convert base 257 to integer
     hfd]           "Hex from Decimal"
echo]               Print to stdout

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

Keg , 6 byte, Điểm: 6

Đầu vào

Từ stdin, sử dụng?

Đầu ra

5\x1c"\x1c"9

Xin lưu ý rằng đó là các chuỗi thoát cho các byte không thể in được. Thay thế các lối thoát bằng các ký tự theo nghĩa đen. Văn bản thô có sẵn ở đây

Chúc may mắn với điều này! Hẹn gặp lại vào tuần tới!

 Perl 6, 31 byte, Điểm: 39, từ stdin - Cracked

Nứt ở đây

().1111111111112222235abcegijkmnorstvy

Giải pháp thô. Có thể sống sót.