В этом вызове, учитывая список призраков из Pac-Man, вы должны указать, каких призраков не хватает. Вы должны сделать это как можно меньше байтов

вход

Ввод будет состоять из строки или списка, который будет включать в себя число призраков, которые могут включать;

• Блинки
• чернильный
• мизинец
• Клайд

Однако ввод может также включать Pac-Man (с этой пунктуацией). Таким образом, максимальное количество элементов в списке будет пять в любом порядке. Можно предположить, что в списке не будет недопустимых элементов

Выход

Вывод будет состоять из строки или списка. Это будет включать всех призраков, которых нет на входе, в любом порядке. Однако, если Pac-Man находится на входе, все призраки будут считаться пропавшими (потому что он их ест).

Контрольные примеры

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

Это код-гольф, поэтому чем меньше счет, тем лучше.

Желе , 25 22 байта

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

Это монадическая функция. Ввод / вывод в форме списков. Попробуйте онлайн!

Как это работает

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.

Этап 2: Замена

$
,;BliNClyde,INPiN

Это просто добавляет фиксированную строку ,;BliNClyde,INPiN. Это будет список призраков в выводе после некоторой очистки.

Этап 3: Замена

N
nky,

Обратите внимание, что на предыдущем этапе мы написали три *nkyпризрака с Nсимволом (и пропустили запятую после них), а теперь расширим эту стенограмму, которая экономит пару байтов. Теперь после каждого призрака есть запятая, и у нас есть входные призраки и список всех призраков, разделенных точкой с запятой.

Этап 3: дедупликация

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

Рубин, 55 49 байтов

Попробуйте онлайн!

-6 байт от @MartinEnder

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

Еще один байт благодаря Leaky Nun!

Ввод должен быть разделен пробелом, все строчные буквы; выводит недостающие призраки в отдельных строках, если на входе не указан pac-man.

C 171 байт

Передайте массив строк с нулевым символом в конце 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 отсутствует тернарный оператор или какой-либо mapоператор стиля. В результате мы строим свои собственные.

Принимает ввод $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 байт, которая не обрабатывает Pac-Man:

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

Ввод представляет собой список строк. Он решает, использовать ли список «как есть» или сделать разницу в списке в зависимости от наличия «Pac-Man».

Для дополнительного удовольствия здесь нет Pac-Man:

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)˜

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

Попробуйте онлайн

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]в конце первого понимания списка). Но так как я не уверен, что это правильный результат, я считаю их.

Объект Паскаль, 204 200 байт

Два цикла, использующие двоичный файл для определения присутствия 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.

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.

Старая версия с использованием набора, 227 209 байт

Два цикла, используя набор, чтобы найти, какие призраки + 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.

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.

PHP программа, 84 байта

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

• принимает аргументы из командной строки, выводит результат в виде массива.
• имя файла не должно быть ни одним из призраков или «Pac-Man»!
• краткая разбивка: удалить (если '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)
• Программа может потерять еще 6 байт в PHP <5.4 с register_globalsна
• чтобы программа печатала список через запятую: замените <?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"
]

Он-лайн тест:

• ["Клайд"]
• [ "Pac-Man", "Клайд"]

TSQL (sqlserver 2016), 114 байт

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

скрипка

Lotus Notes @Formula язык, 85 84 75 74 символов

-1 символ путем изменения назначения @If

-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 # - довольно многословный язык :)

Пайк, 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%

(Вычтите 6 байт, :~1,-1если допустимы начальные и конечные пробелы.) Требуется Pac-Man в заглавном регистре, но в призраках регистр не учитывается.

Japt , 38 байт (не конкурирует)

Принимает ввод как массив строк, выводит массив строк

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

Попробуйте онлайн