Dada uma string, retorne se a string é uma substring do código fonte do programa.

Aplicam-se regras padrão de quine, o que significa que você não pode ler seu próprio código-fonte. A duração da entrada é garantida como menor ou igual à duração do programa. Você pode retornar dois valores distintos, não necessariamente valores de verdade e falsey. Você também pode enviar uma função, em vez de um programa completo.

Este é um código de golfe, então o código mais curto vence!

Um exemplo

Se o seu código-fonte for print(input() = False), ele deve retornar True para nt(imas False para tupn.

Python 2 , 41 bytes

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

Experimente online!

JavaScript , 25 bytes

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

Experimente online!

Pessoalmente, não sou fã disso, mas é permitido .

Solução alternativa (inválida?), 19 bytes

Isso leva a entrada como um regex.

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

Experimente online!

Java 8, 124 112 bytes (função)

p->{String s="p->{String s=%c%s%1$c;return s.format(s,34,s).contains(p);}";return s.format(s,34,s).contains(p);}

Experimente aqui.

Aqui está o programa completo (para ver uma das razões pelas quais as funções são permitidas no PPCG, porque algumas linguagens - como Java - requerem código padrão detalhado muito detalhado para programas completos).

Java 8, 226 214 bytes (programa completo)

interface M{static void main(String[]a){String s="interface M{static void main(String[]a){String s=%c%s%1$c;System.out.print(s.format(s,34,s).contains(a[0]));}}";System.out.print(s.format(s,34,s).contains(a[0]));}}

Experimente aqui.

Explicação:

• O String scontém o código fonte não formatado.
• %sé usado para inserir esta String em si mesma com o s.format(...).
• %c, %1$cE 34são usados para formatar as aspas.
• s.format(s,34,s) coloca tudo junto.

E então .contains(...)é usado para verificar se esse código fonte contém a entrada fornecida.

Bash, 43 , 28 bytes

[[ $BASH_COMMAND = *"$1"* ]]

experimente online

Haskell , 92 bytes

import Data.List;f s=isInfixOf s$(++)<*>show$"import Data.List;f s=isInfixOf s$(++)<*>show$"

Experimente online! Extensão óbvia do padrão quine. Livrar-se da importação seria bom, mas duvido que isInfixOfpossa ser calculado em uma quantidade menor de bytes.

Wolfram Language (Mathematica) , 33 bytes

!StringFreeQ[ToString[#0], #1] & 

Experimente online!

QBIC , 28 bytes

?instr(B+B,;)#?instr(B+B,;)#

Isso imprime 0 se a entrada não for uma substring da fonte e X, caso contrário, onde X é o (primeiro) índice da substring.

Explicação

Latter part:
#?instr(B+B,;)#   Define a string literal B$ with a copy of the source

First part:
?                 PRINT
 instr(   , )     the index of
           ;          the cmd line parameter A$
       B+B            in B$ concatenated with itself

#define um literal de sequência em QBIC e o atribui à primeira variável de sequência disponível. Isso está B$neste programa, porque A$já foi usado por ;(leia uma string da linha cmd). Então, tudo até o delimitador é alimentado no literal; o delimitador é um backtick - o que também o torna o único caractere ASCII não incluído nos lits de string. Nesse caso, o QBIC não precisa de um backtick, porque o literal é finalizado no final do código pelo recurso de fechamento automático do QBIC. Para obter mais informações sobre literais do QBIC, consulte o tópico Showcase .

Gelatina , 10 bytes

“;⁾vṾƓẇ”vṾ

Experimente online!

Como funciona

“;⁾vṾƓẇ”vṾ  Main link. No arguments.

“;⁾vṾƓẇ”    Set the left argument and the return value to ';⁾vṾƓẇ'.
         Ṿ  Uneval; yield '“;⁾vṾƓẇ”'.
        v   Dyadic eval; eval ';⁾vṾƓẇ' with argument '“;⁾vṾƓẇ”'.

  ⁾vṾ       Yield 'vṾ'.
 ;          Append it to '“;⁾vṾƓẇ”', yielding the source code.
     Ɠ      Read a string from STDIN.
      ẇ     Check if it's a substring of the source code.

Julia, 72 bytes

Agora entendo o que as pessoas querem dizer quando dizem que os problemas do quine são apenas variações do quine clássico.

x="~y=contains\"x=\$(repr(x));\$x\",y)";~y=contains("x=$(repr(x));$x",y)

Explicação

#Defines x to be the next line of the source, with the help of escaping characters
x="~y=contains\"x=\$(repr(x));\$x\",y)"; 
#Interpolates together a comparison string, including repr(x), the re-escaped from of x, and x itself, for comparison. 
~y=contains("x=$(repr(x));$x",y)

Perl 5, 60 + 2 (-pl) bytes

$_=(sprintf$a=q($_=(sprintf$a=q(%s),$a)=~/\Q$_/),$a)=~/\Q$_/

experimente online

05AB1E , 17 bytes

0"D34çýIå"D34çýIå

Modificação do quine padrão 0"D34çý"D34çýadicionando Iå.

Experimente online.

Explicação:

0                    # Push 0 to the stack
                     #  STACK: [0]
 "D34çýIå"           # Push the string 'D34çýIå' 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å']
               I     # Take the input
                     #  STACK: ['0"D34çýIå"D34çýIå', 'Iå"D']
                å    # Check if it's a substring of the source code
                     #  STACK [1]
                     # (Output the top of the stack implicitly)