在此挑战中，给定吃豆人的鬼魂列表，您必须输出缺少的鬼魂。您必须尽可能地减少字节数

输入项

输入将由字符串或列表组成，其中将包含数字重影，可能包括；

• 眨眼
• 墨黑
• 小指
• 克莱德

但是，输入也可能包括吃豆人（带有标点符号）。因此，列表中的最大项目数将为五个，以任何顺序排列。可以假设列表中没有无效项

输出量

输出将包含一个字符串或列表。这将以任何顺序包括所有不在输入中的幻影。但是，如果输入中包含吃豆人，则所有鬼影都将被视为丢失（因为他吃掉了它们）。

测试用例

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

这是codegolf，因此字节数越低越好。

果冻，25 22 字节

Ff”-ȯ⁸“JLKqḤṢ&F⁻ı»ṣ⁶¤ḟ

这是单子函数。I / O采用列表形式。在线尝试！

怎么运行的

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".

视网膜，45字节

A`-
$
,;BliNClyde,INPiN
N
nky,
D`\w+,
.*;|,$

尾随换行很重要。输入和输出以逗号分隔。

在线尝试！（第一行启用换行分隔的测试套件。）

说明

我没想到能够这么快就展示Retina的最新功能（重复数据删除阶段），但这确实对解决这一挑战很有帮助。:)

阶段1：反Grep

A`-

反grep阶段会丢弃与给定正则表达式匹配的所有行。正则表达式是正义的-，输入始终是一行，因此如果输入包含，则将丢弃所有重影Pac-Man。

第二阶段：替代

$
,;BliNClyde,INPiN

这只是追加固定字符串,;BliNClyde,INPiN。这将是经过一些清理后输出中的幻影列表。

第三阶段：替代

N
nky,

请注意，我们在上一阶段*nky用编写了三个幽灵N（并在它们之后省略了逗号），现在我们扩展了此简写形式，节省了几个字节。现在，每个鬼影之后都有一个逗号，并且我们得到了输入鬼影和所有鬼影的列表，用分号分隔。

第三阶段：重复数据删除

D`\w+,

这是新的部分。重复数据删除阶段将找到给定正则表达式的所有实例，并丢弃所有等于较早匹配子字符串的匹配子字符串。正则表达式仅匹配输入和潜在输出列表中的所有重影。如果输入包含重影，则相同的重影将在第二个列表中再次匹配并被丢弃。否则，将在第二个列表中首次匹配幻影并将其保留。因此，在此之后，分号后的列表就是我们想要的输出。剩下的就是一些清理工作：

阶段5：替代

.*;|,$

我们只需将所有内容匹配至分号以及字符串末尾的逗号，然后将其删除。

Python 3，75个字节

lambda s:[x for x in['Blinky','Inky','Pinky','Clyde']if(x in s)<1or'-'in s]

输入是一个逗号分隔的字符串，输出是一个列表。

的JavaScript ES6，85 78个字节

作为匿名功能

a=>["Blinky","Inky","Pinky","Clyde"].filter(c=>!a.includes(c)|a.some(v=>v[6]))

今天，我了解了此filter功能。好玩！

多亏了尼尔，节省了15个字节。

用法：

(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"]

Ruby，55个 49字节

在线尝试！

@MartinEnder的-6个字节

->a{%w"Blinky Inky Pinky Clyde"-(a*''=~/-/?[]:a)}

Ruby数组可以进行集合减法，从而很容易删除适当的重影。

Perl，51个字节

50个字节的代码+ 1个 -n

for$@(Blinky,Inky,Pinky,Clyde){print$@if/-/|!/$@/}g}

用法

perl -ne 'for$@(Blinky,Inky,Pinky,Clyde){print$@if/-/|!/$@/}' <<< 'Pac-Man, Clyde'
BlinkyInkyPinkyClyde

如果必要的话，我可以修改的输出，每个鬼魂之后加入的空间，为+ 3字节替换print$@用print"$@ "。

-6个字节感谢@MartinEnder！

Perl，53个字节

51个字节的代码+ 2个 -na

使用smartmatch运算符的替代解决方案：

print grep/-/~~@F|!($_~~@F),Blinky,Inky,Pinky,Clyde

用法

需要用空格分隔的输入列表：

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'

Pyth - 45 38 35字节

=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个字节，感谢Leaky Nun！

输入必须以空格分隔，全部为小写；除非在输入中包含pac-man，否则在单独的行上输出缺少的重影。

C，171字节

将NULL终止的字符串数组传递给f()，它将打印出缺少的名称。

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

在ideone上尝试。

PowerShell v4 +，107个字节

param($n)((($n+($x='Pinky','Inky','Blinky','Clyde')|group|?{$_.count-eq1}).Name),$x)['-'-in[char[]]-join$n]

与PowerShell相比，它有些笨拙，因为PowerShell缺少三元运算符或任何类型的map-style运算符。结果，我们建立了自己的。

将输入$n作为一个显式的字符串数组（例如，.\which-ghosts-are-missing.ps1 @('Clyde','Blinky')。程序的其余部分是一个伪三元数，由一个我们通过某种逻辑索引到的数组组成[...]。逻辑仅是-字符是否在输入数组中的任意位置-join一起）转换为单个字符串，然后重新转换为char数组，以便使用-in运算符。因此，如果Pac-Man在输入数组中，则为，$TRUE将选择伪三元数组的第二个元素，否则第一个将被选中。

如果Pac-Man不是数组，则输出伪三进制数组的第一部分。这是将输入数组$n与所有重影数组（保存为$x）组合而成的组合。我们管新的数组Group-Object，类似的项目会组合在一起，然后选择使用Where-Object（通过别名|?{...}只有在他们的项目.count是-eqUAL到1，这是在一个小括号的所有包裹，我们选择.Name属性。这是V4的需求进来，如在v4中一样，您可以引用这样的哈希表标签，而不是使用诸如这样的哈希表标签|Select Name来节省几个字节。

否则，由于Pac-Man位于输入数组中，因此我们需要输出所有重影。幸运的是，我们已经将它们保存到中$x，因此在这种情况下就是这样的选择。无论哪种方式，管道现在都包含一个由幻影组成的字符串数组，并且输出是隐式的。

例子

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

Python 2，66 61 96字节

g={"Blinky","Inky","Pinky","Clyde"};i=set(input());print",".join(g-i if not"Pac-Man"in i else g)

输入必须是列表，输出将是用分隔的名称字符串,。

无法处理吃豆人的61字节版本：

print",".join({"Blinky","Inky","Pinky","Clyde"}-set(input()))

Haskell，91字节

import Data.List
p l=(if elem"Pac-Man"l then id else(\\l))["Blinky","Inky","Pinky","Clyde"]

输入是字符串列表。它根据“吃豆人”的存在来决定是按原样使用列表还是进行列表差异处理。

为了获得更多乐趣，这里没有吃豆人：

import Data.List
(["Blinky","Inky","Pinky","Clyde"]\\)

很快就会改善这个答案，在深夜才做得很好。

Python 3，77个字节

lambda i:[g for g in"Blinky Inky Pinky Clyde".split()if g not in i or"-"in i]

这是我正在玩的另一个89字节的答案，但是没有解决:(

lambda i:[g for g in[s+"nky"for s in"Bli I Pi".split()]+["Clyde"]if g not in i or"-"in i]

这是原始的85字节：

lambda i,n="Blinky Inky Pinky Clyde":([g for g in n.split()if g not in i],n)["-"in i]

这些都采用由空格/逗号分隔的单个名称字符串。

05AB1E，47 44字节

•1g!Z~÷kÅ]°%Ï0›K/•35B0¡™svy'-åi,q}}v¹ykÌiy)˜

讲解

•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

在线尝试

Python 2，151字节

由于已经有了使用集合和字符串的Python答案，因此我决定限制自己使用列表，事实证明列表很长且没有竞争力。但是，由于所采用的方法与常用的方法不同，因此它是：

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

其中预期的输入是字符串列表。

该方法是强制使用0、1、2、3和4个元素的所有可能组合（不考虑顺序）。这是通过

reduce(lambda z,x:z+[y+[x]for y in z],o,[[]])

哪个返回

[[], ['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']]

并找到一个除输入列表之外还生成完整幻影列表的列表。

然后检查字符串'Pac-Man'是否是输入的一部分，如果是，则返回整个幻象列表。如果不是，则仅返回不属于输入的内容。

请注意，包含所有幻影名称（o）的列表按字母顺序排序，而构建为（sorted(l+x)）的列表也是如此。这是由于以下事实：在Python中，['a','b']==['b','a']的值为，False而['a','b']==['a','b']的值为True。

如果允许将答案作为列表列表返回，则可以节省3个字节（通过删除[0]第一个列表理解的末尾）。但是由于我不确定这是一个有效的输出，因此我正在对它们进行计数。

对象Pascal，204200字节

两个循环，使用二进制查找存在的ghosts + pacman。从命令行获取参数。感谢@manatwork节省了更多字节！

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.

取消高尔夫：

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.

使用一组旧版本，227 209字节

两个循环，使用一组查找存在的ghosts + pacman。从命令行获取参数。

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.

取消高尔夫：

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.

PHP程序，84字节

<?print_r(array_diff([Blinky,Inky,Pinky,Clyde],in_array('Pac-Man',$argv)?[]:$argv));

• 从命令行获取参数，将结果打印为数组。
• 文件名不能是任何幽灵或“吃豆人”！
• 简短故障：从所有虚影中删除（如果'Pac-Man'在自变量中：无，则所有自变量）；递归打印结果

例子：

>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函数，90个字节

function p($a){return array_diff([Blinky,Inky,Pinky,Clyde],in_array('Pac-Man',$a)?[]:$a);}

接受并返回一个数组，将空数组用于空输入，没有其他虚假值！

进一步的想法

• 替换in_array(...)与strstr(join($argv),'-')检测-代替Pac-Man（-2）
• 使用ereg('-',join($argv))代替（另一个-2）
• 程序在PHP <5.4 register_globals上可能会另外丢失6个字节
• 使程序打印以逗号分隔的列表：<?print_r(用<?=join(',',（+2）替换。您可能需要添加;echo""到换行符的通话中

jq，69个字符

("Blinky Inky Pinky Clyde"/" ")as $a|if inside($a)then$a-. else$a end

输入是JSON，输出是JSON，条件语法很痛苦。

样品运行：

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"
]

在线测试：

• [“克莱德”]
• [“吃豆人”，“克莱德”]

TSQL（sqlserver 2016），114字节

打高尔夫球：

DECLARE @ VARCHAR(99) = 'Blinky,Inky,Pinky,Clyde'

SELECT*FROM STRING_SPLIT('Blinky,Inky,Pinky,Clyde',',')EXCEPT SELECT*FROM STRING_SPLIT(@,','WHERE @ NOT LIKE'%-%'

取消高尔夫：

DECLARE @ VARCHAR(99) = 'Blinky,Inky,Pinky,Clyde'

SELECT * FROM STRING_SPLIT('Blinky,Inky,Pinky,Clyde',',')
EXCEPT
SELECT * FROM STRING_SPLIT(@,',')
WHERE @ NOT LIKE'%-%'

小提琴

Lotus Notes @Formula语言，85 84 75 74个字符

通过反转@If分配来返回-1个字符

-9将@Contains（i;“-”）更改为@Like（i;“％-％”）并删除@Trim（如果使用空格作为分隔符显示，则不需要）

-1通过删除换行符

创建具有两个字段的表单：i（文本，可编辑，多值）和o（文本，计算，多值）。在o中输入以下公式：

l:="Inky":"Pinky":"Blinky":"Clyde";@If(@Like(i;"%-%");l;@Replace(l;i;""))

在Notes客户端中，使用该表单创建一个新文档，在i字段中输入名称，然后按F9刷新文档。答案显示在字段o中。

这利用了一个事实，即@Like和@Replace都可以在字符串或字符串列表上使用。

C＃135字节 126字节

string[] g{"Blinky","Inky","Pinky","Clyde"};Console.WriteLine(String.Join(",",i.Contains("Pac-Man")?g:g.Except(i).ToArray()));

（其中我是一个包含输入的字符串数组）

看完其他示例后，我发现C＃是一种冗长的语言:)

Pyke，45 39 38 37 32字节

.d𖭺𐎪膎㧫l4dc].^D`\-R{!*

在这里尝试！

.d𖭺𐎪膎㧫l4dc - dictionary_lookup('blinky inky pinky clyde').title().split()
].^ - xor(^, input)
D`\-R{!* - ^*("-" not in input)

批处理，141字节

@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%

（:~1,-1如果可以接受前导和尾随空格，则减去6个字节。）在标题情况下需要吃豆人，但幻影不区分大小写。

Japt，38个字节（不竞争）

将输入作为字符串数组，将输出字符串数组

`B¦nky Inky Pky CÒè`¸kUø`Pac-M` ?N:U

在线尝试