In dieser Herausforderung müssen Sie anhand einer Liste von Geistern aus Pac-Man ausgeben, welche Geister fehlen. Sie müssen es in so wenigen Bytes tun, wie Sie können

Eingang

Die Eingabe besteht aus einer Zeichenfolge oder Liste, die eine Anzahl von Geistern enthält, die Folgendes enthalten könnten.

• Blinky
• Inky
• kleiner Finger
• Clyde

Die Eingabe kann jedoch auch Pac-Man (mit dieser Interpunktion) umfassen. Die maximale Anzahl von Elementen in einer Liste beträgt also fünf in beliebiger Reihenfolge. Es kann davon ausgegangen werden, dass keine ungültigen Elemente in der Liste enthalten sind

Ausgabe

Die Ausgabe besteht aus einer Zeichenfolge oder Liste. Dies schließt alle Geister, die nicht in der Eingabe enthalten sind, in beliebiger Reihenfolge ein. Wenn sich Pac-Man jedoch in der Eingabe befindet, werden alle Geister als vermisst betrachtet (weil er sie isst).

Testfälle

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

Das ist Codegolf. Je niedriger der Bytecount, desto besser.

Jelly , 25 22 Bytes

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

Dies ist eine monadische Funktion. I / O ist in Form von Listen. Probieren Sie es online!

Wie es funktioniert

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

Netzhaut , 45 Bytes

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

Der Zeilenvorschub am Ende ist signifikant. Eingabe und Ausgabe sind durch Kommas getrennt.

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Erläuterung

Ich hatte nicht erwartet, dass ich Retinas neueste Erweiterung (Deduplizierungsphasen) so bald vorführen kann, aber es ist wirklich hilfreich für diese Herausforderung. :)

Stufe 1: Anti-Grep

A`-

Anti-Grep-Stufen verwerfen alle Zeilen, die dem angegebenen regulären Ausdruck entsprechen. Der reguläre Ausdruck ist gerecht -und die Eingabe ist immer eine einzelne Zeile. Dadurch werden alle Geister verworfen, wenn die Eingabe enthält Pac-Man.

Stufe 2: Substitution

$
,;BliNClyde,INPiN

Hiermit wird einfach die feste Zeichenfolge angehängt ,;BliNClyde,INPiN. Dies ist die Liste der Geister in der Ausgabe nach einer Bereinigung.

Stufe 3: Substitution

N
nky,

Beachten Sie, dass wir die drei *nkyGeister mit einem Nin der vorherigen Phase geschrieben haben (und das Komma nach ihnen weggelassen haben), und dass wir jetzt diese Kurzform erweitern, wodurch ein paar Bytes gespart werden. Nach jedem einzelnen Geist steht jetzt ein Komma, und wir haben die Eingabegeister und die Liste aller Geister, die durch ein Semikolon getrennt sind.

Stufe 3: Deduplizierung

D`\w+,

Das ist der neue Teil. Deduplizierungsstufen finden alle Instanzen des angegebenen regulären Ausdrucks und verwerfen alle übereinstimmenden Teilzeichenfolgen, die einer früheren übereinstimmenden Teilzeichenfolge entsprechen. Der reguläre Ausdruck stimmt einfach mit allen Geistern überein, sowohl in der Eingabe als auch in der Liste der möglichen Ausgaben. Wenn die Eingabe einen Geist enthält, wird derselbe Geist erneut in der zweiten Liste abgeglichen und verworfen. Andernfalls wird der Geist zum ersten Mal in der zweiten Liste abgeglichen und beibehalten. Danach ist die Liste nach dem Semikolon unsere gewünschte Ausgabe. Alles was übrig bleibt, ist ein bisschen aufzuräumen:

Stufe 5: Substitution

.*;|,$

Wir ordnen einfach alles dem Semikolon sowie dem Komma am Ende der Zeichenkette zu und entfernen sie.

Python 3, 75 Bytes

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

Die Eingabe ist eine durch Kommas getrennte Zeichenfolge und die Ausgabe ist eine Liste.

JavaScript ES6, 85 78 Bytes

Als anonyme Funktion

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

Heute habe ich diese filterFunktion kennengelernt. Spaß!

Neil spart 15 Bytes.

Verwendung:

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

Probieren Sie es online!

-6 Bytes von @MartinEnder

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

Ruby-Arrays können einer Mengen-Subtraktion unterzogen werden, wodurch es sehr einfach wird, die entsprechenden Geister zu entfernen.

Perl, 51 Bytes

50 Byte Code + 1 für -n

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

Verwendung

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

Ich kann die Ausgabe bei Bedarf ändern, um einen Raum nach jeder Zugabe Geister, für + 3 Bytes ersetzen print$@mit print"$@ ".

-6 Bytes dank @MartinEnder !

Perl, 53 Bytes

51 Byte Code + 2 für -na

Eine alternative Lösung mit dem Smartmatch-Operator:

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

Verwendung

Benötigt eine durch Leerzeichen getrennte Liste der Eingaben:

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 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 weiteres Byte dank Leaky Nun!

Die Eingabe muss durch Leerzeichen getrennt und in Kleinbuchstaben erfolgen. Gibt fehlende Geister in separaten Zeilen aus, es sei denn, pac-man ist in der Eingabe.

C 171 Bytes

Übergeben Sie ein NULL-terminiertes Array von Zeichenfolgen an f(), um die fehlenden Namen auszudrucken.

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

Probiere es auf ideone aus.

PowerShell v4 +, 107 Byte

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

Ein wenig klobig im Vergleich zu anderen, da PowerShell keinen ternären Operator oder irgendeine Art von mapOperator hat. Infolgedessen bauen wir unsere eigenen.

Nimmt die Eingabe $nals explizite Array von Zeichenketten (zB .\which-ghosts-are-missing.ps1 @('Clyde','Blinky'). Der Rest des Programms ist eine pseudo-ternäre , die aus einem Array zusammengesetzt ist , dass wir Index in über eine gewisse Logik [...]. Die Logik ist einfach , ob das -Zeichen überall im Eingabearray -joinzusammen ed charUm den -inOperator zu verwenden , Pac-Manwird er in eine einzelne Zeichenfolge umgewandelt und dann als Array neu umgewandelt$TRUE und das zweite Element des pseudoternären Arrays wird ausgewählt, andernfalls das erste gewählt werden.

Wenn dies nicht der Fall Pac-Manist, wird der erste Teil des pseudoternären Arrays ausgegeben. Dies ist eine Kombination des Eingabearrays, das $nmit einem Array aller (in $x) gespeicherten Geister verknüpft ist . Wir Rohr , dass neue Array in Group-Objectdenen Gruppe wie Elemente zusammen, wählen Sie dann mit Where-Object(aliased über |?{...}die Elemente nur dann, wenn ihr .countist -equal zu 1. Das ist alles in einem Pars gekapselt und wir die wählen .NameEigenschaft. Hier wird die Anforderung v4 kommt, Wie unter v4 können Sie auf ein solches Hashtable-Label verweisen, anstatt so etwas zu verwenden |Select Name, das mehrere Bytes spart.

Andernfalls Pac-Manmüssen alle Geisterbilder ausgegeben werden , da sie sich im Eingabearray befinden. Zum Glück haben wir diese bereits in gespeichert $x, also ist das in diesem Fall die Wahl. In beiden Fällen enthält die Pipeline jetzt ein String-Array mit Geistern, und die Ausgabe ist implizit.

Beispiele

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 Bytes

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

Die Eingabe muss eine Liste sein. Die Ausgabe erfolgt in Form einer durch ein Zeichen getrennten Namensfolge ,.

61-Byte-Version, die Pac-Man nicht unterstützt:

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

Haskell, 91 Bytes

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

Die Eingabe ist eine Liste von Zeichenfolgen. Es entscheidet, ob die Liste unverändert verwendet wird oder ob ein Listendifferenz basierend auf dem Vorhandensein von "Pac-Man" durchgeführt wird.

Für zusätzlichen Spaß gibt es hier keinen Pac-Man:

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

Wird diese Antwort bald verbessern, hat es super spät in der Nacht.

Python 3, 77 Bytes

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

Hier ist eine weitere Antwort bei 89 Bytes, mit der ich gespielt habe, die aber nicht geklappt hat :(

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

Und hier ist das Original mit 85 Bytes:

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

Diese setzen sich aus einer einzelnen Zeichenfolge von durch Leerzeichen / Kommas getrennten Namen zusammen.

05AB1E, 47 44 Bytes

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

Erklärung

•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

Probieren Sie es online aus

Python 2, 151 Bytes

Da es bereits Python-Antworten mit Mengen und Zeichenfolgen gibt, habe ich mich darauf beschränkt, mit Listen zu arbeiten, die sich als ziemlich lang und nicht wettbewerbsfähig herausstellten. Da der gewählte Ansatz jedoch anders ist als der übliche, ist er hier:

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

wobei die erwartete Eingabe eine Liste von Zeichenfolgen ist.

Der Ansatz besteht darin, alle möglichen Kombinationen (ohne Berücksichtigung der Reihenfolge) von 0,1,2,3 und 4 Elementen zu erzwingen. Dies geschieht durch

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

was zurückkehrt

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

und finde den, der zusätzlich zu der Eingabeliste die vollständige Liste der Geister ergibt.

Dann wird geprüft, ob der String 'Pac-Man'Teil der Eingabe ist, und falls dies der Fall ist, wird die gesamte Liste der Geister zurückgegeben. Wenn nicht, werden nur diejenigen zurückgegeben, die nicht Teil der Eingabe sind.

Beachten Sie, dass die Liste mit allen Geisternamen ( o) alphabetisch sortiert ist und dass dies auch für die Liste gilt, die als ( sorted(l+x)) erstellt wurde. Dies liegt daran, dass in Python ['a','b']==['b','a']ausgewertet wird als Falsewohingegen ['a','b']==['a','b']ausgewertet wird als True.

3 Bytes können gespeichert werden, wenn die Antwort als Liste von Listen zurückgegeben werden darf (indem das [0]am Ende der ersten Liste stehende Verständnis entfernt wird). Aber da ich nicht sicher bin, ob es eine gültige Ausgabe ist, zähle ich sie.

Object Pascal, 204 200 Bytes

Zwei Schleifen mit einer Binärdatei, um herauszufinden, welche Geister + Pacman vorhanden sind. Übernimmt die Argumente von der Kommandozeile. Vielen Dank an @manatwork für das Speichern weiterer 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.

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.

Alte Version unter Verwendung eines Satzes, 227 209 Bytes

Zwei Loops mit einem Set, um herauszufinden, welche Geister + Pacman vorhanden sind. Übernimmt die Argumente von der Kommandozeile.

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-Programm, 84 Bytes

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

• Übernimmt Argumente von der Kommandozeile und gibt das Ergebnis als Array aus.
• Dateiname darf kein Geister oder 'Pac-Man' sein!
• kurze Aufschlüsselung: entferne (wenn 'Pac-Man' in Argumenten steht: nichts, sonst alle Argumente) von allen Geistern; Ergebnis rekursiv ausgeben

Beispiele:

>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-Funktion, 90 Bytes

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

Nimmt ein Array und gibt es zurück, verwende ein leeres Array für leere Eingaben, keinen anderen falschen Wert!

weitere gedanken

• ersetzen in_array(...)mit strstr(join($argv),'-')zu erkennen -stattPac-Man (-2)
• verwenden ereg('-',join($argv)) stattdessen (ein anderes -2)
• Programm könnte weitere 6 Bytes in PHP <5.4 mit register_globalson verlieren
• Damit das Programm eine durch Kommas getrennte Liste druckt: Ersetzen Sie diese <?print_r(durch <?=join(',',(+2). Möglicherweise möchten Sie ;echo""dem Anruf einen Zeilenumbruch hinzufügen

69 Zeichen

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

Eingabe ist JSON, Ausgabe ist JSON, bedingte Syntax ist Schmerz.

Probelauf:

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

Online-Test:

• ["Clyde"]
• ["Pac-Man", "Clyde"]

TSQL (SQL Server 2016), 114 Byte

Golf gespielt:

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

Geige

Lotus Notes @Formula-Sprache, 85 84 75 74 Zeichen

-1 Zeichen durch Umkehren der @ If-Zuweisung

-9 @Contains (i; "-") wurde in @Like (i; "% -%") geändert und @Trim entfernt (nicht erforderlich, wenn Leerzeichen als Trennzeichen verwendet werden)

-1 durch Entfernen der Newline

Erstellen Sie ein Formular mit zwei Feldern: i (Text, Bearbeitbar, Mehrfachwert) und o (Text, Berechnet, Mehrfachwert). Geben Sie die folgende Formel in o ein:

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

Erstellen Sie im Notes-Client ein neues Dokument mit dem Formular, geben Sie den oder die Namen in das Feld i ein und drücken Sie F9, um das Dokument zu aktualisieren. Antwort wird in Feld o angezeigt.

Dies nutzt die Tatsache aus, dass sowohl @Like als auch @Replace entweder für eine Zeichenfolge oder für eine Liste von Zeichenfolgen verwendet werden können.

C # 135 Bytes 126 Bytes

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

(wobei i ein String-Array ist, das die Eingabe enthält)

Wenn ich mir die anderen Beispiele anschaue, sehe ich, dass C # eher eine ausführliche Sprache ist :)

Pyke, 45 39 38 37 32 Bytes

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

Probieren Sie es hier aus!

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

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%

(Subtrahieren Sie 6 Bytes, :~1,-1wenn führende und nachfolgende Leerzeichen zulässig sind.) Erfordert Pac-Man in Groß- und Kleinschreibung, aber bei den Ghosts wird die Groß- und Kleinschreibung nicht berücksichtigt.

Japt , 38 Bytes (nicht konkurrierend)

Nimmt Eingaben als ein Array von Zeichenfolgen und gibt ein Array von Zeichenfolgen aus

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

Probieren Sie es online aus