Trong câu hỏi này, tôi đã yêu cầu bạn đoán một quine đảo chữ dựa trên đầu ra của nó. Tuy nhiên, có vẻ như chúng ta chưa có câu hỏi nào về việc chơi golf một câu đố đảo chữ. Vì vậy, nhiệm vụ của bạn sẽ là tạo ra quine ngắn nhất mà bạn có thể.

Một quine đảo là gì?

Một quine đảo chữ là một chương trình không trống, in một đảo chữ cái của mã nguồn, không phải là nguồn gốc của nó.

Đây là một ví dụ về một quine đảo chữ trong Python 2:

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

Bạn không nên đọc nguồn của riêng bạn cho thử thách này.

Bình thường , 2 byte

)(

Đầu ra

()

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

)  # Ends statement, does nothing in this program
 ( # Create an empty tuple
   # Implicitly print the empty tuple

V , 4 byte

2ii2

Đầu ra:

i2i2

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

> <> , 9 8 7 byte

Đã chơi gôn 1 byte nhờ @WheatWizard bằng cách sử dụng !và tăng nó để có được"

Đã chơi gôn 1 byte nhờ @ ConorO'Brien bằng cách sử dụng #thay vì<!

":1->o#

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

Đầu ra "#o>-1:.

Giải trình

":1->o#"        Push this string (note that the IP wraps around)
:               Duplicate the top value of the stack (35 from the "#")
1-              Subtract one from it to get 34 ('"')
>o#             Print every character on the stack until the program cannot pop any more and still tries to pop a value from the stack afterwards
                The program exits with an error from not being able to pop a value from an empty stack

Brainfuck, 158 byte

>>--<<-[[<+>->+>->+++<<<]>-]<<<<<<[--->>.<<]>>++<<<[->>>.<<<]>>-<<<[--->>>.<<<]>>>--<<<<[++>>>>.<<<<]>>>>+++>--.[---<.>]>+.......++.......<<<>>>>>>>>>-----+++

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

Nó có thể không phải là phiên bản ngắn nhất, nhưng ít nhất nó hoạt động.

Thực tế thú vị , mã đầu ra thực sự có thể được thực thi (và nó chấm dứt).

Đầu ra

<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------++++++++++++++++++<....................[[[[[[[]]]]]]]

Giải trình

>>--<<-[[<+>->+>->+++<<<]>-]    Initializes the tape with the
                                help of a recurrence relation.
<<<<<<[--->>.<<]>>++<<<[->>>
.<<<]>>-<<<[--->>>.<<<]>>>--    Prints the characters using
<<<<[++>>>>.<<<<]>>>>+++>--.    classic loops.
[---<.>]>+.......++.......

<<<>>>>>>>>>-----+++            Junk to complete the anagram.

Python 3, 32 byte

in ("" "p" r "i" n "t" 2 (") *" "" * 2)

In p"r"i"n"t"2(")*p"r"i"n"t"2(")*\n, sắp xếp đầu ra:\n""""""""""""(())**22iinnpprrtt

Ruby , 8 byte

p"p*2"*2

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

Bản in này

"p*2p*2"

Giải trình

Điều này hoạt động tương tự như câu trả lời python trong câu hỏi. Nó sẽ tạo chuỗi p*2p*2sau đó sử dụng Ruby psẽ in đại diện của chuỗi.

JavaScript (ES6), 40 32 byte

f=($=`($)=>{$=$+"${"``"}$"}`)=>$+$

Không có sự lộn xộn với Function.toString. Như một phần thưởng, mã bên trong chuỗi gần như trông hợp pháp. Chỉnh sửa: Đã lưu 8 byte bằng cách sử dụng +thay vì repeat(2).

Klein , 7 + 6 = 13 byte

Đây là một câu trả lời dựa trên câu trả lời > <> .

":1+@!

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

Đầu ra này

:1+@!"

Japt , 10 9 byte

Tìm thấy một cách tốt hơn :-)

Q+2ç"Q+2ç

Đầu ra "Q+2çQ+2ç. Kiểm tra nó trực tuyến!

Giải trình

Q+2ç"Q+2ç    // Implicit: Q = quotation mark
    "Q+2ç    // Take this string.     Q+2ç
  2ç         // Repeat it twice.      Q+2çQ+2ç
Q+           // Prepend a quote.      "Q+2çQ+2ç
             // Implicit: output result of last expression

Cũng có thể Qi2ç"Qi2ç, mà in Qi2çQi2ç". Cái này gần với quine Japt tiêu chuẩn hơn:

"iQ ²"iQ ²

Nhưng tôi không tin có bất kỳ cách dễ dàng nào để nêm dấu ngoặc kép ở giữa chuỗi cho một chuỗi 9 byte.

Ruby, 20 byte

$><<%q($><<%q()*2)*2

Đầu ra này

$><<%q()*2$><<%q()*2

Tận dụng %q(...)cú pháp chuỗi của Ruby , hỗ trợ các dấu ngoặc đơn lồng nhau.

Võng mạc , 8 byte

_

$nn$

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

Bản in

n$_
n$

Cả hai đều chứa một _, hai n, hai $và ba nguồn cấp dữ liệu.

Lưu ý rằng một nguồn cấp dữ liệu theo sau bởi hầu hết các ký tự khác là một giải pháp tầm thường, nhưng không rõ liệu nó có hợp lệ hay không, bởi vì ký tự thứ hai chỉ mã hóa chính nó và nguồn cấp dữ liệu không thực sự mã hóa ký tự đầu ra.

Giải trình

_

Thay thế đầu vào trống bằng a _.

$nn$

Nối một chuỗi trống, xảy ra cả trước hoặc sau _và chèn một linefeed ( $n), an nvà a $. Vì lần đầu tiên chúng tôi chèn vào đó _, điều này thêm vào mỗi ký tự đó hai lần, do đó, nvà $tài khoản cho $n, và chúng tôi nhận được hai trong số ba nguồn cấp dữ liệu chúng tôi cần trong đầu ra. Nguồn cấp dữ liệu thứ ba được in vì Retina in một nguồn cấp theo dõi theo mặc định.

Chúng tôi cũng có thể sử dụng n$n$trong giai đoạn này, sau đó sẽ in:

n
$_n
$

Python thay thế, 4 byte

Đây là giải pháp Code Golf đầu tiên của tôi, vì vậy tôi hy vọng nó đáp ứng các quy tắc. Trong trình thông dịch tương tác Python 2 hoặc 3:

>>> (1),
(1,)

Đầu ra là một đảo chữ của đầu vào.

Khác:

>>> 2*'2*'
'2*2*'

Trong Python 2:

>>> type('rst <>'),
(<type 'str'>,)

Trong Python 3:

>> {1, 0}
{0, 1}

Cập nhật 2017-06-15: Còn nữa:

>>> 01.
1.0

Haskell , 38 39 byte

main=print$[0,0]>>"main=print$[0,0]>>"

Hãy thử trực tuyến! Đầu ra:

"main=print$[0,0]>>main=print$[0,0]>>"

Chỉnh sửa: +1 byte vì trước đây tôi đã quên dòng mới theo dõi ngầm định của print.

Thay thế: (Cùng số byte nhưng không chứa ASCII-Owl)

main=print$e++e;e="main=print$e++e;e="

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

Đầu ra:

"main=print$e++e;e=main=print$e++e;e="

Groovy, 24 20 byte

{"""{""*""2""}"""*2}

-4 cảm ơn CalculatorFeline, rốt cuộc không cần khoảng trắng!

Đầu ra:

{""*""2""}{""*""2""}

Giải trình:

Đóng cửa ẩn danh mà khi được gọi sẽ trả về {""*""2""}hai lần (nối).

05AB1E , 10 byte

'∞∞''∞'JJ∞

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

Đầu ra:

∞∞''JJ''∞∞

Giải trình:

Code       | Explanation                | Stack
-----------+----------------------------+-------------------
'∞         | Push literal '∞'.          | ["∞"]
  ∞        | Mirror.                    | ["∞∞"]
   ''      | Push literal "'".          | ["∞∞","'"]
     ∞     | Mirror.                    | ["∞∞","''"]
      'J   | Push literal 'J'.          | ["∞∞","''","J"]
        J  | Join it all together.      | ["∞∞''J"]
         ∞ | Mirror.                    | ["∞∞''JJ''∞∞"]
-----------+----------------------------+-------------------
           | Implicit print.            | ∞∞''JJ''∞∞

CJam , 6 byte

"_`"_`

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

Bản in

_`"_`"

Giải trình

"_`"   e# Push this string.
_      e# Duplicate.
`      e# Stringify it, which wraps it in quotes.
       e# Implicitly print stack contents.

Bash, 36 byte

tee f<<<'tee f<<<""cat f'"''"
cat f

Đầu ra này

tee f<<<""cat f''
tee f<<<""cat f''

(và tạo tệp fdưới dạng tác dụng phụ, nhưng điều đó được cho phép trên mỗi meta .)

Cả chương trình và đầu ra đều có một dòng mới.

Quá trình suy nghĩ: Tôi đã nghĩ rằng cách dễ nhất để xuất một chuỗi hai lần, ngoài việc gán nó cho một biến, là làm

tee f<<<string
cat f

Chuỗi cần được trích dẫn bởi vì nó sẽ chứa khoảng trắng và <ký tự, vì vậy sau đó tôi đã có

tee f<<<'tee f<<<cat f'
cat f

mà hầu như hoạt động, ngoại trừ nó không xuất ra dấu ngoặc kép. May mắn thay, Bash hỗ trợ nối chuỗi theo nghĩa đen bằng cách chỉ cần đặt chúng cạnh nhau, do đó, nối thêm "''"vào ""phần trích dẫn và chèn vào bên trong phần trích dẫn duy nhất mang lại giải pháp này.

PHP , 44 byte

<?=str_repeat('<?=\str_\repeat(\'\',2);',2);

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

CJam , 8 byte

"2*`"2*`

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

Giải trình

Tương tự như ví dụ Python trong câu hỏi

"2*`"     e# Push the string "2*`"
     2*   e# Repeat it twice
       `  e# Get its string representation (wrap in quotes)

Đầu ra là "2*`2*`".

Befunge, 11 byte

' 2+">:#,_@

Bản in:

+2 '@_,#:>"

Giải trình:

' 2+"        Put a " on the stack (32 + 2)
    "        Put the rest of the code on stack (wrap-around string)
     >:#,_   Print stack
          @  End

QBIC , 8 byte

?A+@?A@+

Tôi chỉ tìm ra cách thực hiện một câu hỏi thích hợp trong QBIC. Tạo một đảo chữ cái được thực hiện bằng cách chuyển đổi xung quanh các ký tự trong chuỗi ký tự. Có 24 đảo chữ có thể theo cách này.

Befunge-98 , 8 byte

"'$<@,k7

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

Ồ , 14 byte

"æ3M.Cæ"æ3M."C

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

Đầu ra:

æ3M.CæC.M3æ"""

Giải trình

"æ3M.Cæ"æ3M."C
"æ3M.Cæ"       # Pushes "æ3M.Cæ"
        æ      # Palindrone of that string
         3M    # 3 times...
           ."   # Push " on the stack
             C  # Concatenate with the string above

JavaScript (ES6), 15 byte

f=(s='f=')=>f+s

Đầu ra:

(s='f=')=>f+sf= 

Đoạn trích:

f=(s='f=')=>f+s

console.log(f());

Phân hạch 2 , 9 8 6 byte

R"'!+O

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

Giải trình

Một nguyên tử được tạo ra R, mà di chuyển đúng. Nguyên tử này sau đó đi qua một ", bắt đầu chế độ in. Trong chế độ in, tất cả các ký tự (cho đến khi khớp ") được in. Điều này có nghĩa là nó in '!+ORtrong trường hợp này. Sau đó, tất cả những gì còn lại là in ", được thực hiện bởi các ký tự còn lại. '!đặt khối lượng của nguyên tử thành mã ký tự !và +tăng nó thành mã ký tự của ". Sau đó, mã ký tự được xuất ra Ovà nguyên tử bị hủy, kết thúc chương trình.

(Trên thực tế, đây chỉ là một vòng quay của quine ngắn nhất)

Toán học, 2 byte

.0

Đầu ra:

0.

Một số bắt đầu bằng một dấu thập phân như .123được hiểu là 0.123, do đó .0được hiểu là 0.0. Vì phần của số sau dấu thập phân bằng 0, Mathicala không in nó.

JavaScript (một số khác), 11 byte

f=_=>'=f'+f

Được gọi với f(), đầu ra

=f_=>'=f'+f

f=_=>'=f'+f

console.log(f());

Python 3, 31 byte

a='a=%r;pritn(a%%a)';print(a%a)

Stax , 8 4 byte

.S.S

Chạy và gỡ lỗi trực tuyến!

Một cổng trực tiếp của câu trả lời này .

Phiên bản cũ, 8 byte

..b..LbL

Chạy và gỡ lỗi trực tuyến!

Phiên bản thay thế với một thủ thuật khá rẻ có thể được áp dụng cho các câu hỏi thích hợp trong hầu hết mọi ngôn ngữ.

"43bL"34bL

Chạy và gỡ lỗi trực tuyến!

Bởi vì "34bL"34bLlà một quine thích hợp trong Stax.

Một phiên bản khác, chỉ sử dụng chuỗi ký tự char đơn.

''c'Lc'cccLcLL

Chạy và gỡ lỗi trực tuyến!

Giải trình

.S.S        Generates powerset ["","S","S.","."]
            Implicit flatten and output

..b         Push string ".b"
   ..L      Push string ".L"
      b     Duplicate both strings
       L    Concatenate all 4 strings to a single one.

05AB1E , 13 byte

"34çJ∞"34çJ∞

Đầu ra:

34çJ∞""∞Jç43

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

"34çJ∞"      # Push this string                 | [ 34çJ∞ ]
       34ç   # Push a quote (")                 | [ 34çJ∞, " ]
          J  # Join                             | [ 34çJ∞" ]
           ∞ # Mirror                           | [ 34çJ∞""∞Jç43 ]
             # Implicitly output with a newline