Introducción

El desafío es crear un programa / función que imprima la intersección de su propio código fuente y una entrada de cadena dada. Este es el código de golf y para ser más precisos:

• Deje Iser el conjunto de entrada
  • {"a","b","c"}
• Dejar Sser el conjunto de código fuente
  • {"b","f"}
• Entonces la intersección es lo que comparten
  • I ∩ S = {"b"}

Entrada

La entrada es flexible. Debe poder manejar la codificación de caracteres utilizada para el código fuente.

Salida

La salida es flexible. Debe ser el conjunto de caracteres que comparten la entrada y el código fuente. Además, los conjuntos son colecciones desordenadas de objetos distintos. En resumen:

• La salida es flexible:
  • Podría ser cualquier estructura de datos (cadena o de otra manera)
  • Podría desordenada
  • Podría tener un final \n
  • Debe ser distinto

Restricción

Similar a los desafíos de quine , el programa / función puede no leer su propio código fuente y no se permiten soluciones de 0 bytes.

Ejemplos

• # 1

functor x(I){ return I ∩ self; }

Inputs                                Outputs
------                                -------
enter preformatted text here      ->  {"e","n","t","r","f","o","x"}

["Albrt"," Einstin"]              ->  {"l","r","t","n","s"}

• # 2

(_)->_&"(_)->&\"\\"

Inputs                                Outputs
------                                -------
"Security at the expense of       ->  "
usability comes at the expense 
of security."

(0____0)                          ->  (_)

• # 3

ಠa益длф


Inputs                                Outputs
------                                -------
Far out in the uncharted backwaters ->"a"    
of the unfashionable end of the 
Western Spiral arm of the Galaxy lies 
a small unregarded yellow sun. 
Orbiting this at a distance of roughly 
ninety-eight million miles is an 
utterly insignificant little blue-green 
planet whose ape-descended life forms 
are so amazingly primitive that they 
still think digital watches are a pretty 
neat idea.

(ノಠ益ಠ)ノ彡┻━┻                      ->"ಠ益"

Casos de prueba

Albert Einstein

\__( O__O)_/

!@#$%^&*()_+{}|:"<>?

1234567890-=[]\;',./

(ノಠ益ಠ)ノ彡┻━┻

“¤>%,oỊȤʠ“ØụĊ5D³ṃṠɼQ»j;Ç;“;}¶”

┬──┬ ノ( ゜-゜ノ)

Far out in the uncharted backwaters of the unfashionable end of the Western Spiral arm of the Galaxy lies a small unregarded yellow sun. Orbiting this at a distance of roughly ninety-eight million miles is an utterly insignificant little blue-green planet whose ape-descended life forms are so amazingly primitive that they still think digital watches are a pretty neat idea.

Actualizar

• [16-08-10]: los conjuntos son colecciones desordenadas de objetos distintos
• [16-08-10]: la nueva línea final es aceptable

Jalea , 10 6 bytes

“Ṿf”Ṿf

Pruébalo en línea!

Cómo funciona

“Ṿf”Ṿf  Main link. Argument: s (string)

“Ṿf”    Set the return value to 'Ṿf'.
    Ṿ   Uneval; yield '“Ṿf”'.
     f  Filter; remove the characters from '“Ṿf”' that do not appear in s.

Python 3, 44 bytes

Gracias Karl por salvarme un byte :-) ¡Gracias Dada por salvarme dos bytes!

Creo que esto funciona, pero es mi primer desafío quine, así que no estoy 100% seguro. : \

print(set("printseu()&'"+'+"')&set(input()))

Versión Lambda con 43 bytes: lambda a:set(" lambdaset()&'"+':+"')&set(a)

Dyalog APL , 8 bytes

'∩''⊢'∩⊢

∩is devuelve los caracteres del argumento izquierdo que están presentes en el argumento derecho (si el argumento izquierdo no tiene duplicados, como en este caso, entonces el resultado tampoco tiene duplicados

⊢ es el argumento

Luego, la cadena solo tiene esos dos más el carácter de comillas (duplicado, ya que está en una cadena).

TryAPL en línea!

GolfScript, 6 bytes

"`&"`&

Pruébalo en línea!

Cómo funciona

        # (implicit) Push the input on the stack.
"`&"    # Push the string '`&' on the stack.
   `    # Inspect; turn the string into '"`&"'.
     &  # Perform set intersection.

Python 2, 56 46 39 Bytes

-1 Byte gracias a @Jeremy

lambda a:set(':&()smelt\ bad\'')&set(a)

función lambda anónima, toma una cadena, devuelve un conjunto

versión antigua:

lambda x,w=set('newmatrixbuspdl_:-)(=,\ \''):w-(w-set(x))

Perl 6 , 56, 55 bytes

Versión " francesa " / Unicode (55 bytes)

say perl q.say perlq∩$*IN\\\.comb:..comb∩$*IN.comb:

Versiones " Texas " / ASCII (56 bytes)

say (q.sayq(&) $*IN\\\.combperl..comb (&)$*IN.comb).perl

say perl q.sayq(&) $*IN\\\.comb:perl..comb (&)$*IN.comb:

No golfizado:

my \Source = 'my \\Source = \'say ( $*IN.comb.Set ∩ Source.comb.Set ).perl\'';
say ( $*IN.comb.Set ∩ Source.comb.Set ).perl

Ejemplos:

$ echo -n 'say perl q.say perlq∩$*IN\\\.comb:..comb∩$*IN.comb:' > test-unicode.p6

$ echo -n 'say (q.sayq(&) $*IN\\\.combperl..comb (&)$*IN.comb).perl' > test-ascii.p6

$ perl6 test-ascii.p6 <<< 'abcdefghijklmnopqrstuvwxyz'
set("p","a","l","r","c","q","b","s","e","m","y","o")

$ perl6 test-unicode.p6 < test-unicode.p6
set("\\","I","p"," ","a","c","l","r","q","b","∩","*","s","m","e",".","y",":","o","N","\$")

$ perl6 test-ascii.p6 < test-ascii.p6
set("p","\\","I"," ","a","l","r","c","q","b",")","*","s","e","m","\&",".","(","y","o","N","\$")

$ perl6 test-ascii.p6 < test-unicode.p6
set("p","\\","I"," ","a","l","r","c","q","b","*","s","e","m",".","y","o","N","\$")

$ perl6 test-unicode.p6 <<< 'Albert Einstein'
set(" ","l","r","b","s","e")

$ perl6 test-unicode.p6 <<< '\__( O__O)_/'
set("\\"," ")

$ perl6 test-ascii.p6 <<< '!@#$%^&*()_+{}|:"<>?'
set(")","*","\&","(","\$")

$ perl6 test-unicode.p6 <<< "1234567890-=[]\\;',./"
set("\\",".")

$ perl6 test-unicode.p6 <<< '(ノಠ益ಠ)ノ彡┻━┻'
set()

“¤>%,oỊȤʠ“ØụĊ5D³ṃṠɼQ»j;Ç;“;}¶”
set("o")

$ perl6 test-unicode.p6 <<< '┬──┬ ノ( ゜-゜ノ)'
set(" ")


$ perl6 test-ascii.p6 <<< 'Far out in the uncharted backwaters of the unfashionable end of the Western Spiral arm of the Galaxy lies a small unregarded yellow sun. Orbiting this at a distance of roughly ninety-eight million miles is an utterly insignificant little blue-green planet whose ape-descended life forms are so amazingly primitive that they still think digital watches are a pretty neat idea.'
set("p"," ","a","l","r","c","b","s","e","m",".","y","o")

MATL , 8 bytes

'X&'''X&

Pruébalo en línea!

La entrada es una cadena entre comillas simples. Si la cadena contiene un símbolo de comillas simples, debe duplicarse para escapar de ella.

Explicación

'X&'''   % Push string with the three characters used by the program. The single-quote 
         % symbol needs to be escaped by duplicating it
X&       % Take input implicitly. Set intersection. Display implicitly

En realidad, 6 bytes

`∩è`è∩

Pruébalo en línea!

Explicación:

`∩è`è∩
`∩è`    push the function `∩è` (which contains every character in the source code except '`')
    è   repr (same as Python repr - leaves "`∩è`", which contains every character in the source code)
      ∩ set intersection with input

Haskell (30 bytes)

Esta es una solución tan aburrida ... Pero no podría hacerlo mejor. :(

filter(`elem`"f(term)\"i`l\\")

Brachylog , 23 bytes

:{e.~e":{}e~\"fd\."}fd.

Pruébalo en línea!

Explicación

:{                 }f      Find all chars that verify the predicate below
                     d.    Remove duplicates and output

  e.                       Take a char from the input ; this is our output…
    ~e":{}e~\"fd\."        … if that char is in the string :{}e~"fd. (the first \ is here
                               to escape the ")

05AB1E , 11 bytes

Código:

"'ÃJÙ"'"JÃÙ

Utiliza la codificación CP-1252 . Pruébalo en línea! .

C, 142 bytes

main(i){char*p,a[]="remain([*]){fought?>:01;,\\\"=capsv+-l}";for(;(i=getchar())>=0;p?putchar(i),memmove(p,p+1,a+strlen(a)-p):0)p=strchr(a,i);}

Pruébalo con ideone .

CJam, 8 bytes

"`q&"`q&

Pruébalo aquí.

Explicación:

"`q&"    e# Push that string to the stack
     `   e# Stringify, pops the string and pushes "\"`r&\"" to the stack
      q  e# Pushes the input to the stack
       & e# Union, pops two elements and pushes a list of every element that is contained in both.

Pyth , 9 8 bytes

1 byte gracias a Sp3000

@Q"\Q@\"

Pruébalo en línea!

@Q"\Q@\"
@Q"\Q@\""   implicit string ending

@Q           intersect the input with
  "\Q@\""   the string containing '\', 'Q', '@', '"'.

Retina, 21 20 bytes

Elimina los caracteres que no están en el código fuente, luego elimina los caracteres duplicados.

[^Ds.n\n[-a_-]

Ds`.

Pruébalo en línea

Mathematica, 35 bytes

Characters@"\"#&@C\acehrst⋂"⋂#&

Función anónima. Ignora cualquier mensaje generado. Toma una lista de caracteres como entrada y devuelve una lista de caracteres como salida. El carácter Unicode es U + 22C2 para \[Intersection].

C #, 36 bytes

s=>s.Intersect("s=>.Interc(\"\\);");

La conversión prevista es Func<string, IEnumerable<char>>( stringentrada, IEnumerable<char>salida).

Vim, 78 68 78 79 61 pulsaciones de teclas

Cambié completamente mi enfoque:

oo/\$kjxd<esc>/o<cr>xj$/\/<cr>xj$/\\<cr>xj$/$<cr>xj$/k<cr>xj$/x<cr>xj$/j<cr>xj$/d<cr>xkdd

Cómo funciona:

Primero, hace una línea con todos los caracteres del programa, luego, encuentra la primera instancia de cada uno de los caracteres del programa, que está en la entrada, si la entrada y la salida se cruzan, o la salida si no lo hacen, elimina se mueve al último carácter del archivo (de modo que se envuelve) y lo hace para cada carácter único en la fuente, excepto d, donde, en lugar de moverse al final del archivo, termina eliminando la entrada

Bash , 45 50 41 39 37 34 29 bytes

-9 bytes gracias a Geoff Reedy
-4 bytes gracias a Dennis
-5 bytes gracias a Nahuel Fouilleul

grep -o '[] [|\'\'grepouniq-]

Pruébalo en línea!

PowerShell v4 +, 122104 bytes

([char[]]($args[0]+'acegfhmnoprstu012|][()"?+_,.$-{0}{1}{2}'-f("'","}","{"))|group|?{$_.count-gt1}).name

Ugh Quines o código similar a quine en PowerShell apesta, porque el formato de reemplazo de cadena es muy torpe.

La cadena ace...{2}en el medio es cada carácter que está presente en el resto del código. El {0}{1}{2}se utiliza junto con el -foperador ormat para extraer los '{}caracteres en la cadena.

Eso se combina como una matriz de caracteres con la entrada $args, luego se alimenta a la tubería. La primera parada es Group-Objectqué (esencialmente) crea una tabla hash de los objetos de entrada y cuántas veces ocurren en la entrada. Eso es canalizado a |?{...}la Where-Objectúnica seleccionar aquellos elementos que tienen un .countmayor que 1. Encapsulamos eso en parens y extraemos la .Nameparte de la tabla hash (que es donde entra en juego el requisito v4 +, de lo contrario necesitaríamos una |Select Nameetapa adicional en la tubería).

Esos elementos se dejan en la tubería (como una matriz), y la impresión está implícita.

Python 2, 44 bytes

x='c=set;print c(`x`)&c(raw_input())';exec x

Solo por diversión, aquí hay una presentación completa del programa tipo quine. Emite la representación de cadena de un conjunto de Python 2.

JavaScript (ES6), 59 57 bytes

f=
t=>[..."\"().=>O[\\]defilnrtx~"].filter(e=>~t.indexOf(e))
;

<input placeholder=Input oninput=o.value=f(this.value).join``><input placeholder=Output id=o>

Devuelve una matriz de caracteres presentes tanto en la cadena original / matriz de caracteres como en el código fuente. Editar: Guardado 2 bytes gracias a @ user81655.

Matlab, 37 bytes

Bastante sencillo:

Utiliza el incorporado intersectpara encontrar la intersección. El código fuente está codificado. La entrada debe ser entre comillas''

intersect(input(''),'''intersc(pu),')

JavaScript (Chrome 58 en OS X 10), 12654 12426 11992 Bytes

https://paste.ubuntu.com/25593218/

https://paste.ubuntu.com/25595798/

https://paste.ubuntu.com/25595831/

El código original:

var t=prompt();"!+()[]".split("").forEach(function(f){if(t.includes(f))alert(f)})

Esto se convirtió en un estilo de programación llamado jsfk que solo usa estos seis caracteres:

(+)[!] 

utilizando un compilador en línea.

R, 129 bytes

f=function(s){b=strsplit("f=unctio(s){arpl;,[1]b\\\"qemh0T}",c())[[1]];cat(b[unique(pmatch(strsplit(s,c())[[1]],b,0,T))],sep="")}

Si lo elimino, es necesario que cambien las cosas raras como una nueva línea en la cadena b. De todos modos, es súper simple: construye un vector con todos los caracteres en la función. Luego, extrae la entrada en un vector y verifica la membresía.

Ruby, 34 + nbandera = 35 bytes

No funciona exactamente con entradas de líneas múltiples, ya que -nhace que el programa procese STDIN línea por línea. No hay líneas nuevas en este código, pero tratar de ingresar algo como eso generará múltiples matrices en lugar de una. Si eso no es bueno de acuerdo con las especificaciones, infórmeme y lo arreglaré.

p $_.chars&"\\\"p $_.chars&".chars

ListSharp , 222 bytes

STRG S=READ[<here>+"\\S.txt"]
ROWS T=ROWSPLIT S BY [""]
ROWS R=ROWSPLIT "STRG =EAD[<her>+\".tx]OWPLIBYCFMHVNc#isn()oay\r\n" BY [""]
ROWS R=SELECT FROM T WHERE[EVERY STRG IS ANY STRG IN R]
SHOW=<c#R.Distinct().ToArray()c#>

ridículo pero estoy entretenido

sed, 47 caracteres

:s;st[^])(*\1.s2t:[;^]tt;st\(.\)\(.*\1\)t\2t;ts

Estoy un poco decepcionado por cuánto tiempo resultó ser esto, especialmente el poco para eliminar los caracteres repetidos.

Java 8 lambda, 152 142 140 caracteres

Bastante corto:

s->s.chars().mapToObj(i->(char)i).filter(c->"COSTab\"\\cefh(i)j+l-mn.oprstuv>".contains(""+c)).collect(java.util.stream.Collectors.toSet())

O sin golf por aquí:

public class Q89400 {

    static Set<Character> inAndQuine(String in) {
        return in.chars()
                .mapToObj(i->(char)i)
                .filter(c->"COSTab\"\\cefh(i)j+l-mn.oprstuv>".contains(""+c))
                .collect(java.util.stream.Collectors.toSet());

    }
}

Por supuesto, la solución no correcta es incorrecta, ya que no coincide con las llaves y algunos caracteres más, es solo por su integridad.

La función toma la entrada como a Stringy devuelve un que java.util.Set<Character>contiene los caracteres que están presentes tanto en la entrada como en la fuente.

Actualizaciones

Resultó que la solución no estaba funcionando. Pensé que las String#containspruebas para una coincidencia de expresiones regulares, pero es solo una coincidencia literal. Agregué algunos escapes para citar los personajes, .pero esto no fue necesario, pero arruiné todo en su lugar. Ahora, sin este escape, guardamos algunos caracteres y ahora realmente funciona :)

Gracias a @NonlinearFruit por recordarme el uso de variables de un carácter.

SQF , 71 69 64 bytes

Usando el formato de archivo como función:

i="-_h ;""=()sSplitrng"splitString"";i-(i-(_this splitString""))

Llamar como "STRING" call NAME_OF_COMPILED_FUNCTION