Escreva um programa que gere uma saída "true" se a entrada corresponder ao código-fonte do programa e que gere uma saída "false" se a entrada não corresponder ao código-fonte do programa.

Esse problema pode ser descrito como relacionado a quines, pois o programa deve poder, de alguma forma, computar seu próprio código-fonte no processo.

Este é o código golf: regras padrão se aplicam. Seu programa não deve acessar arquivos especiais, como o arquivo de seu próprio código-fonte.

Editar: se você escolher, verdadeiro / falso pode ser substituído por Verdadeiro / Falso ou 1/0.

Exemplo

Se o código fonte do seu programa for bhiofvewoibh46948732));:/)4, aqui está o que seu programa deve fazer:

Entrada (Stdin)

bhiofvewoibh46948732));:/)4

Saída (saída padrão)

true

Entrada

(Anything other than your source code)

Resultado

false

JavaScript: 26

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

Não sei se um arquivo JavaScript realmente se qualifica como um "programa".

JavaScript ES6, 9 caracteres

Essa é a única maneira (de jogar golfe) em JS. ES6 faz com que seja necessário menos caracteres

Execute isso no console da Web mais recente do Firefox:

f=x=>f==x

Exemplo de uso:

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

Haskell, 72 caracteres

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

Nota: não há caracteres de fim de linha no final do script.

$ runhaskell Self.hs < Self.hs
True

GolfScript, 11 caracteres

{`".~"+=}.~

Sem o =, esse código seria um quine que gera seu próprio código-fonte como uma string. O =torna comparar esta cadeia para a sua entrada e saída 1se eles combinam e 0se não o fizerem. Observe que a comparação é exata - em particular, uma nova linha final no final da entrada fará com que ela falhe.

Explicação:

• { } é um literal de bloco de código no GolfScript;
• .duplica esse bloco de código e ~executa a segunda cópia (deixando a primeira na pilha);
• `especifica o bloco de código e ".~"+ anexa .~a ele;
• finalmente, =compara a sequência resultante com a entrada (que é empurrada na pilha como uma sequência pelo intérprete GolfScript antes do início do programa) e retorna 1se elas coincidem e 0se não coincidem .

Perl, Infinito 41 38 Personagens

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

Atualização: o programa não termina mais com uma nova linha, o que significa que funcionará corretamente em arquivos com várias linhas. Você deve inserir a entrada de STDIN sem pressionar Enter. No Windows, eu era capaz de fazer isso apenas lendo um arquivo.

Solução original:

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

Os peixes adoram comer cocô de peixe. Agora sabemos que eles podem distinguir os deles dos amigos.

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

Você pode experimentá-lo online !

Python 2, 55

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

Testado:

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

(anything else) -> False

JavaScript ES6, 16 14 bytes

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

Menos dois bytes, graças a Neil.

31 bytes se for necessário receber entrada via prompt.

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

38 bytes, se precisarmos enviar por alerta.

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

Essa é a maneira correta de fazer isso, pois a resposta do Optimizer não aceita todo o código-fonte.

Node.js: 54

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

Você o testará salvando-o em um arquivo f.js(o nome exato não tem importância) e usando

node f.js "test"

(que gera false) ou

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

(que gera true)

Eu também fiz uma versão diferente com base em eval:

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

Agora são 72 caracteres, tentarei encurtar isso quando tiver tempo.

Smalltalk (dialeto Pharo 2.0)

Implemente este método de 41 caracteres em String (formatação feia para code-golf):

isItMe^self=thisContext method sourceCode

Em seguida, avalie isso em um espaço de trabalho (printIt da maneira tradicional de Smalltalk)
A entrada não é lida a partir de stdin, é apenas uma String para a qual enviamos a mensagem (o que mais um programa poderia ter no Smalltalk?):

'isItMe^self=thisContext method sourceCode' isItMe.

Mas estamos enganando, o sourceCode lê algum arquivo de origem ...
Aqui está uma variante com 51 caracteres que não:

isItMe
    ^ self = thisContext method decompileString

E teste com:

'isItMe
    ^ self = thisContext method decompileString' isItMe

Se uma String em uma área de trabalho não for considerada uma entrada válida, vamos ver como usar algumas caixas de diálogo em 116 caracteres . Avalie
esta frase:

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

Como o formato de descompilação inclui CR e TAB, alteramos isso com SeparadoresCompactos.
Então pulamos os 7 primeiros caracteres 'doIt ^'

Finalmente, uma variante de 105 caracteres usando stdin, apenas interprete esta frase na linha de comando, apenas para se sentir mais mainstream:

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

flex - 312 caracteres

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

Provavelmente pode ser reduzido, mas funciona com entrada de várias linhas (necessária, pois o código fonte é várias linhas) e até mesmo para entradas que contêm o programa como uma substring. Parece que muitas das respostas até agora falham em uma ou em ambas.

Comando de compilação: flex id.l && gcc -lfl lex.yy.c

D (133 caracteres)

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+[])}

ligar i()e solicitará a entrada

GolfScript - 26

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

Inspirado em http://esolangs.org/wiki/GolfScript#Examples

Outra versão:

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

Pena que \é ao mesmo tempo trocar e escapar ...

Python 2, 47 bytes

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

Uma solução simples com a verificação adicionada.

CJam , 12 bytes

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

Experimente online!

Explicação

Isso apenas usa a estrutura padrão do CJam quine.

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

O que o bloco faz:

 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 caracteres

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

Perl, 52 caracteres

$_='$/=$\;$_="\$_=\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))

Cuidado para não adicionar nova linha no final. Alguém com melhor Python-fu pode ser capaz de reduzi-lo.

Casca , 11 bytes

=hS+s"=hS+s

Experimente online!

Explicação

A explicação usa ¨para delimitar seqüências de caracteres (para evitar escapamentos ilegíveis):

     "=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?

Ao remover a função, =você pode verificar se ela realmente corresponderá à própria fonte.

> <> , 24 bytes

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

Experimente online!

Quebrando literalmente a sequência de caracteres, seguido de verificação se a entrada é idêntica à pilha, com uma verificação final de que não há mais entrada.

Gelatina , 10 bytes

“Ṿ;$⁼”Ṿ;$⁼

Experimente 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

Modifica o quine padrão 0"D34çý"D34çýadicionando Q(verifique a igualdade com a entrada implícita)

Experimente online.

Explicação:

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)

Legal alternativa de 15 bytes fornecida pelo @Grimy :

187745012D27BJQ

Experimente online.

Explicação:

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 caracteres

Um forro:

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

Com espaço em branco (observe que isso interrompe o programa):

*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

Experimente online!

Stax , 26 bytes

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

Execute e depure

q, 8 bytes

{x~.z.s}

Retornar booleano na entrada correspondente ao .zs auto-referencial

Rúnico , 11 bytes

"3X4+kSqi=@

Experimente online!

O TIO foi atualizado e não há mais um problema de leitura de entrada (e não requer mais um espaço em branco à direita).

Explicação

>                 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

Solução da JoKing:

"'<~qi=@|

Explicação

  <              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])

Experimente online!

bodyobtém o corpo da função (dividindo-a um pouco, de modo que body(f)[3]é tudo a partir paste0de então). Curiosamente, bodyreformata o código, adicionando espaços após vírgulas, etc. Este é um caso raro de uma resposta de golfe R com um espaço após uma vírgula.

Isso funciona porque body(f)é um objeto do tipo languagee existe um as.charactermétodo para esse tipo. Por outro lado, fe args(f)são do tipo closure, e não podem ser convertidos em tipo de caractere até onde eu sei. Por favor, não me pergunte qual é o tipo de idioma…

PowerShell, 28 bytes

Muito parecido com esta resposta JavaScript , usa o provedor de funções .

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

Exemplo

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

PS > 'xxx' | f
False