Đây là một cảnh sát và kẻ cướp thách thức Chủ đề của tên cướp có thể được tìm thấy ở đây

Thách thức của bạn là viết một chương trình tạo ra đảo chữ cái của mã nguồn chứ không phải chính mã nguồn gốc.

Ví dụ chương trình Python sau,

print`'print*2``'*2`

in

'print*2``print*2``'

trong đó có tất cả các ký tự giống như nguồn ban đầu của nó nhưng theo một thứ tự khác.

Một khi bạn đã tìm thấy một chương trình như vậy, bao gồm đầu ra của chương trình như một câu trả lời bỏ qua chương trình tạo ra nó. Như bạn có thể đoán, những tên cướp sẽ tìm cách khám phá chương trình bạn đã ẩn hoặc bất kỳ chương trình nào phù hợp với thông số kỹ thuật. Mục tiêu của bạn là làm cho chương trình ngắn nhất mà bọn cướp không thể bẻ khóa.

Quy tắc

• Như với hầu hết các thử thách của cảnh sát và tên cướp , nếu câu trả lời của bạn không bị bẻ khóa trong một tuần, bạn có thể thêm giải pháp dự định vào câu trả lời của mình và đánh dấu là An toàn . Một khi an toàn, một câu trả lời không thể bị bẻ khóa bởi những tên cướp.

• Bạn không cần bao gồm ngôn ngữ của giải pháp dự định, tuy nhiên nếu bạn không bao gồm những kẻ cướp ngôn ngữ có thể bẻ khóa nó bằng bất kỳ ngôn ngữ nào trước thách thức, trong khi nếu bạn chỉ định ngôn ngữ thì chúng chỉ có thể bẻ khóa nó trong ngôn ngữ được cung cấp.

• Quy tắc tiêu chuẩn cho Quines áp dụng.

Brain-Flak , 231 byte bị bẻ khóa bởi Wizard Wizard

}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{][][][][][][][)()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(

Chương trình ban đầu sử dụng -Ađối số.

Dưới đây là số lượng:

( -> 74
) -> 74
{ -> 34
} -> 34
[ -> 7
] -> 7

Python 2, 96 byte, bị bẻ khóa bởi math_junkie

Đầu ra:

B97.off]xo) wnd[ri0'of{r1({r6-{r{rri) {r1(xo0'sjD;0'0'qhF=1({r{r2)4+}twnri2)wnlcof) yp) ) xomd2)

Lần đầu chơi golf mã! Hy vọng nó không quá dễ dàng.

Haskell, 107 byte, bị bẻ khóa bởi nimi

"$$$$'''''''',,----....::<<<<<<<<========>>>>[[[[[[[[]]]]]]]]aaddddddddddddiiiiiiiiiiiimmnnnnpprrtt||||||"

Có một dòng mới bổ sung.

Giải pháp ban đầu:

main=print$id=<<[[id|i<-"main=print$id=<<[[id|i<-,i==d]>>d:[d]|d<-['$'..'|']]",i==d]>>d:[d]|d<-['$'..'|']]

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

Ý tưởng chính của tôi là viết một quine sắp xếp mã nguồn riêng trước khi xuất nó mà không sử dụng sortchức năng thư viện . Chỉ sau một lần bẻ khóa ban đầu bằng nimi , mã chương trình có thể được sắp xếp theo cách thủ công, mã hóa cứng vào chương trình và sau đó được in ra trong khi nhân đôi mỗi chữ cái. Tuy nhiên, các ký tự có sẵn hạn chế làm cho cách tiếp cận này trở nên cồng kềnh hơn và việc bẻ khóa thành công của nimi khá giống với chương trình ban đầu của tôi.

Giải trình:

main=print$                                      -- full program which prints the following string
  id=<<[[id|i<-"...",i==d]>>d:[d]|d<-['$'..'|']]
                                 |d<-['$'..'|']  -- for each char d in "$%&'()*+,-./012 ... xyz{|"
        [id|i<-"...",i==d]                       -- build a list with as many elements as d is contained in the string
                          >>d:[d]                -- replicate the string "dd" as often as the previous list is long 
  id=<<[                                       ] -- concatenate the resulting list of srings to one single string

Ngôn ngữ không xác định, 124 byte,

Trong chủ đề câu trả lời của DJMcMayhem, đây là 32 ký tự ASCII đầu tiên (ngoài 0x00) được in bốn lần mỗi ký tự. Vì không ai trong số này có thể nhìn thấy, tôi đã không bao gồm mã thực tế trong câu trả lời của mình.

Đây là hexdump:

00000000: 0101 0101 0202 0202 0303 0303 0404 0404  ................
00000010: 0505 0505 0606 0606 0707 0707 0808 0808  ................
00000020: 0909 0909 0a0a 0a0a 0b0b 0b0b 0c0c 0c0c  ................
00000030: 0d0d 0d0d 0e0e 0e0e 0f0f 0f0f 1010 1010  ................
00000040: 1111 1111 1212 1212 1313 1313 1414 1414  ................
00000050: 1515 1515 1616 1616 1717 1717 1818 1818  ................
00000060: 1919 1919 1a1a 1a1a 1b1b 1b1b 1c1c 1c1c  ................
00000070: 1d1d 1d1d 1e1e 1e1e 1f1f 1f1f            ............

Tuy nhiên, đây là một số Python in nó (và một dòng mới) nếu bạn muốn:

print"".join(chr(x)*4for x in range(1,32))

Pyth , 32 byte, bị bẻ khóa bởi math_junkie

J+J=JJ 1-2#pTN%"J+J=JJ 1-2#pTN%"

Giải pháp ban đầu

J2#p+"J+J=JJ 1-2#pTN%"N=J-J1 %TJ

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

J2                               # Assign 2 to the variable J
  #                              # Infinite loop, break on error
    +"J+J=JJ 1-2#pTN%"N          # appending a '"' to the string 'J+J=JJ 1-2#pTN%'
   p                             # print the string above
                       =J-J1     # subtract 1 from J and assign back to J
                             %TJ # calculated 10%J, with a blank space before to supress output,
                                 # on the 3rd iteration this will be 10%0 that will generate an
                                 # erro and will break out the loop

CJam, 46 byte, bị bẻ khóa bởi math_junkie

3658:93]93]]]95_959599c101101$::]]]]]]____ccee

V , 21 byte (An toàn!)

"&./124ipq|ÍÓÚîñòÿ

Lưu ý các dòng mới hàng đầu.

Vì cái này chứa những thứ không thể in được, nên đây là một hexdump:

00000000: 0a16 1b22 262e 2f31 3234 6970 717c cdd3  ..."&./124ipq|..
00000010: daee f1f2 ff                             .....

Để giúp mọi người hiểu, đây là một liên kết đến tiêu chuẩn V mở rộng tiêu chuẩn

Đây là phiên bản gốc:

ñi241"qp|Ó./ò&
ÚÍîÿ

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

Phiên bản dễ đọc là:

ñi<C-v>241<esc>"qp|Ó./ò&
ÚÍîÿ

Cách thức hoạt động của nó là bằng cách nhúng sắp xếp vào quine mở rộng mặc định. Khi tôi đang nghĩ về V-quines vì ​​câu trả lời này, tôi nhận ra rằng quine mở rộng tiêu chuẩn có thể được rút ngắn bằng ba byte, vì vậy giải pháp này có thể là:

ñiéÑ~"qp|Ó./ò&
ÚÍîÿ

Giải trình:

ñi<C-v>241<esc>"qp  " Standard V-quine. Everything after this is recorded into register 'q'
                    " so we can do whatever we want without ruining it's "quine-ness"


|       " Go the first character on the line (I just realized now that this is pointless)
 Ó./ò&  " Put every character on a newline
Ú       " Sort every line
 Íî     " Join all lines together
   ÿ    " Necessary for V-quines

Ngôn ngữ không xác định, 254 byte Được bẻ khóa bởi @Dennis!

Tôi nghi ngờ điều này sẽ giành chiến thắng vì sự ngắn gọn, nhưng nó sẽ là một nỗi đau để phá vỡ, vì vậy nó vẫn đáng để thực hiện.

Do một lỗi, thứ tự 0x0b, 0x0c, 0x0acó một chút lẫn lộn, nhưng đây chắc chắn là đầu ra thực sự.

Tôi hình dung tôi sẽ không chỉ định ngôn ngữ để tôi có thể thấy những ngôn ngữ khác nhau có thể có. Vì đầu ra chủ yếu không phải là ASCII, đây là một kết quả của đầu ra:

00000000: 0102 0304 0506 0708 090b 0c0a 0e0f 1011  ................
00000010: 1213 1415 1617 1819 1a1b 1c1d 1e1f 2021  .............. !
00000020: 2223 2425 2627 2829 2a2b 2c2d 2e2f 3031  "#$%&'()*+,-./01
00000030: 3233 3435 3637 3839 3a3b 3c3d 3e3f 4041  23456789:;<=>?@A
00000040: 4243 4445 4647 4849 4a4b 4c4d 4e4f 5051  BCDEFGHIJKLMNOPQ
00000050: 5253 5455 5657 5859 5a5b 5c5d 5e5f 6061  RSTUVWXYZ[\]^_`a
00000060: 6263 6465 6667 6869 6a6b 6c6d 6e6f 7071  bcdefghijklmnopq
00000070: 7273 7475 7677 7879 7a7b 7c7d 7e7f 8081  rstuvwxyz{|}~...
00000080: 8283 8485 8687 8889 8a8b 8c8d 8e8f 9091  ................
00000090: 9293 9495 9697 9899 9a9b 9c9d 9e9f a0a1  ................
000000a0: a2a3 a4a5 a6a7 a8a9 aaab acad aeaf b0b1  ................
000000b0: b2b3 b4b5 b6b7 b8b9 babb bcbd bebf c0c1  ................
000000c0: c2c3 c4c5 c6c7 c8c9 cacb cccd cecf d0d1  ................
000000d0: d2d3 d4d5 d6d7 d8d9 dadb dcdd dedf e0e1  ................
000000e0: e2e3 e4e5 e6e7 e8e9 eaeb eced eeef f0f1  ................
000000f0: f2f3 f4f5 f6f7 f8f9 fafb fcfd feff       ..............

Đó là mỗi ký tự ASCII ngoại trừ 0x00và 0x0Dvì cả hai đều gây ra hành vi lạ trên TIO. Hãy vui vẻ bẻ khóa! >: D

Mã ban đầu là ở V.

Dùng thử trực tuyến

Hexdump:

00000000: ee02 0304 0506 0708 090b 0c0e 0f10 1112  ................
00000010: 1314 1516 1718 191a 1b1c 1d1e 1f20 2122  ............. !"
00000020: 2324 2526 2728 292a 2b2c 2d2e 2f30 3132  #$%&'()*+,-./012
00000030: 3334 3536 3738 393a 3b3c 3d3e 3f40 4142  3456789:;<=>?@AB
00000040: 4344 4546 4748 494a 4b4c 4d4e 4f50 5152  CDEFGHIJKLMNOPQR
00000050: 5455 5657 5859 5a5b 5c5d 5e5f 6061 6263  TUVWXYZ[\]^_`abc
00000060: 6465 6667 6869 6a6b 6c6d 6e6f 7071 7273  defghijklmnopqrs
00000070: 7475 7677 7879 7a7b 7c7d 7e7f 8081 8283  tuvwxyz{|}~.....
00000080: 8485 8687 8889 8a8b 8c8d 8e8f 9091 9293  ................
00000090: 9495 9697 9899 9a9b 9c9d 9e9f a0a1 a2a3  ................
000000a0: a4a5 a6a7 a8a9 aaab adae afb0 b1b2 b3b4  ................
000000b0: b5b6 b7b8 b9ba bbbc bdbe bfc0 c1c2 c3c4  ................
000000c0: c5c6 c7c8 c9ca cbcc cdce cfd0 d1d2 d3d4  ................
000000d0: d5d6 d7d8 d9da dbdc ddde dfe0 e1e2 e3e4  ................
000000e0: e5e6 e7e8 e9ea ebec edef f0f1 f2f3 f4f5  ................
000000f0: f6f7 f8f9 fafb fcfd feff 0a53 ac01       ...........S..

Về cơ bản, tất cả mọi thứ cho đến Schỉ chèn rác vào bộ đệm. Lúc 0xEEđầu chỉ là để đảm bảo rằng mọi thứ sau dòng mới không xảy ra trong một phần của vòng lặp hoặc macro. Sau đó, chúng tôi làm

¬<C-a>   "Insert every character in the range 0x01-0xFF

Octave , 91 byte

a=['111111111123666667eeegggkkknnszEEGn};:;:'];
''''''''''(),,,,,-[[[]]]aaaddip;;=ds1010]);

PHP, 130 byte (An toàn)

    $$$$$$''''(((((((()))))))),,22;;;;;;<<==??\\\\____aaccddeeeeeeeehhhhiiiillllmmoooooopppppppppprrrrrrrrssssssssttttttttttvvvvvv

Giải pháp gốc

Tôi không thể hiểu rằng nó không bị nứt

<?php $v=str_split(str_repeat('<?php\ $v=str_split(str_repeat(\'\',2));sort($v);echo\ implode($v);',2));sort($v);echo implode($v);

Đoán, 43 byte

{4"2)4q):)u(4o'{4t:q(e)(",(t22(u()o)?,?'2e

Đó là một cuộc gọi khó khăn cho dù có chia sẻ ngôn ngữ đó hay không, nhưng tôi nghĩ tùy chọn này tốt hơn. Lưu ý rằng có một dòng mới.