W tym wyzwaniu, biorąc pod uwagę listę duchów z Pac-Mana, musisz podać, których duchów brakuje. Musisz to zrobić w jak najmniejszej liczbie bajtów

Wkład

Dane wejściowe będą składać się z łańcucha lub listy, która będzie zawierać wiele duchów, które mogą obejmować;

• Mrugnięcie
• Atramentowy
• mały palec
• Clyde

Jednak dane wejściowe mogą również obejmować Pac-Man (z tą interpunkcją). Zatem maksymalna liczba pozycji na liście będzie wynosić pięć, w dowolnej kolejności. Można założyć, że na liście nie będzie żadnych nieprawidłowych pozycji

Wydajność

Dane wyjściowe będą składać się z ciągu lub listy. Obejmuje to wszystkie duchy, których nie ma na wejściu, w dowolnej kolejności. Jeśli jednak Pac-Man jest na wejściu, wszystkie duchy zostaną uznane za zaginione (ponieważ je je).

Przypadki testowe

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

To jest codegolf, więc im niższa liczba bajtów, tym lepiej.

Galaretka , 25 22 bajtów

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

To jest funkcja monadyczna. I / O ma postać list. Wypróbuj online!

Jak to działa

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

Siatkówka , 45 bajtów

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

Końcowe podawanie linii jest znaczące. Wejścia i wyjścia są oddzielone przecinkami.

Wypróbuj online! (Pierwszy wiersz włącza pakiet testowy oddzielony od linii).

Wyjaśnienie

Nie spodziewałem się, że będę mógł tak szybko pochwalić się najnowszym dodatkiem Retiny (etapy deduplikacji), ale jest to naprawdę pomocne w tym wyzwaniu. :)

Etap 1: Anti-Grep

A`-

Etapy anti-grep odrzucają wszystkie wiersze pasujące do podanego wyrażenia regularnego. Wyrażenie regularne jest po prostu, -a wejście jest zawsze pojedynczą linią, więc odrzuca wszystkie duchy, jeśli dane wejściowe zawierają Pac-Man.

Etap 2: Zmiana

$
,;BliNClyde,INPiN

To po prostu dołącza stały ciąg ,;BliNClyde,INPiN. Będzie to lista duchów na wyjściu po pewnym czyszczeniu.

Etap 3: Zmiana

N
nky,

Zauważ, że napisaliśmy trzy *nkyduchy za pomocą Nna poprzednim etapie (i pominęliśmy przecinek po nich), i teraz rozszerzamy ten skrót, który oszczędza kilka bajtów. Po każdym duchu jest teraz przecinek, a mamy duchy wejściowe i listę wszystkich duchów oddzielonych średnikiem.

Etap 3: deduplikacja

D`\w+,

To jest nowa część. Etapy deduplikacji znajdują wszystkie wystąpienia podanego wyrażenia regularnego i odrzucają wszystkie dopasowane podciągi, które są równe wcześniej dopasowanemu podciągowi. Wyrażenie regularne po prostu pasuje do wszystkich duchów, zarówno na wejściu, jak i na liście potencjalnych wyników. Jeśli dane wejściowe zawierają ducha, ten sam duch zostanie ponownie dopasowany na drugiej liście i zostanie odrzucony. W przeciwnym razie duch zostanie dopasowany po raz pierwszy na drugiej liście i zachowany. Po tym lista po średniku jest naszym pożądanym wynikiem. Pozostało tylko trochę oczyszczenia:

Etap 5: Zmiana

.*;|,$

Po prostu dopasowujemy wszystko do średnika, a także przecinka na końcu łańcucha i usuwamy je.

Python 3, 75 bajtów

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

Dane wejściowe to łańcuch rozdzielany przecinkami, a wynikiem będzie lista.

JavaScript ES6, 85 78 bajtów

Jako funkcja anonimowa

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

Dzisiaj dowiedziałem się o tej filterfunkcji. Zabawa!

15 bajtów zapisanych dzięki Neilowi.

Stosowanie:

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

Rubin, 55 49 bajtów

Wypróbuj online!

-6 bajtów od @MartinEnder

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

Tablice Ruby mogą podlegać odejmowaniu, dzięki czemu bardzo łatwo można usunąć odpowiednie duchy.

Perl, 51 bajtów

Kod 50 bajtów + 1 dla -n

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

Stosowanie

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

Mogę zmiany sygnału, jeżeli jest to konieczne, dodanie miejsca po każdej duch do + 3 bajty zastępujących print$@z print"$@ ".

-6 bajtów dzięki @MartinEnder !

Perl, 53 bajty

Kod 51 bajtów + 2 dla -na

Alternatywne rozwiązanie z wykorzystaniem operatora smartmatch:

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

Stosowanie

Wymaga listy danych oddzielonych spacjami:

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 bajtów

=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 więcej bajtów dzięki Leaky Nun!

Dane wejściowe muszą być rozdzielane spacjami, wszystkie małe litery; wyświetla brakujące duchy w osobnych liniach, chyba że na wejściu znajduje się pac-man.

C, 171 bajtów

Przekaż tablicę zakończonych znakiem NULL ciągów f(), a wyświetli brakujące nazwy.

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

Wypróbuj na ideone.

PowerShell v4 +, 107 bajtów

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

Trochę nieporadny w porównaniu do innych, ponieważ PowerShell nie ma trójskładnikowego operatora lub innego rodzaju mapoperatora. W rezultacie budujemy własne.

Pobiera dane wejściowe $njako jawną tablicę ciągów znaków (np .\which-ghosts-are-missing.ps1 @('Clyde','Blinky'). Reszta programu to jeden pseudo-trójskładnik, który składa się z tablicy, którą indeksujemy za pomocą jakiejś logiki [...]. Logika polega po prostu na tym, czy -znak jest w dowolnym miejscu w tablicy wejściowej -joinrazem w pojedynczy łańcuch, a następnie ponownie rzutowany jako chartablica, aby użyć -inoperatora. Zatem jeśli Pac-Manznajduje się w tablicy wejściowej, będzie to $TRUEi wybierany będzie drugi element tablicy pseudo-trójskładnikowej, w przeciwnym razie pierwsza być wybranym.

Jeśli tak jest w przypadku, gdy Pac-Mannie ma go w tablicy, wyprowadzana jest pierwsza część pseudo-trójskładnikowej tablicy. Jest to kombinacja tablicy wejściowej $npołączonej z tablicą wszystkich duchów (zapisanych w $x). Podłączamy tę nową tablicę, do Group-Objectktórej będą grupować podobne elementy, a następnie wybieramy za pomocą Where-Object(aliasy |?{...}tylko przez elementy, do których .countsą -eqone potrzebne 1. To wszystko jest zamknięte w parens, i wybieramy .Namewłaściwość. To tutaj pojawia się wymaganie v4, tak jak w v4, możesz odwoływać się do takiej etykiety hashtable, zamiast używać czegoś takiego |Select Name, co oszczędza kilka bajtów.

W przeciwnym razie, ponieważ Pac-Manznajduje się w tablicy wejściowej, musimy wyprowadzić wszystkie duchy. Na szczęście już je zapisaliśmy $x, więc w tym przypadku to jest wybór. Tak czy inaczej, potok zawiera teraz szereg duchów, a dane wyjściowe są niejawne.

Przykłady

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 bajtów

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

Dane wejściowe muszą być listą, dane wyjściowe będą ciągiem nazw oddzielonych znakiem ,.

Wersja 61 bajtów, która nie obsługuje Pac-Mana:

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

Haskell, 91 bajtów

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

Dane wejściowe to lista ciągów znaków. Decyduje, czy użyć listy w stanie, w jakim jest, czy zrobić różnicę w zależności od obecności „Pac-Man”.

Dla dodatkowej zabawy nie ma Pac-Mana:

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

Wkrótce poprawię tę odpowiedź, zrobiłem to bardzo późno w nocy.

Python 3, 77 bajtów

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

Oto kolejna odpowiedź przy 89 bajtach, z którą bawiłem się, ale się nie udało :(

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

A oto oryginał w 85 bajtach:

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

Wszystkie one biorą pojedynczy ciąg nazw oddzielony spacjami / przecinkami.

05AB1E, 47 44 bajtów

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

Wyjaśnienie

•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

Wypróbuj online

Python 2, 151 bajtów

Ponieważ są już odpowiedzi w Pythonie przy użyciu zestawów i ciągów, postanowiłem ograniczyć się do pracy z listami, które okazały się dość długie i niekonkurencyjne. Ponieważ jednak zastosowane podejście różni się od powszechnie stosowanego, oto ono:

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

gdzie oczekiwanym wejściem jest lista ciągów.

Podejście polega na brutalnym wykorzystaniu wszystkich możliwych kombinacji (bez uwzględnienia kolejności) 0,1,2,3 i 4 elementów. Odbywa się to przez

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

który zwraca

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

i znajdź tę, która oprócz listy danych wejściowych daje pełną listę duchów.

Następnie sprawdzane jest, czy ciąg znaków 'Pac-Man'jest częścią danych wejściowych, a jeśli tak, zwracana jest cała lista duchów. Jeśli nie, zwracane są tylko te, które nie są częścią danych wejściowych.

Zauważ, że lista zawierająca wszystkie nazwy duchów ( o) jest posortowana alfabetycznie i to samo dotyczy listy zbudowanej jako ( sorted(l+x)). Wynika to z faktu, że w Pythonie ['a','b']==['b','a']jest oceniany jako, Falsepodczas gdy ['a','b']==['a','b']jest oceniany jako True.

Można zapisać 3 bajty, jeśli dozwolone jest zwrócenie odpowiedzi w postaci listy list (poprzez usunięcie znaku [0]na końcu pierwszej listy). Ale ponieważ nie jestem pewien, czy jest to poprawny wynik, liczę je.

Obiekt Pascal, 204 200 bajtów

Dwie pętle, za pomocą pliku binarnego, aby znaleźć, które duchy + pacman są obecne. Pobiera argumenty z wiersza polecenia. Dzięki @manatwork za zaoszczędzenie trochę więcej bajtów!

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.

Nie golfowany:

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.

Stara wersja przy użyciu zestawu, 227 209 bajtów

Dwie pętle, za pomocą zestawu znajdź duchy + pacman. Pobiera argumenty z wiersza polecenia.

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.

Nie golfowany:

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.

Program PHP, 84 bajty

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

• pobiera argumenty z wiersza poleceń, wyświetla wynik jako tablicę.
• nazwa pliku nie może być żadnym z duchów lub „Pac-Man”!
• krótki podział: usuń (jeśli „Pac-Man” jest w argumentach: nic, w przeciwnym razie wszystkie argumenty) ze wszystkich duchów; wydrukuj wynik rekurencyjnie

przykłady:

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

Funkcja PHP, 90 bajtów

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

pobiera i zwraca tablicę, użyj pustej tablicy dla pustych danych wejściowych, żadnych innych wartości falsy!

dalsze przemyślenia

• zastąpić in_array(...)w strstr(join($argv),'-')celu wykrycia -zamiast Pac-Man(-2)
• użyj ereg('-',join($argv))zamiast (kolejne -2)
• program może stracić kolejne 6 bajtów w PHP <5.4 z register_globalswłączonym
• aby program wydrukować listę oddzielonych przecinkami: wymienić <?print_r(z <?=join(',',(+2). Możesz dodać ;echo""do połączenia podział linii

jq, 69 znaków

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

Dane wejściowe to JSON, dane wyjściowe to JSON, składnia warunkowa to ból.

Przykładowy przebieg:

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

Test on-line:

• [„Clyde”]
• [„Pac-Man”, „Clyde”]

TSQL (sqlserver 2016), 114 bajtów

Gra w golfa:

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

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

Nie golfowany:

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

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

Skrzypce

Lotus Notes @ Język Formula, 85 84 75 74 znaków

-1 znak poprzez odwrócenie przypisania @If

-9 Zmieniono @Contains (i; "-") na @Like (i; "% -%") i usunięto @Trim (niepotrzebne, jeśli wyświetla się za pomocą spacji jako separatora)

-1 poprzez usunięcie nowej linii

Utwórz formularz z dwoma polami: i (Tekst, Edytowalny, Wiele wartości) i o (Tekst, Obliczony, Wiele wartości). Wprowadź następującą formułę we:

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

W kliencie Notes utwórz nowy dokument za pomocą formularza, wprowadź nazwy w polu i i naciśnij klawisz F9, aby odświeżyć dokument. Odpowiedź wyświetlana w polu o.

Wykorzystuje to fakt, że @Like i @Replace mogą być używane zarówno w łańcuchu, jak i na liście łańcuchów.

C # 135 bajtów 126 bajtów

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

(gdzie i jest tablicą łańcuchów zawierających dane wejściowe)

Po przejrzeniu innych przykładów widzę, że C # jest raczej pełnym językiem :)

Pyke, 45 39 38 37 32 bajtów

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

Wypróbuj tutaj!

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

Partia, 141 bajtów

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

(Odejmij 6 bajtów, :~1,-1jeśli dopuszczalne są początkowe i końcowe białe znaki). Wymaga Pac-Mana w tytule, ale duchy nie rozróżniają wielkości liter.

Japt , 38 bajtów ( niekonkurencyjny )

Pobiera dane wejściowe jako tablicę ciągów, generuje tablicę ciągów

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

Wypróbuj online