Schreiben Sie ein vollständiges Programm, das eine boolesche oder nicht negative Ganzzahleingabe akzeptiert. Es muss:

• Gibt seinen eigenen Quellcode aus, wenn der Eingabewert falsch ist
• Geben Sie den eigenen Quellcode umgekehrt aus, wenn der Eingabewert wahr ist

Ihr Programm kann weder palindrom sein noch seinen eigenen Quellcode lesen.

Dies ist Code Golf - kürzester Code in Bytes gewinnt.

Gol> <> , 9 Bytes

'rd3*I?rH

Es ist mir ein wenig unangenehm, dies zu posten, da wir bereits die Antworten von> <>, Vitsy und Minkolang haben. Die einzigen Ergänzungen zum Standard-Quine sind I(Integer-Eingabe lesen), ?(Next If Truthy ausführen) und r(Reverse Stack).

Probieren Sie es online aus .

CJam, 17 16 Bytes

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

Teste es hier.

Eine recht unkomplizierte Modifikation der Standard-Quine. Andere Lösungen für 17 Bytes:

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

Wenn ich davon ausgehen kann, dass die Eingabe nur 0 oder 1 ist (als Ersatz für einen Booleschen Wert, für den es in CJam keinen dedizierten Typ gibt), erhalte ich 15, indem ich Folgendes weglasse g:

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

Erläuterung

{`"_~"+  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.
}_~

Pyth, 17 Bytes

_WQjN*2]"_WQjN*2]

Eine einfache Modifikation des Standard-Pyth-Quines.

> <>, 17 Bytes

Benötigt das Flag -v (+1 Byte), um Eingaben auf den Stapel zu verschieben (oder um Eingaben zuvor auf dem Online-Interpreter auf den Stapel zu setzen).

'rd3*$?rol?!;70.

Sie könnten das Folgende für die gleiche Anzahl von Bytes (ohne das Flag) tun, wenn nur Ganzzahleingaben zulässig wären (dh 0 für falsch, 1 für wahr).

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

Probieren Sie es online aus

Wahrheit / Falschheit für> <> ist nichts anderes als 0 bzw. 0.

Vitsy , 15 Bytes

... Ich ... Ich besiege CJam! (schreit vorbei) Mama! Schau, ma, ich habe es getan!

'rd3 * i86 * -) rl \ O

Erläuterung:

'rd3 * i86 * - (rl \ O
Standard Quine, aber mit einem Twist:

'Erfassen Sie den Quellcode als String
 rd3 * Erstellt das Zeichen 'in ASCII
     i86 * - Hole das eingegebene Zeichen als ASCII und subtrahiere 48 davon. 
                    Wenn es Null ist, überspringt die if-Anweisung den nächsten Befehl.
          (r Wenn der oberste Gegenstand des Stapels Null ist, machen Sie nicht den nächsten Gegenstand.
                    Der nächste Punkt hier ist umgekehrt.
            l \ O Den Stapel ausdrucken.

Neuere Version von Vitsy , 11 Bytes

v'rd3 *} v) rZ
v Erfassen Sie die Eingabe als Variable.
 "Erfassen Sie die Quelle, bis Sie auf eine andere stoßen"
  r Drehen Sie den Stapel um.
   d3 * Zum Stapel schieben.
      } Drehen Sie den Stapel nach rechts.
       v) Schieben Sie die Variable (Eingabe) auf den Stapel und prüfen Sie, ob sie nicht Null ist.
         r Wenn ja, drehen Sie den Stapel um.
          Z Alles im Stapel ausgeben.

Javascript (ES6), 42 Byte

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

Dies ist eine Modifikation meines Bling Quine . Es ist auch doppelt so lang.

Burlesque, 40 Bytes

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

Erläuterung:

Burlesque verfügt über integrierte Funktionen zur Stapel- und Codemanipulation. Sie können zwar nicht auf den Quellcode des Programms zugreifen, aber Sie können auf den verbleibenden Code zugreifen, der in Zukunft ausgeführt werden soll. Dies bedeutet #Q, dass der gesamte darauf folgende Code zurückgegeben wird, weshalb wir alles #Qzu dem Code addieren müssen, mit dem wir arbeiten ri#Q.

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

++1 2ist technisch illegaler Code, da er stapelbasiert ist. Wir können den Code jedoch so manipulieren, dass er wie folgt ausgeführt wird 1 2++:

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

Die Arbeit mit diesen integrierten Funktionen ist unglaublich knifflig und niemand hat sie bisher für produktive Zwecke verwendet, außer für quine-bezogene Dinge. Wenn du umkehrst ++1 2bekommst du 2 1++was produziert 21und nicht 12. Der Grund, warum der obige Code erzeugt, 12ist, dass er #Qauch das beinhaltet, <-damit wir am Ende viel mehr ausführen als nur 2 1++: p. Am Ende führen wir das aus, 2 1++#q<-was produziert 12.

Wir können tatsächlich Dinge in unserem Code ersetzen, zum Beispiel ersetzt dieser Code alle Vorkommen von sich ?+selbst durch?*

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

Verwendung:

$ 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 Bytes

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

Erwartet 0oder 1als Eingabe.

Minkolang 0,10 , 13 Bytes

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

Probieren Sie es hier aus.

Das ist genau wie das Standard - quine außer für diese vier Zeichen: n,?r. Nimmt neine Ganzzahl von der Eingabe, ,invertiert sie und ?überspringt sie, rwenn die Eingabe wahr ist. Andernfalls wird rder Stapel umgekehrt, sodass er in umgekehrter Reihenfolge ausgegeben wird.

Python 2, 51 Bytes

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

Java 10 (volles Programm), 282 Bytes

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

Probieren Sie es online aus.

Java 10 (als Lambda-Funktion), 154 Bytes

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

Probieren Sie es online aus.

Erläuterung:

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

Eine Erklärung:

• Das var senthält den unformatierten Quellcode
• %s wird verwendet, um diesen String mit in sich selbst zu setzen s.format(...)
• %c,, %1$cund 34werden zum Formatieren der doppelten Anführungszeichen verwendet
• s.format(s,34,s) setzt alles zusammen

Und wird dann new StringBuffer(s).reverse()verwendet, um den Quine-String bei Bedarf basierend auf dem Eingabe-Booleschen Wert umzukehren.

05AB1E , 21 Bytes

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

Probieren Sie es online aus.

Änderung der Standard- Quine 0"D34çý"D34çý durch Hinzufügen ‚sè.

Erläuterung:

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: Druckt automatisch eine nachgestellte Zeile. Wenn dies auch umgekehrt werden soll, sind es stattdessen 23 Bytes:

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

Probieren Sie es online aus. ( ?ist ein expliziter Ausdruck ohne Zeilenumbruch )