Schreiben Sie ein Programm, das eine "true" -Ausgabe generiert, wenn die Eingabe mit dem Quellcode des Programms übereinstimmt, und das eine "false" -Ausgabe generiert, wenn die Eingabe nicht mit dem Quellcode des Programms übereinstimmt.

Dieses Problem kann als mit Quines verbunden beschrieben werden, da das Programm in der Lage sein muss, seinen eigenen Quellcode zu berechnen.

Dies ist Code Golf: Es gelten die Standardregeln. Ihr Programm darf nicht auf spezielle Dateien zugreifen, z. B. auf die Datei seines eigenen Quellcodes.

Bearbeiten: Wenn Sie dies wünschen, kann true / false durch true / false oder 1/0 ersetzt werden.

Beispiel

Wenn der Quellcode Ihres Programms ist bhiofvewoibh46948732));:/)4, dann ist hier, was Ihr Programm tun muss:

Eingang (Stdin)

bhiofvewoibh46948732));:/)4

Ausgang (Stdout)

true

Eingang

(Anything other than your source code)

Ausgabe

false

JavaScript: 26

function f(s){return s==f}

Ich weiß nicht, ob eine JavaScript-Datei wirklich als "Programm" qualifiziert ist.

JavaScript ES6, 9 Zeichen

Dies ist die einzige (golferische) Möglichkeit, dies in JS zu tun. ES6 macht es einfach super weniger Zeichen

Führen Sie dies in der neuesten Firefox-Webkonsole aus:

f=x=>f==x

Anwendungsbeispiel:

f("check") // returns false
f("x=>f==x") // returns true

Haskell, 72 Zeichen

main=interact$show.(==s++show s);s="main=interact$show.(==s++show s);s="

Hinweis: Am Ende des Skripts befindet sich kein Zeilenendezeichen.

$ runhaskell Self.hs < Self.hs
True

GolfScript, 11 Zeichen

{`".~"+=}.~

Ohne das =wäre dieser Code ein Quine, der seinen eigenen Quellcode als String generiert. Das =macht es diese Zeichenfolge an seinem Eingang und Ausgang vergleichen , 1wenn sie übereinstimmen und 0wenn sie es nicht tun. Beachten Sie, dass der Vergleich genau ist. Insbesondere ein Zeilenumbruch am Ende der Eingabe führt dazu, dass der Vergleich fehlschlägt.

Erläuterung:

• { } ist ein Codeblockliteral in GolfScript;
• .dupliziert diesen Codeblock und ~führt die zweite Kopie aus (wobei die erste auf dem Stapel verbleibt);
• `stringifiziert den Codeblock und ".~"hängt + daran .~an;
• =vergleicht abschließend die resultierende Zeichenfolge mit der Eingabe (die vom GolfScript-Interpreter vor dem Programmstart als Zeichenfolge auf dem Stapel abgelegt wird) und gibt zurück, 1ob sie übereinstimmen und 0nicht.

Perl, Infinity 41 38 Zeichen

$_=q(print<>eq"\$_=q($_);eval"|0);eval

Update: Das Programm endet nicht mehr mit einem Zeilenumbruch, was bedeutet, dass es bei mehrzeiligen Dateien korrekt funktioniert. Sie müssen die Eingabe von STDIN eingeben, ohne die Eingabetaste zu drücken. Unter Windows konnte ich dies nur durch Lesen aus einer Datei tun.

Ursprüngliche Lösung:

print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(print<>==q(...

> <> 68 Bytes

Fische lieben es, Fischkacke zu essen. Jetzt wissen wir, dass sie sich von ihren Freunden unterscheiden können.

00v      0+1~$^?)0~\;n0\
  >:@@:@gi:0(?\:a=?/=?!/$1+
  0n;n*=f$=2~~/

Sie können es online ausprobieren !

Python 2, 55

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

Geprüft:

a='a=%r;print a%%a==raw_input()';print a%a==raw_input() -> True

(anything else) -> False

JavaScript ES6, 16 14 Bytes

$=_=>_==`$=`+$

Minus zwei Bytes dank Neil.

31 Bytes, wenn die Eingabe per Eingabeaufforderung erfolgen muss.

$=_=>prompt()==`$=${$};$()`;$()

38 Bytes, wenn wir per Alert ausgeben müssen.

$=_=>alert(prompt()==`$=${$};$()`);$()

Dies ist der richtige Weg, da die Antwort des Optimierers nicht den gesamten Quellcode akzeptiert.

Node.js: 54

function f(){console.log(f+'f()'==process.argv[2])}f()

Sie testen es, indem Sie es in einer Datei speichern f.js(der genaue Name hat keine Bedeutung) und verwenden

node f.js "test"

(was falsch ausgibt) oder

node f.js "$(< f.js)"

(welche Ausgabe ist wahr)

Ich habe auch eine andere Version basierend auf eval gemacht:

eval(f="console.log('eval(f='+JSON.stringify(f)+')'==process.argv[2])")

Es ist jetzt bei 72 Zeichen, ich werde versuchen, das zu verkürzen, wenn ich Zeit habe.

Smalltalk (Pharo 2.0 Dialekt)

Implementieren Sie diese 41- Zeichen-Methode in String (hässliche Formatierung für Code-Golf):

isItMe^self=thisContext method sourceCode

Bewerten Sie dies dann in einem Arbeitsbereich (printIt nach traditioneller Smalltalk-Methode).
Die Eingabe wird nicht von stdin gelesen, sondern ist nur ein String, an den wir die Nachricht senden (was könnte ein anderes Programm in Smalltalk sein?):

'isItMe^self=thisContext method sourceCode' isItMe.

Aber wir betrügen, SourceCode liest eine Quelldatei ...
Hier ist eine Variante mit 51 Zeichen, die dies nicht tut:

isItMe
    ^ self = thisContext method decompileString

Und teste mit:

'isItMe
    ^ self = thisContext method decompileString' isItMe

Wenn eine Zeichenfolge in einem Arbeitsbereich nicht als gültige Eingabe betrachtet wird, sehen wir uns an, wie ein Dialogfeld in 116 Zeichen verwendet wird.
Bewerten Sie einfach diesen Satz:

(UIManager default request: 'type me') = (thisContext method decompileString withSeparatorsCompacted allButFirst: 7)

Da das Dekompilierungsformat CR und TAB enthält, ändern wir dies mit SeparatorsCompacted.
Dann überspringen wir die ersten 7 Zeichen sind 'doIt ^'

Endlich eine 105- Zeichen-Variante mit stdin, interpretiere diesen Satz einfach von der Kommandozeile aus, um dich mehr im Mainstream zu fühlen:

Pharo -headless Pharo-2.0.image eval "FileStream stdin nextLine = (thisContext method decompileString withSeparatorsCompacted allButFirst: 7)"

flex - 312 Zeichen

Q \"
N \n
S " "
B \\
P "Q{S}{B}{Q}{N}N{S}{B}n{N}S{S}{Q}{S}{Q}{N}B{S}{B}{B}{N}P{S}{Q}{P}{Q}{N}M{S}{Q}{M}{Q}{N}%%{N}{P}{N}{M}{N} putchar('1');"
M "(.|{N})* putchar('0');"
%%
Q{S}{B}{Q}{N}N{S}{B}n{N}S{S}{Q}{S}{Q}{N}B{S}{B}{B}{N}P{S}{Q}{P}{Q}{N}M{S}{Q}{M}{Q}{N}%%{N}{P}{N}{M}{N} putchar('1');
(.|{N})* putchar('0');

Kann wahrscheinlich kürzer gemacht werden, funktioniert aber mit mehrzeiliger Eingabe (erforderlich, da der Quellcode aus mehreren Zeilen besteht) und sogar für Eingaben, die das Programm als Teilzeichenfolge enthalten. Es scheint, dass viele der bisherigen Antworten bei einem oder beiden fehlschlagen.

Kompilierbefehl: flex id.l && gcc -lfl lex.yy.c

D (133 Zeichen)

enum c=q{import std.stdio;import std.algorithm;void main(){auto i=readln();writeln(equal("auto c=q{"~c~"};mixin(c);",i));}};mixin(c);

JavaScript (V8), 35

function i(){alert(prompt()==i+[])}

rufen Sie an i()und es wird zur Eingabe aufgefordert

GolfScript - 26

":@;[34]@+2*=":@;[34]@+2*=

Inspiriert von http://esolangs.org/wiki/GolfScript#Examples

Andere Version:

"[34].@@;+2*="[34].@@;+2*=

Schade, dass \das Tauschen und Entkommen ist ...

Python 2, 47 Bytes

_='_=%r;print _%%_==input()';print _%_==input()

Ein einfaches Quine mit dem hinzugefügten Scheck.

CJam , 12 Bytes

{s"_~"+q=}_~

Probieren Sie es online!

Erläuterung

Dies verwendet nur das Standard-CJam-Quine-Framework.

{s"_~"+q=}    e# Push this block (function literal).
          _~  e# Copy and run it.

Was der Block macht:

 s            e# Stringify the top element (this block itself).
  "_~"+       e# Append "_~". Now the source code is on the stack.
       q      e# Read the input.
        =     e# Check if it equals the source code.

Tcl, 111 Zeichen

set c {set c {$c};puts [expr {[read stdin] eq [subst -noc \$c]}]};puts [expr {[read stdin] eq [subst -noc $c]}]

Perl, 52 char

$_='$/=$\;$_="\$_=\47$_\47;eval";print<>eq$_|0';eval

Python, 187 Bytes

import sys;code="import sys;code=!X!;print(sys.stdin.read()==code.replace(chr(33),chr(34)).replace(!X!,code,1))";print(sys.stdin.read()==code.replace(chr(33),chr(34)).replace("X",code,1))

Achten Sie darauf, dass Sie am Ende keine Zeilenumbrüche einfügen. Jemand mit besserem Python-fu könnte es verkürzen.

Schale , 11 Bytes

=hS+s"=hS+s

Probieren Sie es online!

Erläuterung

Die Erklärung dient ¨zum Abgrenzen von Zeichenfolgen (um unlesbare Escapezeichen zu vermeiden):

     "=hS+s  -- string literal: ¨=hS+s¨
  S+         -- join itself with
    s        -- | itself "showed": ¨"=hS+s"¨
             -- : ¨=hS+s"=hS+s"¨
 h           -- init: ¨=hS+s"=hS+s¨
=            -- is the input equal?

Durch Entfernen der Funktion können =Sie überprüfen, ob sie tatsächlich nur mit der Quelle selbst übereinstimmt.

> <> 24 Bytes

'1rd3*i={*}50l3-?.~i)*n;

Probieren Sie es online!

Wrapping-String-Literal, gefolgt von der Überprüfung, ob die Eingabe mit dem Stack identisch ist, und der endgültigen Überprüfung, ob keine Eingabe mehr vorhanden ist.

Gelee , 10 Bytes

“Ṿ;$⁼”Ṿ;$⁼

Probieren Sie es online!

“Ṿ;$⁼”Ṿ;$⁼
“Ṿ;$⁼”      String literal: 'Ṿ;$⁼'
        $   Next two links act on the string literal
      Ṿ     Uneval: '“Ṿ;$⁼”'
       ;    Append string: '“Ṿ;$⁼”Ṿ;$⁼' (source code)
         ⁼  Is the string above equal to the input?

05AB1E , 15 Bytes

0"D34çýQ"D34çýQ

Modifiziert das Standard - quine 0"D34çý"D34çý durch Hinzufügen Q(für die Gleichstellung mit der impliziten Eingabe prüfen)

Probieren Sie es online aus.

Erläuterung:

0                # Push 0 to the stack
                 #  STACK: [0]
 "D34çýQ"        # Push the string 'D34çýQ' to the stack
                 #  STACK: [0, 'D34çýIå']
         D       # Duplicate this string
                 #  STACK: [0, 'D34çýIå', 'D34çýIå']
          34ç    # Push '"' to the stack
                 #  STACK: [0, 'D34çýIå', 'D34çýIå', '"']
             ý   # Join the stack by this '"' delimiter
                 #  STACK: ['0"D34çýIå"D34çýIå']
              Q  # Check if it's equal to the (implicit) input
                 # (and output the top of the stack implicitly as result)

Coole 15- Byte- Alternative von @Grimy :

187745012D27BJQ

Probieren Sie es online aus.

Erläuterung:

187745012        # Push integer 187745012 
                 #  STACK: [187745012]
         D       # Duplicate it
                 #  STACK: [187745012, 187745012]
          27     # Push integer 27
                 #  STACK: [187745012, 187745012, 27]
            B    # Convert 187745012 to base-27
                 #  STACK: [187745012, "D27BJQ"]
             J   # Join the values on the stack together
                 #  STACK: ["187745012D27BJQ"]
              Q  # Check if it's equal to the (implicit) input
                 # (and output the top of the stack implicitly as result)

C - 186 176 Zeichen

Einzeiler:

 *a="*a=%c%s%c,b[999],c[999];main(){sprintf(b,a,34,a,34);gets(c);putchar(strcmp(b,c)?'0':'1');}",b[999],c[999];main(){sprintf(b,a,34,a,34);gets(c);putchar(strcmp(b,c)?'0':'1');}

Mit Leerzeichen (beachten Sie, dass dies das Programm bricht):

*a="*a=%c%s%c,b[999],c[999];main(){sprintf(b,a,34,a,34);gets(c);putchar(strcmp(b,c)?'0':'1');}",b[999],c[999];
main() {
  sprintf(b,a,34,a,34);
  gets(c);
  putchar(strcmp(b,c)?'0':'1');
}

Python 2 , 40 Bytes

s="print's=%r;exec s'%s==input()";exec s

Probieren Sie es online!

Stax , 26 Bytes

"34bLN26)s:f="34bLN26)s:f=

Führen Sie es aus und debuggen Sie es

q, 8 Bytes

{x~.z.s}

Gibt bei Eingaben, die mit den selbstreferenzierenden .zs übereinstimmen, einen booleschen Wert zurück

Runen , 11 Bytes

"3X4+kSqi=@

Probieren Sie es online!

TIO wurde aktualisiert und es gibt kein Problem mehr beim Lesen von Eingaben (und es ist kein abschließendes Leerzeichen mehr erforderlich).

Erläuterung

>                 Implicit entry
 "                Begin reading as string
  3X4+kSqi=@      Pushed to the stack as a string, loop around
 "                End reading as string
  3X4+            Push 3*10 and 4 to the stack, add them together
      k           Convert to character (")
       S          Swap the top two items on the stack
        q         Concatenate. This leaves only "3X4+kSqi=@ on the stack
         i        Read input
          =       Compare using .Equals, push 1 if equal, else 0
           @      Print and terminate

JoKings Lösung:

"'<~qi=@|

Erläuterung

  <              Entry
 '               Read character (loop around)
"                Push "
         |       Mirror
"                Begin reading string (loop around)
 '<~ri=@|        Push the string '<~qi=@| (loop around)
"                End reading string
 '<~             Push the character < and then discard it
    q            Concatenate, stack contains only "'<~qi=@|
      i          Read input
       =         Compare
        @        Print and terminate

R , 54 Bytes

f=function(s)s==paste0("f=function(s)s==", body(f)[3])

Probieren Sie es online!

body Ruft den Rumpf der Funktion ab (ein bisschen aufteilen, so dass body(f)[3] ist alles von paste0Anfang an möglich). Interessanterweise wird bodyder Code neu formatiert, Leerzeichen nach Kommas usw. hinzugefügt. Dies ist daher ein seltener Fall einer R-Golf-Antwort mit einem Leerzeichen nach einem Komma.

Dies funktioniert, da body(f)es sich um ein Objekt vom Typ languagehandelt und as.characterfür diesen Typ eine Methode vorhanden ist. Andererseits sind fund args(f)vom Typ closureund können, soweit ich das beurteilen kann, nicht in einen Zeichentyp konvertiert werden. Bitte fragen Sie mich nicht, wofür der Sprachtyp ist ...

PowerShell, 28 Byte

Sehr ähnlich zu dieser JavaScript-Antwort , verwendet Funktionsanbieter .

filter f{"$Function:f"-eq$_}

Beispiel

PS > '"$Function:f"-eq$_' | f
True

PS > 'xxx' | f
False