[Question]
  [
In this challenge, given a list of ghosts from Pac-Man, you must output which ghosts are missing. You must do it in as few bytes as you can
## Input
Input will consist of a string or list, which will include a number ghosts, which could include:
* Blinky
* Inky
* Pinky
* Clyde
However, input may also include Pac-Man (with that punctuation). So, the maximum amount of items in a list will be five, in any order. It can be assumed that no invalid items will be in the list
## Output
Output will consist of a string, or list. This will include of all the ghosts that are not in the input, in any order. However, if Pac-Man is in the input, all ghosts will be considered missing (because he eats them).
## Test cases
```
input: Clyde
output: Blinky, Inky, Pinky
alternate output: Inky, Pinky, Blinky
or one of the other 4 permutations
input: Clyde, Blinky # or however you delimit it
output: Inky, Pinky
alt: Pinky, Inky
input: Pac-Man, Clyde
Output: Blinky, Inky, Pinky, Clyde
or you could output one of the other 23 permutations
input:[null]
Output: Blinky, Inky, Pinky, Clyde
or you could output one of the other 23 permutations
```
This is codegolf, so the lower the bytecount, the better.
  
[Answer]
## [Retina](https://github.com/m-ender/retina), 45 bytes
```
A`-
$
,;BliNClyde,INPiN
N
nky,
D`\w+,
.*;|,$
```
The trailing linefeed is significant. Input and output are comma separated.
[Try it online!](http://retina.tryitonline.net/#code=JShHYApBYC0KJAosO0JsaU5DbHlkZSxJTlBpTgpOCm5reSwKRGBcdyssCi4qO3wsJAo&input=Q2x5ZGUKQ2x5ZGUsQmxpbmt5ClBhYy1NYW4sQ2x5ZGUK) (The first line enables a linefeed-separated test suite.)
### Explanation
I did not expect to be able to show off Retina's latest addition (deduplication stages) so soon, but it's really helpful for this challenge. :)
**Stage 1: Anti-Grep**
```
A`-
```
Anti-grep stages discard all lines that match the given regex. The regex is just `-` and the input is always a single line, so this discards all ghosts if the input contains `Pac-Man`.
**Stage 2: Substitution**
```
$
,;BliNClyde,INPiN
```
This simply appends the fixed string `,;BliNClyde,INPiN`. This will be the list of ghosts in the output after some clean-up.
**Stage 3: Substitution**
```
N
nky,
```
Note that we've written the three `*nky` ghosts with an `N` in the previous stage (and omitted the comma after them), and we now expand this shorthand, which saves a couple of bytes. There is now a comma after every single ghost, and we've got the input ghosts and list of all ghosts separated by a semicolon.
**Stage 3: Deduplication**
```
D`\w+,
```
This is the new part. Deduplication stages find all instances of the given regex and discard all matched substrings which are equal to an earlier matched substring. The regex simply matches all the ghosts, both in the input and in the list of potential outputs. If the input contains a ghost, then the same ghost will be matched again in the second list and is discarded. Otherwise, the ghost is matched for the first time in the second list and kept. So after this, the list after the semicolon is our desired output. All that's left is a bit of clean-up:
**Stage 5: Substitution**
```
.*;|,$
```
We simply match everything up to the semicolon as well as the comma at the end of the string and remove them.
[Answer]
## Python 3, 75 bytes
```
lambda s:[x for x in['Blinky','Inky','Pinky','Clyde']if(x in s)<1or'-'in s]
```
Input is a comma-separated string, and the output will be a list.
[Answer]
# JavaScript ES6, ~~85~~ 78 bytes
As an anonymous function
```
a=>["Blinky","Inky","Pinky","Clyde"].filter(c=>!a.includes(c)|a.some(v=>v[6]))
```
Today I learned about this `filter` function. Fun!
15 bytes saved thanks to Neil.
Usage:
```
(a=>["Blinky","Inky","Pinky","Clyde"].filter(c=>!a.includes(c)||a.includes("Pac-Man")))(["Pac-Man"])
> ["Blinky","Inky","Pinky","Clyde"]
(a=>["Blinky","Inky","Pinky","Clyde"].filter(c=>!a.includes(c)||a.includes("Pac-Man")))(["Pinky"])
> ["Blinky","Inky","Clyde"]
(a=>["Blinky","Inky","Pinky","Clyde"].filter(c=>!a.includes(c)||a.includes("Pac-Man")))([])
> ["Blinky","Inky","Pinky","Clyde"]
```
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), ~~25~~ 22 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Ff‚Äù-»Ø‚Å∏‚ÄúJLKq·∏§·π¢&F‚Åªƒ±¬ª·π£‚Å∂¬§·∏ü
```
This is a monadic function. I/O is in form of lists. [Try it online!](http://jelly.tryitonline.net/#code=RmbigJ0tyK_igbjigJxKTEtx4bik4bmiJkbigbvEscK74bmj4oG2wqThuJ8Kw4figqxH&input=&args=WydDbHlkZSddLCBbJ0NseWRlJywgJ0JsaW5reSddLCBbJ1BhYy1NYW4nLCAnQ2x5ZGUnXSwgW10)
### How it works
```
Ff‚Äù-»Ø‚Å∏‚ÄúJLKq·∏§·π¢&F‚Åªƒ±¬ª·π£‚Å∂¬§·∏ü  Monadic link. Argument: A (list of strings)
F                       Flatten A.
 f‚Äù-                    Filter it with the string "-" to detect "Pac-Man".
    »Ø‚Å∏                  Flat logical OR with A. This yields A if there is no '-'
                        in the input, the string "-" otherwise.
                    ¬§   Combine the three links to the left into a niladic chain.
      ‚ÄúJLKq·∏§·π¢&F‚Åªƒ±¬ª        Yield "Blinky Inky Pinky Clyde", using Jelly's built-in
                          English dictionary.
                  ·π£‚Å∂      Split at spaces to yield
                          ["Blinky", "Inky", "Pinky", "Clyde"].
                     ·∏ü  Filter-false; removing all elements from that list that
                        appear in A or "-". This is a noop if A contains "Pac-Man".
```
[Answer]
# Ruby, ~~55~~ 49 bytes
[Try it online!](https://repl.it/Cd2b/1)
*-6 bytes from @MartinEnder*
```
->a{%w"Blinky Inky Pinky Clyde"-(a*''=~/-/?[]:a)}
```
Ruby arrays can undergo set subtraction, making it very easy to remove the appropriate ghosts.
[Answer]
## Perl, 51 bytes
**50 bytes code + 1 for `-n`**
```
for$@(Blinky,Inky,Pinky,Clyde){print$@if/-/|!/$@/}g}
```
### Usage
```
perl -ne 'for$@(Blinky,Inky,Pinky,Clyde){print$@if/-/|!/$@/}' <<< 'Pac-Man, Clyde'
BlinkyInkyPinkyClyde
```
I can amend the output if necessary, adding a space after each ghost, for + 3 bytes replacing `print$@` with `print"$@ "`.
-6 bytes thanks to [@MartinEnder](https://codegolf.stackexchange.com/users/8478/martin-ender)!
---
## Perl, 53 bytes
**51 bytes code + 2 for `-na`**
An alternative solution, using the smartmatch operator:
```
print grep/-/~~@F|!($_~~@F),Blinky,Inky,Pinky,Clyde
```
### Usage
Requires a space separated list of input:
```
perl -nae 'print grep/-/~~@F|!($_~~@F),Blinky,Inky,Pinky,Clyde' <<< 'Clyde Pinky Inky'
Blinky
perl -nae 'print grep/-/~~@F|!($_~~@F),Blinky,Inky,Pinky,Clyde' <<< 'Clyde Pinky Inky Pac-Man'
BlinkyInkyPinkyClyde'
```
[Answer]
# [Pyth](http://pyth.herokuapp.com/?code=j-c%3A%22+p+bl+clyde%22d%22inky+%22d%3F%3Az%5CaZYcz&input=pac-man&test_suite=1&test_suite_input=clyde%0Ablinky+pinky%0Ainky+clyde%0Apac-man&debug=0) - 45 38  35 Bytes
```
=GwI!:G"a")j-["inky""pinky""blinky""clyde")cG
```
```
I!:=Gw"a")j-c:" p bl clyde"d"inky "dcG
```
```
j-c:" p bl clyde"d"inky "d?:z\aZYcz
```
*-1 more byte thanks to Leaky Nun!*
Input must be space delimited, all lowercase; outputs missing ghosts on separate lines unless pac-man is in the input.
[Answer]
# C, 171 bytes
Pass a NULL-terminated array of strings to `f()`, and it will print out the missing names.
```
*a[]={"Blinky","Inky","Pinky","Clyde",0},**s,**r,n;f(int**p){for(r=p;*p;)r=strcmp(*p++,"Pac-Man")?r:a+4;for(s=a;*s;++s){for(p=r,n=1;n&&*p;)n=strcmp(*s,*p++);n&&puts(*s);}}
```
[Try it on ideone.](http://ideone.com/F3SYw7)
[Answer]
## PowerShell v4+, 107 bytes
```
param($n)((($n+($x='Pinky','Inky','Blinky','Clyde')|group|?{$_.count-eq1}).Name),$x)['-'-in[char[]]-join$n]
```
A little clunky compared to others, as PowerShell lacks a ternary operator or any sort of `map`-style operator. As a result, we build our own.
Takes input `$n` as an explicit array of strings (e.g., `.\which-ghosts-are-missing.ps1 @('Clyde','Blinky')`. The rest of the program is one pseudo-ternary that's composed of an array that we index into via some logic `[...]`. The logic is simply whether the `-` character is anywhere in the input array `-join`ed together into a single string and then re-cast as a `char` array, in order to use the `-in` operator. Thus, if `Pac-Man` is in the input array, this will be `$TRUE` and the second element of the pseudo-ternary array will be chosen, else the first will be chosen.
If it's the case that `Pac-Man` is not in the array, the first portion of the pseudo-ternary array is output. That is a combination of the input array `$n` concatenated with an array of all the ghosts (saved into `$x`). We pipe that new array into `Group-Object` which will group like items together, then select using `Where-Object` (aliased via `|?{...}` only the items where their `.count` is `-eq`ual to `1`. That's all encapsulated in a parens, and we select the `.Name` property. This is where the v4 requirement comes in, as under v4 you can reference a hashtable label like this rather than using something like `|Select Name`, which saves several bytes.
Otherwise, since `Pac-Man` is in the input array, we need to output all the ghosts. Thankfully we already saved those into `$x`, so that's the choice in this case. Either way, the pipeline now contains a string array of ghosts, and output is implicit.
### Examples
```
PS C:\Tools\Scripts\golfing> .\which-ghosts-are-missing.ps1 @('Clyde')
Pinky
Inky
Blinky
PS C:\Tools\Scripts\golfing> .\which-ghosts-are-missing.ps1 @('Pac-Man','Clyde')
Pinky
Inky
Blinky
Clyde
PS C:\Tools\Scripts\golfing> .\which-ghosts-are-missing.ps1 @()
Pinky
Inky
Blinky
Clyde
PS C:\Tools\Scripts\golfing> .\which-ghosts-are-missing.ps1 @('Clyde','Blinky')
Pinky
Inky
```
[Answer]
# Python 2, ~~66~~ ~~61~~ 96 bytes
```
g={"Blinky","Inky","Pinky","Clyde"};i=set(input());print",".join(g-i if not"Pac-Man"in i else g)
```
Input must be a list, output will be a string of names separated by a `,`.
61 bytes version that doesn't handle Pac-Man:
```
print",".join({"Blinky","Inky","Pinky","Clyde"}-set(input()))
```
[Answer]
# Haskell, 91 bytes
```
import Data.List
p l=(if elem"Pac-Man"l then id else(\\l))["Blinky","Inky","Pinky","Clyde"]
```
Input is a list of strings. It decides whether to use the list as-is or do a list-difference based on the presence of "Pac-Man".
For extra fun, here is no Pac-Man:
```
import Data.List
(["Blinky","Inky","Pinky","Clyde"]\\)
```
Will be improving this answer soon, did it super late at night.
[Answer]
## Python 3, 77 bytes
```
lambda i:[g for g in"Blinky Inky Pinky Clyde".split()if g not in i or"-"in i]
```
Here is another answer at 89 bytes that I was playing with but didn't work out :(
```
lambda i:[g for g in[s+"nky"for s in"Bli I Pi".split()]+["Clyde"]if g not in i or"-"in i]
```
And here's the original at 85 bytes:
```
lambda i,n="Blinky Inky Pinky Clyde":([g for g in n.split()if g not in i],n)["-"in i]
```
These all take a single string of the names separated by spaces/commas.
[Answer]
## 05AB1E, ~~47~~ 44 bytes
```
‚Ä¢1g!Z~√∑k√Ö]¬∞%√è0‚Ä∫K/‚Ä¢35B0¬°‚Ñ¢svy'-√•i,q}}v¬πyk√åiy)Àú
```
**Explaination**
```
‚Ä¢1g!Z~√∑k√Ö]¬∞%√è0‚Ä∫K/‚Ä¢35B0¬°‚Ñ¢                      # push list of the 4 ghosts
                        svy'-√•i,q}}           # if Pac-Man is in input, quit and output list of all 4 ghosts
                                  v¬πyk√åiy)Àú   # otherwise, generate the list of ghosts missing from input
```
[Try it online](http://05ab1e.tryitonline.net/#code=4oCiMWchWn7Dt2vDhV3CsCXDjzDigLpLL-KAojM1QjDCoeKEonN2eSctw6VpLHF9fXbCuXlrw4xpeSnLnA&input=WydDbHlkZScsICdCbGlua3knLCdQYWMtTWFuJ10)
[Answer]
# Python 2, 151 bytes
As there are already Python answers using sets and strings I decided to restrict myself to work with lists, which turned out to be pretty long and uncompetitive. However, as the approach taken is different as the common one used, here it is:
```
o=['Blinky','Clyde','Inky','Pinky']
p=lambda x:[l for l in reduce(lambda z,x:z+[y+[x]for y in z],o,[[]])if sorted(l+x)==o][0]if'Pac-Man'not in x else o
```
where the expected input is a list of strings.
The approach is to bruteforce all possible combinations (without taking order into account) of 0,1,2,3 and 4 elements. This is done by
```
reduce(lambda z,x:z+[y+[x]for y in z],o,[[]])
```
which returns
```
[[], ['Clyde'], ['Pinky'], ['Clyde', 'Pinky'], ['Inky'], ['Clyde', 'Inky'],
['Pinky', 'Inky'], ['Clyde', 'Pinky', 'Inky'], ['Blinky'], ['Clyde', 'Blinky'],
['Pinky', 'Blinky'], ['Clyde', 'Pinky', 'Blinky'], ['Inky', 'Blinky'],
['Clyde', 'Inky', 'Blinky'], ['Pinky', 'Inky', 'Blinky'], 
['Clyde', 'Pinky', 'Inky', 'Blinky']]
```
and find the one which, in addition to the input list results in the complete list of ghosts.
Then it is checked if the string `'Pac-Man'` is part of the input and, in case it is, the whole list of ghosts is returned. If not, only the ones which are not part of the input are returned.
Notice that the list containing all ghost names (`o`) is sorted alphabetically and the same goes for the list built as (`sorted(l+x)`). This is due to the fact that in Python, `['a','b']==['b','a']` is evaluated as `False` whereas `['a','b']==['a','b']` is evaluated as `True`.
3 bytes can be saved if it is permitted to return the answer as a list of lists ( by removing the `[0]` at the end of the first list comprehension). But as I'm not sure it is a valid output I am counting them.
[Answer]
# [Pascal (FPC)](https://www.freepascal.org/), ~~204~~ 200 bytes
Two loops, using a binary to find which ghosts+pacman are present. Takes the arguments from the commandline.
Thanks to @manatwork for saving some more bytes!
```
var a:array[1..4]of string=('Blinky','Inky','Pinky','Clyde');i,s:Byte;begin for i:=1to ParamCount do s:=1<<Pos(ParamStr(i)[4],'nykd-')or s;for i:=1to 4do if(1<<i and s=0)or(s>31)then WriteLn(a[i])end.
```
[Try it online!](https://tio.run/##TY4xq8IwFIX/yt2SQC0WO7X2DToJDgUHh9LhalLfxXojSRTy62NQB6fD@TgfnDv6M86L6X5O6YkOsEHnMA5VWdajncAHR3zppNjMxNcoCrH7RP@t2zlqI1RLhW82MZj2ZC7EMFkH1HRVsNCjw9vWPjiAtuAzXK976@WbH4KTpIZ6LATHq14IlUXf/uh1lmiSWSJA1uC7Zd5I/7eqVPg3DEdHwexZ4kCjMqzLlNL73Qs "Pascal (FPC) ‚Äì Try It Online")
Ungolfed:
```
var
  a: array[1..4] of string = ('Blinky', 'Inky', 'Pinky', 'Clyde');
  i, s: byte;
begin
  for i:=1 to ParamCount do
    s := 1 << pos(ParamStr(i)[4], 'nykd-') or s; // fill bits by shifting, check for unique 4th char of names, '-' in 'pac-man', could also use the 3rd char
  for i:=1 to 4 do
    if (1 << i and s=0) or (s>31) then    // check if bits are on
      writeln(a[i]);
end.
```
# Old version using a set, ~~227~~ 209 bytes
Two loops, using a set to find which ghosts+pacman are present. Takes the arguments from the commandline.
```
var a:array[1..4]of string=('Blinky','Inky','Pinky','Clyde');i:byte;s:set of 1..5;begin for i:=1to ParamCount do s:=s+[pos(ParamStr(i)[4],'nykd-')];for i:=1to 4do if not(i in s)or(5in s)then writeln(a[i]);end.
```
Ungolfed:
```
var
  a: array[1..4] of string = ('Blinky', 'Inky', 'Pinky', 'Clyde');
  i: byte;
  s: set of 1..5;
begin
  for i:=1 to ParamCount do
    s := s + [pos(ParamStr(i)[4], 'nykd-')]; // fill set with indxs
  for i:=1 to 4 do
    if not(i in s) or (5 in s) then    // check indx not in set or pac-man is
      writeln(a[i]);
end.
```
[Answer]
# PHP program, 84 bytes
```
<?print_r(array_diff([Blinky,Inky,Pinky,Clyde],in_array('Pac-Man',$argv)?[]:$argv));
```
* takes arguments from command line, prints result as an array.
* filename must not be any of the ghosts or 'Pac-Man'!
* short breakdown: remove (if 'Pac-Man' is in arguments: nothing, else all arguments) from all ghosts; print result recursively
examples:
```
>php -d error_reporting=0 ghosts.php Clyde
Array
(
    [0] => Blinky
    [1] => Inky
    [2] => Pinky
)
>php -d error_reporting=0 ghosts.php Clyde Blinky
Array
(
    [0] => Inky
    [1] => Pinky
)
>php -d error_reporting=0 ghosts.php Pac-Man Clyde
Array
(
    [0] => Blinky
    [1] => Inky
    [2] => Pinky
    [3] => Clyde
)
```
**PHP function, 90 bytes**
```
function p($a){return array_diff([Blinky,Inky,Pinky,Clyde],in_array('Pac-Man',$a)?[]:$a);}
```
takes and returns an array, use empty array for empty input, no other falsy value!
**further thoughts**
* replace `in_array(...)` with `strstr(join($argv),'-')` to detect `-` instead of `Pac-Man` (-2)
* use `ereg('-',join($argv))` instead (another -2)
* program could lose another 6 bytes in PHP<5.4 with `register_globals` on
* to make the program print a comma-separated list: replace `<?print_r(` with `<?=join(',',` (+2). You may want to add `;echo""` to the call for a line break
[Answer]
# jq, 69 characters
```
("Blinky Inky Pinky Clyde"/" ")as $a|if inside($a)then$a-. else$a end
```
Input is JSON, output is JSON, conditional syntax is pain.
Sample run:
```
bash-4.3$ jq '("Blinky Inky Pinky Clyde"/" ")as $a|if inside($a)then$a-. else$a end' <<< '["Clyde"]'
[
  "Blinky",
  "Inky",
  "Pinky"
]
bash-4.3$ jq '("Blinky Inky Pinky Clyde"/" ")as $a|if inside($a)then$a-. else$a end' <<< '["Pac-Man","Clyde"]'
[
  "Blinky",
  "Inky",
  "Pinky",
  "Clyde"
]
```
On-line test:
* [["Clyde"]](https://jqplay.org/jq?q=%28"Blinky%20Inky%20Pinky%20Clyde"/"%20"%29as%20$a|if%20inside%28$a%29then$a-.%20else$a%20end&j=["Clyde"])
* [["Pac-Man","Clyde"]](https://jqplay.org/jq?q=%28"Blinky%20Inky%20Pinky%20Clyde"/"%20"%29as%20$a|if%20inside%28$a%29then$a-.%20else$a%20end&j=["Pac-Man","Clyde"])
[Answer]
# TSQL(sqlserver 2016), 114 bytes
**Golfed:**
```
DECLARE @ VARCHAR(99) = 'Blinky,Inky,Pinky,Clyde'
SELECT*FROM STRING_SPLIT('Blinky,Inky,Pinky,Clyde',',')EXCEPT SELECT*FROM STRING_SPLIT(@,','WHERE @ NOT LIKE'%-%'
```
**Ungolfed:**
```
DECLARE @ VARCHAR(99) = 'Blinky,Inky,Pinky,Clyde'
SELECT * FROM STRING_SPLIT('Blinky,Inky,Pinky,Clyde',',')
EXCEPT
SELECT * FROM STRING_SPLIT(@,',')
WHERE @ NOT LIKE'%-%'
```
**[Fiddle](https://data.stackexchange.com/stackoverflow/query/515126/which-ghosts-are-missing)**
[Answer]
## Lotus Notes @Formula language, ~~85~~ ~~84~~ ~~75~~ 74 characters
*-1 character by reversing the @If assignment*
*-9 Changed @Contains(i;"-") to @Like(i;"%-%") and removed @Trim (not needed if displayed using space as seperator)*
*-1 by removing the newline*
Create a form with two fields: i (Text,Editable,Multi-value) and o (Text,Computed,Multi-value). Enter the following formula in o:
```
l:="Inky":"Pinky":"Blinky":"Clyde";@If(@Like(i;"%-%");l;@Replace(l;i;""))
```
From Notes client, create a new document using the form, enter the name(s) in the i field and press F9 to refresh the document. Answer displayed in field o.
This takes advantage of the fact that @Like and @Replace can can both be used either on a string or on a list of strings.
[Answer]
**C# ~~135 bytes~~126 bytes**
```
string[] g{"Blinky","Inky","Pinky","Clyde"};Console.WriteLine(String.Join(",",i.Contains("Pac-Man")?g:g.Except(i).ToArray()));
```
(where i is a string array containing the input)
After looking at the other examples, I see that C# is rather a verbose language :)
[Answer]
## Pyke, ~~45~~ ~~39~~ ~~38~~ ~~37~~ 32 bytes
```
.dñ≠∫êé™ËÜé„ß´l4dc].^D`\-R{!*
```
[Try it here!](http://pyke.catbus.co.uk/?code=.d%04%F0%96%AD%BA%F0%90%8E%AA%E8%86%8E%E3%A7%ABl4dc%5D.%5ED%60%5C-R%7B%21%2a&input=%5B%22Blinky%22%2C+%22Pinky%22%5D)
```
.dñ≠∫êé™ËÜé„ß´l4dc - dictionary_lookup('blinky inky pinky clyde').title().split()
].^ - xor(^, input)
D`\-R{!* - ^*("-" not in input)
```
[Answer]
## Batch, 141 bytes
```
@set g= Blinky Inky Pinky Clyde
@for %%a in (%*)do @if %%a==Pac-Man goto l
@for %%a in (%*)do call set g=%%g: %%a=%%
@l
@echo(%g:~1,-1%
```
(Subtract 6 bytes for `:~1,-1` if leading and trailing whitespace is acceptable.) Requires Pac-Man in title case but the ghosts are case insensitive.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 38 bytes (Non-competing)
Takes input as an array of strings, outputs an array of strings
```
`B¬¶nky Inky Pky C√í√®`¬∏kU√∏`Pac-M` ?N:U
```
[Try it online](http://ethproductions.github.io/japt/?v=1.4.5&code=YEKmbmt5IElua3kgUIhreSBD0uhguGtV+GBQYWMtTYRgID9OOlU=&input=WyJJbmt5Il0=)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 27 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
‚Ä¶√™¬•¬¶¬®‚Ñ¢√Ö#'y¬´.‚Ä¢S:-‚Ä¢¬™‚Ñ¢IDJ{–Ωa–∏K
```
[Try it online](https://tio.run/##yy9OTMpM/f//UcOyw6sOLT207NCKRy2LDrcqq1ceWq33qGFRsJUukDy0Cijq6eJVfWFv4oUd3v//RysFJCbr@ibmKekoOedUpqQqxQIA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKS/X@9Rw2LjA9vOLTi8Pxzkw8viSs73HVu4@F9So8aJj9q2AWUVH7UsqjSxav6wt7ECzu8/@v8j45Wcs6pTElVitWBsXSUnHIy87IrwUIBicm6vol5QEG4MpCwJ0gerlAHrjMAojEWAA).
**Explanation:**
```
‚Ä¶√™¬•¬¶¬®‚Ñ¢√Ö           # Push dictionary string "blink ink pink"
                  #  STACK: "blink ink pink"
       #          # Split it on spaces
                  #  STACK: ["blink","ink","pink"]
        'y       '# Push "y"
                  #  STACK: ["blink","ink","pink"],"y"
          ¬´       # Append it to each string in the list
                  #  STACK: ["blinky","inky","pinky"]
           .‚Ä¢S:-‚Ä¢ # Push compressed string "clyde"
                  #  STACK: ["blinky","inky","pinky"],"clyde"
             ¬™    # Append it to the list
                  #  STACK: ["blinky","inky","pinky","clyde"]
              ‚Ñ¢   # Titlecase each string
                  #  STACK: ["Blinky","Inky","Pinky","Clyde"]
I                 # Push the input-list
                  #  STACK1: ["Blinky","Inky","Pinky","Clyde"],["Pac-Man"]
                  #  STACK2: ["Blinky","Inky","Pinky","Clyde"],["Pinky"]
                  #  STACK3: ["Blinky","Inky","Pinky","Clyde"],[]
 D                # Duplicate it
                  #  STACK1: ["Blinky","Inky","Pinky","Clyde"],["Pac-Man"],["Pac-Man"]
                  #  STACK2: ["Blinky","Inky","Pinky","Clyde"],["Pinky"],["Pinky"]
                  #  STACK3: ["Blinky","Inky","Pinky","Clyde"],[],[]
  J               # Join the copy to a single string
                  #  STACK1: ["Blinky","Inky","Pinky","Clyde"],["Pac-Man"],"Pac-Man"
                  #  STACK2: ["Blinky","Inky","Pinky","Clyde"],["Pinky"],"Pinky"
                  #  STACK3: ["Blinky","Inky","Pinky","Clyde"],[],""
   {              # Sort its characters
                  #  STACK1: ["Blinky","Inky","Pinky","Clyde"],["Pac-Man"],"-MPaacn"
                  #  STACK2: ["Blinky","Inky","Pinky","Clyde"],["Pinky"],"Pikny"
                  #  STACK3: ["Blinky","Inky","Pinky","Clyde"],[],""
    –Ω             # Pop and leave just its first character
                  #  STACK1: ["Blinky","Inky","Pinky","Clyde"],["Pac-Man"],"-"
                  #  STACK2: ["Blinky","Inky","Pinky","Clyde"],["Pinky"],"P"
                  #  STACK3: ["Blinky","Inky","Pinky","Clyde"],[],""
     a            # Check if this is a letter
                  #  STACK1: ["Blinky","Inky","Pinky","Clyde"],["Pac-Man"],0
                  #  STACK2: ["Blinky","Inky","Pinky","Clyde"],["Pinky"],1
                  #  STACK3: ["Blinky","Inky","Pinky","Clyde"],[],0
      –∏           # Repeat the input-list that many times
                  #  STACK1: ["Blinky","Inky","Pinky","Clyde"],[]
                  #  STACK2: ["Blinky","Inky","Pinky","Clyde"],["Pinky"]
                  #  STACK3: ["Blinky","Inky","Pinky","Clyde"],[]
       K          # Remove those strings from the earlier quartet-list
                  #  STACK1: ["Blinky","Inky","Pinky","Clyde"]
                  #  STACK2: ["Blinky","Inky","Clyde"]
                  #  STACK3: ["Blinky","Inky","Pinky","Clyde"]
                  # (after which the resulting list is output implicitly)
```
[See this 05AB1E tip of mine (sections *How to use the dictionary?* and *How to compress strings not part of the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `‚Ä¶√™¬•¬¶¬®‚Ñ¢√Ö` is `"blink ink pink"` and `.‚Ä¢S:-‚Ä¢` is `"clyde"`.
]