Data una stringa, restituisce se la stringa è una sottostringa del codice sorgente del programma.

Si applicano le regole quine standard, il che significa che non è possibile leggere il proprio codice sorgente. La lunghezza dell'input è garantita essere inferiore o uguale alla lunghezza del programma. È possibile restituire due valori distinti, non necessariamente valori di verità e falsità. Puoi anche inviare una funzione, piuttosto che un programma completo.

Questo è un code-golf quindi vince il codice più corto!

Un esempio

Se il codice sorgente è print(input() = False), dovrebbe restituire True per nt(ima False per tupn.

Python 2 , 41 byte

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

Provalo online!

JavaScript , 25 byte

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

Provalo online!

Personalmente non sono un fan di questo, ma è permesso .

Soluzione alternativa (non valida?), 19 byte

Questo accetta input come regex.

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

Provalo online!

Java 8, 124 112 byte (funzione)

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

Provalo qui.

Qui è invece come programma completo (per vedere uno dei motivi per cui le funzioni sono consentite su PPCG, perché alcune lingue, come Java, richiedono un codice boilerplate obbligatorio molto dettagliato per i programmi completi).

Java 8, 226 214 byte (programma 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]));}}

Provalo qui.

Spiegazione:

• Il String scontiene il codice sorgente non formattato.
• %sè usato per inserire questa stringa in se stessa con s.format(...).
• %c, %1$cE la 34vengono utilizzati per formattare le virgolette.
• s.format(s,34,s) mette tutto insieme.

E quindi .contains(...)viene utilizzato per verificare se questo codice sorgente contiene l'input specificato.

Bash, 43 , 28 byte

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

provalo online

Haskell , 92 byte

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

Provalo online! Estensione evidente del quine standard. Sbarazzarsi dell'importazione sarebbe bello, ma dubito che isInfixOfpossa essere calcolato in una quantità più breve di byte.

Wolfram Language (Mathematica) , 33 byte

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

Provalo online!

QBIC , 28 byte

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

Stampa 0 se l'input non è una sottostringa della sorgente e X altrimenti dove X è il (primo) indice della sottostringa.

Spiegazione

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

#definisce una stringa letterale in QBIC e la assegna alla prima variabile di stringa disponibile. Questo è B$in questo programma, perché A$è già preso da ;(leggi una stringa dalla riga cmd). Quindi, tutto fino al delimitatore viene inserito nel letterale; il delimitatore è un backtick - che lo rende anche l'unico carattere ASCII non includibile nei lits di stringhe. In questo caso, QBIC non ha bisogno di un backtick, poiché il valore letterale viene terminato alla fine del codice dalla funzione di chiusura automatica di QBIC. Per ulteriori informazioni sui letterali di QBIC, vedere il thread Showcase .

Gelatina , 10 byte

“;⁾vṾƓẇ”vṾ

Provalo online!

Come funziona

“;⁾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 byte

Ora capisco cosa intendono le persone quando affermano che i problemi di quine sono solo variazioni del quine classico.

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

Spiegazione

#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) byte

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

provalo online

05AB1E , 17 byte

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

Modifica del quine predefinito 0"D34çý"D34çýaggiungendo Iå.

Provalo online.

Spiegazione:

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)