Viết một chương trình hoàn chỉnh có đầu vào số nguyên boolean hoặc không âm. Nó phải:

• Xuất mã nguồn của chính nó nếu giá trị đầu vào là sai
• Xuất mã nguồn của chính nó ngược lại nếu giá trị đầu vào là trung thực

Chương trình của bạn không thể là palindromic, cũng không thể đọc mã nguồn của chính nó bằng bất kỳ phương tiện nào.

Đây là mã golf - mã ngắn nhất tính bằng byte thắng.

Gol> <> , 9 byte

'rd3*I?rH

Tôi cảm thấy hơi lúng túng khi đăng bài này, vì chúng tôi đã có> <>, Vitsy và Minkolang trả lời. Các bổ sung duy nhất cho quine tiêu chuẩn là I(đọc đầu vào số nguyên), ?(thực hiện tiếp theo nếu trung thực) và r(ngăn xếp ngược).

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

CJam, 17 16 byte

{`"_~"+Wq~g#%}_~

Kiểm tra nó ở đây.

Một sửa đổi khá đơn giản của quine tiêu chuẩn. Các giải pháp khác cho 17 byte:

{`"_~"+q~{W%}&}_~
{`"_~"+q~!2*(%}_~

Nếu tôi có thể giả sử rằng đầu vào chỉ là 0 hoặc 1 (dưới dạng dự phòng cho boolean, không có loại dành riêng cho CJam), tôi nhận được 15 bằng cách bỏ qua g:

{`"_~"+Wq~#%}_~

Giải trình

{`"_~"+  e# Standard generalised quine framework. Leaves the source code on the stack. 
  W      e# Push a -1.
  q~     e# Read and evaluate input.
  g      e# signum, turning truthy values into 1 (leaving 0 unchanged).
  #      e# Power. -1^0 == 1, -1^1 == -1.
  %      e# Select every Nth element: a no-op for 1 and reverses the string for -1.
}_~

Bình thường, 17 byte

_WQjN*2]"_WQjN*2]

Một sửa đổi đơn giản của quine Pyth tiêu chuẩn.

> <>, 17 byte

Yêu cầu cờ -v (+1 byte) để đẩy đầu vào lên ngăn xếp (hoặc để bạn đặt đầu vào trên ngăn xếp trước trên trình thông dịch trực tuyến).

'rd3*$?rol?!;70.

Bạn có thể thực hiện các thao tác dưới đây cho cùng một lượng byte (không có cờ) nếu chỉ cho phép nhập số nguyên (nghĩa là 0 cho sai, 1 cho trung thực).

'rd3*ic%?rol?!;80.

Dùng thử trực tuyến

Truthy / falsy cho> <> là bất cứ thứ gì không phải là 0 và 0, tương ứng.

Vitsy , 15 byte

... Tôi ... Tôi đang đánh bại CJam! (hét lên) Mẹ! Nhìn này, ma, tôi làm điều đó!

'rd3 * i86 * -) rl \ O

Giải trình:

'rd3 * i86 * - (rl \ O
Quine tiêu chuẩn, nhưng với một twist:

'Chụp mã nguồn dưới dạng chuỗi
 rd3 * Tạo ký tự 'trong ASCII
     i86 * - Lấy ký tự đầu vào là ASCII rồi trừ 48 từ nó. 
                    Nếu nó bằng 0, nó sẽ là câu lệnh if sẽ bỏ qua hướng dẫn tiếp theo.
          (r Nếu mục trên cùng của ngăn xếp bằng 0, không thực hiện mục tiếp theo.
                    Mục tiếp theo ở đây là đảo ngược.
            l \ O In ra ngăn xếp.

Phiên bản mới hơn của Vitsy , 11 Byte

v'rd3 *} v) rZ
v Chụp đầu vào dưới dạng một biến.
 'Nắm bắt nguồn cho đến khi gặp một nguồn khác'
  r Đảo ngược ngăn xếp.
   d3 * Đẩy 'vào ngăn xếp.
      } Xoay ngăn xếp sang bên phải.
       v) Đẩy biến (đầu vào) vào ngăn xếp và kiểm tra nếu nó không bằng không.
         r Nếu vậy, đảo ngược ngăn xếp.
          Z Xuất mọi thứ trong ngăn xếp.

Javascript (ES6), 42 byte

$=_=>'$='+(_?$:[...''+$].reverse().join``)

Đây là một sửa đổi của Bling Quine của tôi . Nó cũng dài gấp đôi.

Burlesque, 40 byte

ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh

Giải trình:

Burlesque có tích hợp thao tác ngăn xếp và mã nâng cao. Thực tế, bạn không thể truy cập mã nguồn của chương trình nhưng bạn có thể truy cập mã còn lại sẽ được thực thi trong tương lai. Điều này có nghĩa là #Qsẽ trả về tất cả mã theo sau đó là lý do tại sao chúng ta phải thêm mọi thứ #Qvào mã đó, đó là những gì chúng ta đang làm ri#Q.

blsq ) #Q1 2++
12 -- this is the result of 1 2++
{1 2 ++} -- this is the result of #Q

++1 2là mã bất hợp pháp về mặt kỹ thuật vì nó dựa trên ngăn xếp. Nhưng chúng ta có thể thao tác mã để làm cho nó thực thi như 1 2++:

blsq ) #Q<-#q++1 2 
12

Làm việc với các công cụ tích hợp này là vô cùng khó khăn và chưa ai sử dụng chúng cho bất cứ điều gì hữu ích ngoại trừ những thứ liên quan đến quine. Nếu bạn đảo ngược, ++1 2bạn sẽ có được 2 1++sản xuất 21và không 12. Lý do mã trên tạo ra 12là vì #Qcũng bao gồm <-vì vậy cuối cùng chúng tôi thực hiện nhiều hơn chỉ là 2 1++: p. Chúng tôi cuối cùng thực hiện 2 1++#q<-mà sản xuất 12.

Chúng tôi thực sự có thể thay thế những thứ trong mã của chúng tôi, ví dụ mã này thay thế tất cả các lần xuất hiện của ?+chính nó bằng?*

blsq ) #Q(?+)(?*)r~5.-#q5 5?+
25

Sử dụng:

$ echo "1" | blsq --stdin 'ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh'
hs fi sp "-<" j +. /\ "Q#ir" -~ HS 2Q#ir
$ echo "0" | blsq --stdin 'ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh'
ri#Q2 SH ~- "ri#Q" \/ .+ j "<-" ps if sh

Haskell, 126 118 108 byte

main=readLn>>=putStr.([t,reverse t]!!);t=s++show s;s="main=readLn>>=putStr.([t,reverse t]!!);t=s++show s;s="

Mong đợi 0hoặc 1là đầu vào.

Chồn 0,10 , 13 byte

"66*2-n,?r$O.

Hãy thử nó ở đây.

Điều này giống hệt như quine tiêu chuẩn ngoại trừ bốn ký tự này : n,?r. nlấy một số nguyên từ đầu vào, ,đảo ngược nó, vì vậy ?bỏ qua rnếu đầu vào là trung thực. Mặt khác, rđảo ngược ngăn xếp để nó là đầu ra theo thứ tự ngược lại.

Python 2, 51 byte

s="print('s=%r;exec s'%s)[::1-2*0**input()]";exec s

Java 10 (chương trình đầy đủ), 282 byte

interface N{static void main(String[]a){var s="interface N{static void main(String[]a){var s=%c%s%1$c;s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}";s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}

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

Java 10 (dưới dạng hàm lambda), 154 byte

b->{var s="b->{var s=%c%s%1$c;s=s.format(s,34,s);return b?new StringBuffer(s).reverse():s;}";s=s.format(s,34,s);return b?new StringBuffer(s).reverse():s;}

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

Giải trình:

interface N{                          // Class
  static void main(String[]a){        //  Mandatory main-method
    var s="interface N{static void main(String[]a){var s=%c%s%1$c;s=s.format(s,34,s);System.out.print(new Boolean(a[0])?new StringBuffer(s).reverse():s);}}";
                                      //   Unformatted source code
    s=s.format(s,34,s);               //   Format the source code (the quine-String)
    System.out.print(                 //   Print:
      new Boolean(a[0])?              //    If the input is true:
       new StringBuffer(s).reverse()  //     Print the quine-String reversed
      :                               //    Else:
       s);}}                          //     Print the quine-String as is

giải thích quine :

• Có var schứa mã nguồn chưa được định dạng
• %s được sử dụng để đặt Chuỗi này vào chính nó với s.format(...)
• %c, %1$cvà 34được sử dụng để định dạng dấu ngoặc kép
• s.format(s,34,s) đặt tất cả lại với nhau

Và sau đó new StringBuffer(s).reverse()được sử dụng để đảo ngược chuỗi quine nếu cần thiết dựa trên boolean đầu vào.

05AB1E , 21 byte

0"D34çý‚sè"D34çý‚sè

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

Sửa đổi quine mặc định 0"D34çý"D34çýbằng cách thêm ‚sè.

Giải trình:

0                        # Push 0 to the stack
                         #  STACK: [0]
 "D34çý‚sè"             # Push the string 'D34çý‚sè' to the stack
                         #  STACK: [0, 'D34çý‚sè']
            D            # Duplicate this string
                         #  STACK: [0, 'D34çý‚sè', 'D34çý‚sè']
             34ç         # Push '"' to the stack
                         #  STACK: [0, 'D34çý‚sè', 'D34çý‚sè', '"']
                ý        # Join the stack with '"' delimiter
                         #  STACK: ['0"D34çý‚sè"D34çý‚sè']
                 Â       # Bifurcate (short for Duplicate & Reverse)
                         #  STACK: ['0"D34çý‚sè"D34çý‚sè', 'ès‚Âýç43D"ès‚Âýç43D"0']
                  ‚      # Pair them up:
                         #  STACK: [['0"D34çý‚sè"D34çý‚sè','ès‚Âýç43D"ès‚Âýç43D"0']]
                   s     # Swap to get the boolean input (0 or 1)
                         #  STACK: [['0"D34çý‚sè"D34çý‚sè','ès‚Âýç43D"ès‚Âýç43D"0'], 1]
                    è    # Index the input into the list
                         #  STACK: ['ès‚Âýç43D"ès‚Âýç43D"0']
                         # (Output the top of the stack implicitly)

PS: Tự động in một dòng mới. Nếu điều này cũng nên được đảo ngược, thay vào đó là 23 byte:

0"D34çý‚sè?"D34çý‚sè?

Hãy thử trực tuyến. ( ?là một bản in rõ ràng không có dòng mới )