[Question]
  [
## Intro
The challenge is to create a program/function that prints the intersection of its own source code and a given string input. This is code golf and to be more precise:
* Let `I` be the input set
	+ `{"a","b","c"}`
* Let `S` be the source code set
	+ `{"b","f"}`
* Then the intersection is what they share
	+ `I ∩ S = {"b"}`
## Input
Input is flexible. It should be able to handle the character encoding used for the source code.
## Output
Output is flexible. It should be the set of characters that the input and source code share. Also, [sets](https://en.wikipedia.org/wiki/Set_(mathematics)) are unordered collections of distinct objects. In summary:
* Output is flexible:
	+ Could be any data structure (string or otherwise)
	+ Could unordered
	+ Could have a trailing `\n`
	+ Should be distinct
## Restriction
Similar to [quine](/questions/tagged/quine "show questions tagged 'quine'") challenges, the program/function may not read its own source code and 0-byte solutions are not allowed.
## Examples
* **#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.
(ノಠ益ಠ)ノ彡┻━┻                      ->"ಠ益"
```
## Test Cases
```
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.
```
**Update**
* [16-08-10]: [sets](https://en.wikipedia.org/wiki/Set_(mathematics)) are unordered collections of distinct objects
* [16-08-10]: trailing newline is acceptable
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~10~~ 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
“Ṿf”Ṿf
```
[Try it online!](http://jelly.tryitonline.net/#code=4oCc4bm-ZuKAneG5vmY&input=&args=J-KAnOG5vmbigJ3hub5mIGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6Jw)
### How it works
```
“Ṿ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.
```
[Answer]
## Python 3, 44 bytes
Thanks Karl for saving me one byte :-)
Thanks Dada for saving me two bytes!
I think this works, but it's my first quine challenge so I'm not 100% sure. :\
```
print(set("printseu()&'"+'+"')&set(input()))
```
Lambda version with 43 bytes:
`lambda a:set(" lambdaset()&'"+':+"')&set(a)`
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 8 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319)
```
'∩''⊢'∩⊢
```
`∩` is returns those characters from the left argument that are present in the right argument (if the **left** argument has no duplicates – as in this case – then the result also has no duplicates
`⊢` is the argument
Then the string just has those two plus the quote character (doubled, as it is in a string).
[TryAPL online!](http://tryapl.org/?a=%28%27%u2229%27%27%u22A2%27%u2229%u22A2%29%A8%27functor%20x%28I%29%7B%20return%20I%20%u2229%20self%3B%20%7D%27%20%271234567890-%3D%5B%5D%5C%3B%27%27%2C./%27%20%27%5C__%28%20O__O%29_/%27&run)
[Answer]
# GolfScript, 6 bytes
```
"`&"`&
```
[Try it online!](http://golfscript.tryitonline.net/#code=ImAmImAm&input=ImAmImAmIDEyMzQ1Njc4OTA)
### How it works
```
        # (implicit) Push the input on the stack.
"`&"    # Push the string '`&' on the stack.
   `    # Inspect; turn the string into '"`&"'.
     &  # Perform set intersection.
```
[Answer]
# Python 2, ~~56~~ ~~46~~ 39 Bytes
*-1 Byte thanks to @Jeremy*
```
lambda a:set(':&()smelt\ bad\'')&set(a)
```
anonymous lambda function, takes a string, returns a set
old version:
```
lambda x,w=set('newmatrixbuspdl_:-)(=,\ \''):w-(w-set(x))
```
[Answer]
# [Perl 6](http://perl6.org), 56, 55 bytes
**"*French*" / Unicode version** (55 bytes)
```
say perl q.say perlq∩$*IN\\\.comb:..comb∩$*IN.comb:
```
**"*Texas*" / ASCII versions** (56 bytes)
```
say (q.sayq(&) $*IN\\\.combperl..comb (&)$*IN.comb).perl
```
```
say perl q.sayq(&) $*IN\\\.comb:perl..comb (&)$*IN.comb:
```
# Non-golfed:
```
my \Source = 'my \\Source = \'say ( $*IN.comb.Set ∩ Source.comb.Set ).perl\'';
say ( $*IN.comb.Set ∩ Source.comb.Set ).perl
```
# Examples:
```
$ 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")
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 8 bytes
```
'X&'''X&
```
[**Try it online!**](http://matl.tryitonline.net/#code=J1gmJycnWCY&input=J0xldHRlciAnJ1gnJyBpcyBYLXRyYSBmdW4hJw)
Input is a string enclosed in single quotes. If the string contains a single-quote symbol, it should be duplicated to escape it.
### Explanation
```
'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
```
[Answer]
## Actually, 6 bytes
```
`∩è`è∩
```
[Try it online!](http://actually.tryitonline.net/#code=YOKIqcOoYMOo4oip&input=ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6XCInYCI)
Explanation:
```
`∩è`è∩
`∩è`    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
```
[Answer]
# 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);}
```
[Try it on ideone](http://ideone.com/sdlhRR).
[Answer]
# Haskell (30 bytes)
This is such a boring solution... But I couldn't do better. :(
```
filter(`elem`"f(term)\"i`l\\")
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 23 bytes
```
:{e.~e":{}e~\"fd\."}fd.
```
[Try it online!](http://brachylog.tryitonline.net/#code=OntlLn5lIjp7fWV-XCJmZFwuIn1mZC4&input=IiFAIyQlXiYqKClfK3t9fDpcIjw-PzpcOiI&args=Wg)
### Explanation
```
:{                 }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 ")
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 11 bytes
Code:
```
"'ÃJÙ"'"JÃÙ
```
Uses the **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=IifDg0rDmSInIkrDg8OZ&input=SGVsbG8sICInw4NKIiciSsODLCBXb3JsZCE).
[Answer]
# CJam, 8 bytes
```
"`q&"`q&
```
[Try it here.](http://cjam.aditsu.net/#code=%22%60r%26%22%60r%26)
Explanation:
```
"`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.
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~9~~ 8 bytes
**1 byte thanks to Sp3000**
```
@Q"\Q@\"
```
[Try it online!](http://pyth.herokuapp.com/?code=%40Q%22%5CQ%40%5C%22&input=%22+%21%5C%22%23%24%25%26%27%28%29%2a%2B%2C-.%2F0123456789%3A%3B%3C%3D%3E%3F%40ABCDEFGHIJKLMNOPQRSTUVWXYZ%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz%7B%7C%7D~+%21%5C%22%23%24%25%26%27%28%29%2a%2B%2C-.%2F0123456789%3A%3B%3C%3D%3E%3F%40ABCDEFGHIJKLMNOPQRSTUVWXYZ%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz%7B%7C%7D~%22&debug=0)
```
@Q"\Q@\"
@Q"\Q@\""   implicit string ending
@Q           intersect the input with
  "\Q@\""   the string containing '\', 'Q', '@', '"'.
```
[Answer]
# Retina, ~~21~~ 20 bytes
Removes characters not in the source code, then removes duplicate characters.
```
[^Ds.n\n[-a_-]
Ds`.
```
[**Try it online**](http://retina.tryitonline.net/#code=W15Ecy5uXG5bLWFfLV0KCkRzYC4&input=RApgCl4Kbg)
[Answer]
# Mathematica, 35 bytes
```
Characters@"\"#&@C\acehrst⋂"⋂#&
```
Anonymous function. Ignore any generated messages. Takes a list of characters as input and returns a list of characters as output. The Unicode character is U+22C2 for `\[Intersection]`.
[Answer]
# C#, 36 bytes
```
s=>s.Intersect("s=>.Interc(\"\\);");
```
Intended cast is `Func<string, IEnumerable<char>>` (`string` input, `IEnumerable<char>` output).
[Answer]
# Vim, ~~78 68 78 79~~ 61 keystrokes
Completely changed my approach:
```
oo/\$kjxd<esc>/o<cr>xj$/\/<cr>xj$/\\<cr>xj$/$<cr>xj$/k<cr>xj$/x<cr>xj$/j<cr>xj$/d<cr>xkdd
```
How it works:
First, it makes a line with all the program characters, then, it finds the first instance of each of the program characters, which is either in the input, if the input and output intersect, or the output if they don't, deletes it, moves to the last character of the file (so it wraps around) and does that for each unique character in source, except d, where instead of moving to the end of the file, it finishes up by deleting the input
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~45 50 41 39 37 34~~ 29 bytes
-9 bytes thanks to Geoff Reedy  
-4 bytes thanks to Dennis  
-5 bytes thanks to Nahuel Fouilleul
```
grep -o '[] [|\'\'grepouniq-]
```
[Try it online!](https://tio.run/##S0oszvj/P70otUBBN19BPTpWIbomRj1GHSSSX5qXWagb@/9/anpBUWIMAA "Bash – Try It Online")
[Answer]
## PowerShell v4+, ~~122~~ 104 bytes
```
([char[]]($args[0]+'acegfhmnoprstu012|][()"?+_,.$-{0}{1}{2}'-f("'","}","{"))|group|?{$_.count-gt1}).name
```
Ugh. Quines or quine-like code in PowerShell sucks, because the string replacement formatting is so clunky.
The string `ace...{2}` in the middle is every character that's present in the rest of the code. The `{0}{1}{2}` is used in conjunction with the `-f`ormat operator to pull the `'{}` characters into the string.
That's combined as a char-array with the input `$args`, then fed into the pipeline. The first stop is `Group-Object` which (essentially) creates a hashtable of the input objects and how many times they occur in the input. That's piped to `|?{...}` the `Where-Object` to only select those items that have a `.count` greater than `1`. We encapsulate that in parens, and pluck out the `.Name` portion of the hashtable (which is where the v4+ requirement comes into play, otherwise we'd need an additional `|Select Name` stage to the pipeline).
Those elements are left on the pipeline (as an array), and printing is implicit.
[Answer]
## Python 2, 44 bytes
```
x='c=set;print c(`x`)&c(raw_input())';exec x
```
Just for fun, here's a quine-like full program submission. Outputs the string representation of a Python 2 set.
[Answer]
## 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>
```
Returns an array of characters present in both the original string/character array and the source code. Edit: Saved 2 bytes thanks to @user81655.
[Answer]
# Matlab, 37 bytes
Quite simple:
Uses the builtin `intersect` to find the intersection. The source code is hard coded. Input must be given inside quotation marks `''`
```
intersect(input(''),'''intersc(pu),')
```
[Answer]
## sed, 47 characters
```
:s;st[^])(*\1.s2t:[;^]tt;st\(.\)\(.*\1\)t\2t;ts
```
I'm a little disappointed at how long this came out to be, especially the bit to remove repeated characters.
[Answer]
# JavaScript (Chrome 58 on OS X 10), ~~12654~~ ~~12426~~ 11992 Bytes
~~<https://paste.ubuntu.com/25593218/>~~
~~<https://paste.ubuntu.com/25595798/>~~
<https://paste.ubuntu.com/25595831/>
The original code:
```
var t=prompt();"!+()[]".split("").forEach(function(f){if(t.includes(f))alert(f)})
```
This was then converted into a programming style called jsfk which only uses these six characters: 
```
(+)[!] 
```
using an online compiler.
[Answer]
# 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="")}
```
If I ungolf it, it needs to have weird things changed like a newline in the string for `b`. Anyhow, its super simple -- builds a vector with all characters in the function in it. Then it pulls the input into a vector, and checks membership.
[Answer]
# Ruby, 34 + `n` flag = 35 bytes
Doesn't exactly work with multi-lined input, since `-n` causes the program to process STDIN line-by-line. There aren't newlines in this code, but trying to input something like that will output multiple arrays instead of one. If that is not good according to spec, please inform me and I will fix.
```
p $_.chars&"\\\"p $_.chars&".chars
```
[Answer]
## [ListSharp](https://github.com/timopomer/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#>
```
***ridiculous but im entertained***
[Answer]
## Java 8 lambda, ~~152~~ ~~142~~ 140 characters
Quite short:
```
s->s.chars().mapToObj(i->(char)i).filter(c->"COSTab\"\\cefh(i)j+l-mn.oprstuv>".contains(""+c)).collect(java.util.stream.Collectors.toSet())
```
Or ungolfed over here:
```
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());
    }
}
```
Of course the ungolfed solution is wrong, as it doesn't match the curly brackets and some more characters, it's just their for the sake of completeness.
The function takes input as a `String` and returns a `java.util.Set<Character>` containing the characters which are present in both input and source.
**Updates**
It turned out that the solution wasn't working. I thought `String#contains` tests for a regex match but it is just a literal matching. I added some escaping to quote the characters like `.` but this wasn't necessary but ruined everything instead. Now without this escaping we save some characters and now it actually works :)
Thanks to @NonlinearFruit for reminding me of using one-character variables. 
[Answer]
# [SQF](https://community.bistudio.com/wiki/SQF_syntax), ~~71~~ ~~69~~ 64 bytes
Using the file-as-a-function format:
```
i="-_h ;""=()sSplitrng"splitString"";i-(i-(_this splitString""))
```
Call as `"STRING" call NAME_OF_COMPILED_FUNCTION`
]