In questa sfida, dato un elenco di fantasmi di Pac-Man, devi produrre quali fantasmi mancano. È necessario farlo nel minor numero di byte possibile

Ingresso

L'input sarà costituito da una stringa o da un elenco, che includerà un numero di fantasmi, che potrebbero includere;

• blinky
• inky
• Pinky
• Clyde

Tuttavia, l'input può anche includere Pac-Man (con quella punteggiatura). Pertanto, la quantità massima di elementi in un elenco sarà cinque, in qualsiasi ordine. Si può presumere che nessun elemento non valido sia presente nell'elenco

Produzione

L'output sarà costituito da una stringa o da un elenco. Ciò includerà tutti i fantasmi che non sono nell'input, in qualsiasi ordine. Tuttavia, se Pac-Man è nell'input, tutti i fantasmi saranno considerati mancanti (perché li mangia).

Casi test

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

Questo è codegolf, quindi più basso è il numero di dipendenti, meglio è.

Gelatina , 25 22 byte

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

Questa è una funzione monadica. L'I / O è in forma di elenchi. Provalo online!

Come funziona

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

Retina , 45 byte

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

L'alimentazione di linea finale è significativa. Input e output sono separati da virgola.

Provalo online! (La prima riga abilita una suite di test separata da avanzamento riga.)

Spiegazione

Non mi aspettavo di poter sfoggiare così presto l'ultima aggiunta di Retina (fasi di deduplicazione), ma è davvero utile per questa sfida. :)

Fase 1: Anti-Grep

A`-

Le fasi anti-grep scartano tutte le linee che corrispondono alla regex data. Il regex è giusto -e l'input è sempre una singola riga, quindi questo scarta tutti i fantasmi se l'input contiene Pac-Man.

Fase 2: sostituzione

$
,;BliNClyde,INPiN

Questo semplicemente aggiunge la stringa fissa ,;BliNClyde,INPiN. Questo sarà l'elenco di fantasmi nell'output dopo un po 'di pulizia.

Fase 3: sostituzione

N
nky,

Nota che abbiamo scritto i tre *nky fantasmi con un Nnella fase precedente (e abbiamo omesso la virgola dopo di loro), e ora espandiamo questa scorciatoia, che salva un paio di byte. Ora c'è una virgola dopo ogni singolo fantasma e abbiamo i fantasmi di input e l'elenco di tutti i fantasmi separati da un punto e virgola.

Fase 3: deduplicazione

D`\w+,

Questa è la nuova parte. Le fasi di deduplicazione trovano tutte le istanze della regex data e scaricano tutte le sottostringhe corrispondenti che sono uguali a una sottostringa precedente abbinata. Il regex corrisponde semplicemente a tutti i fantasmi, sia nell'input che nell'elenco dei potenziali output. Se l'input contiene un fantasma, lo stesso fantasma verrà nuovamente abbinato nel secondo elenco e verrà scartato. Altrimenti, il fantasma viene abbinato per la prima volta nella seconda lista e mantenuto. Quindi, dopo questo, l'elenco dopo il punto e virgola è l'output desiderato. Tutto ciò che rimane è un po 'di pulizia:

Fase 5: sostituzione

.*;|,$

Abbiniamo semplicemente tutto fino al punto e virgola e alla virgola alla fine della stringa e li rimuoviamo.

Python 3, 75 byte

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

L'input è una stringa separata da virgola e l'output sarà un elenco.

JavaScript ES6, 85 78 byte

Come una funzione anonima

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

Oggi ho imparato a conoscere questa filterfunzione. Divertimento!

15 byte salvati grazie a Neil.

Uso:

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

Rubino, 55 49 byte

Provalo online!

-6 byte da @MartinEnder

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

Le matrici di rubini possono subire sottrazioni prestabilite, rendendo molto semplice la rimozione dei fantasmi appropriati.

Perl, 51 byte

50 byte codice + 1 per -n

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

uso

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

Posso modificare l'output se necessario, aggiungendo uno spazio dopo ogni fantasma, per + 3 byte sostituendoli print$@con print"$@ ".

-6 byte grazie a @MartinEnder !

Perl, 53 byte

51 byte codice + 2 per -na

Una soluzione alternativa, utilizzando l'operatore smartmatch:

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

uso

Richiede un elenco di input separato da spazi:

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 byte

=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 byte in più grazie a Leaky Nun!

L'input deve essere delimitato da spazi, tutto in minuscolo; genera fantasmi mancanti su linee separate a meno che pac-man non sia nell'input.

C, 171 byte

Passa un array di stringhe con terminazione NULL a f()e stamperà i nomi mancanti.

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

Provalo su ideone.

PowerShell v4 +, 107 byte

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

Un po 'goffo rispetto ad altri, in quanto PowerShell manca di un operatore ternario o di qualsiasi tipo map operatore di tipo. Di conseguenza, costruiamo il nostro.

Prende l'input $ncome un array esplicito di stringhe (ad es .\which-ghosts-are-missing.ps1 @('Clyde','Blinky'). , Il resto del programma è uno pseudo-ternario composto da un array in cui indicizziamo tramite una logica [...]. La logica è semplicemente se il -carattere si trova in un punto qualsiasi dell'array di input-join ed insieme in una singola stringa e quindi ri-cast come un chararray, al fine di utilizzare l' -inoperatore. Quindi, se Pac-Manè nell'array di input, questo sarà $TRUEe verrà scelto il secondo elemento dell'array pseudo-ternario, altrimenti il ​​primo sarà essere scelto.

Se è il caso che Pac-Mannon si trova nella matrice, viene emessa la prima porzione della matrice pseudo-ternaria. Questa è una combinazione dell'array di input $nconcatenato con un array di tutti i fantasmi (salvati in $x). Effettuiamo il pipe di quel nuovo array in Group-Objectcui raggrupperemo elementi simili, quindi selezioniamo usando Where-Object(aliasato |?{...}solo tramite gli elementi in cui .countè -eqreale 1. È tutto incapsulato in una parentesi e selezioniamo la .Nameproprietà. È qui che entra in gioco il requisito v4, come sotto v4 puoi fare riferimento a un'etichetta hashtable come questa piuttosto che usare qualcosa come |Select Name, che salva diversi byte.

Altrimenti, da allora Pac-Man trova nell'array di input, dobbiamo generare tutti i fantasmi. Per fortuna abbiamo già salvato quelli in$x , quindi questa è la scelta in questo caso. In entrambi i casi, la pipeline ora contiene una matrice di stringhe di fantasmi e l'output è implicito.

Esempi

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 byte

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

L'input deve essere un elenco, l'output sarà una stringa di nomi separati da un , .

Versione di 61 byte che non gestisce Pac-Man:

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

Haskell, 91 byte

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

L'input è un elenco di stringhe. Decide se utilizzare l'elenco così com'è o fare una differenza di elenco in base alla presenza di "Pac-Man".

Per un divertimento extra, ecco Pac-Man:

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

Migliorerà presto questa risposta, l'ha fatto molto tardi la sera.

Python 3, 77 byte

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

Ecco un'altra risposta a 89 byte con cui stavo giocando ma non ho funzionato :(

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

Ed ecco l'originale a 85 byte:

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

Questi prendono tutti una singola stringa di nomi separati da spazi / virgole.

05AB1E, 47 44 byte

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

spiegazione

•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

Provalo online

Python 2, 151 byte

Dato che ci sono già risposte Python che usano set e stringhe, ho deciso di limitarmi a lavorare con le liste, che si sono rivelate piuttosto lunghe e non competitive. Tuttavia, poiché l'approccio adottato è diverso da quello comune utilizzato, eccolo qui:

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

dove l'input previsto è un elenco di stringhe.

L'approccio è quello di potenziare tutte le possibili combinazioni (senza prendere in considerazione l'ordine) di 0,1,2,3 e 4 elementi. Questo è fatto da

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

che ritorna

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

e trova quello che, oltre alla lista di input, porta alla lista completa dei fantasmi.

Quindi viene verificato se la stringa 'Pac-Man' fa parte dell'input e, in caso affermativo, viene restituito l'intero elenco di fantasmi. In caso contrario, vengono restituiti solo quelli che non fanno parte dell'input.

Si noti che l'elenco contenente tutti i nomi fantasma ( o) è ordinato in ordine alfabetico e lo stesso vale per l'elenco creato come ( sorted(l+x)). Ciò è dovuto al fatto che in Python ['a','b']==['b','a']viene valutato come Falsementre ['a','b']==['a','b']viene valutato comeTrue .

È possibile salvare 3 byte se è consentito restituire la risposta come elenco di elenchi (rimuovendo il simbolo [0]alla fine della prima comprensione dell'elenco). Ma poiché non sono sicuro che sia un output valido, li sto contando.

Oggetto Pascal, 204 200 byte

Due loop, usando un binario per trovare quali fantasmi + pacman sono presenti. Prende gli argomenti dalla riga di comando. Grazie a @manatwork per aver salvato qualche altro byte!

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.

Vecchia versione usando un set, 227 209 byte

Due loop, usando un set per trovare quali fantasmi + pacman sono presenti. Prende gli argomenti dalla riga di comando.

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.

Programma PHP, 84 byte

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

• accetta argomenti dalla riga di comando, stampa il risultato come un array.
• il nome del file non deve essere uno dei fantasmi o "Pac-Man"!
• breve analisi: rimuovi (se "Pac-Man" è in discussione: niente, altrimenti tutti gli argomenti) da tutti i fantasmi; risultato di stampa ricorsivo

esempi:

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

Funzione PHP, 90 byte

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

prende e restituisce un array, usa un array vuoto per input vuoti, nessun altro valore errato!

ulteriori pensieri

• sostituire in_array(...) con strstr(join($argv),'-')per rilevare -anziché Pac-Man(-2)
• usa ereg('-',join($argv))invece (un altro -2)
• il programma potrebbe perdere altri 6 byte in PHP <5.4 con register_globals on
• per fare in modo che il programma stampi un elenco separato da virgole: sostituirlo <?print_r(con <?=join(',',(+2). Potresti voler aggiungere;echo"" alla chiamata per un'interruzione di linea

jq, 69 caratteri

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

L'input è JSON, l'output è JSON, la sintassi condizionale è dolore.

Esecuzione di esempio:

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

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

TSQL (sqlserver 2016), 114 byte

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

Violino

Lotus Notes @Formula language, 85 84 75 74 caratteri

-1 carattere invertendo l'assegnazione @If

-9 Modificato @Contains (i; "-") in @Like (i; "% -%") e rimosso @Trim (non necessario se visualizzato usando lo spazio come separatore)

-1 rimuovendo la nuova riga

Creare un modulo con due campi: i (Testo, Modificabile, Valore multiplo) e o (Testo, Calcolo, Valore multiplo). Immettere la seguente formula in o:

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

Dal client Notes, creare un nuovo documento utilizzando il modulo, immettere i nomi nel campo i e premere F9 per aggiornare il documento. Risposta visualizzata nel campo o.

Ciò si avvale del fatto che @Like e @Replace possono essere entrambi utilizzati su una stringa o su un elenco di stringhe.

C # 135 byte 126 byte

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

(dove i è un array di stringhe contenente l'input)

Dopo aver visto gli altri esempi, vedo che C # è piuttosto un linguaggio dettagliato :)

Pyke, 45 39 38 37 32 byte

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

Provalo qui!

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

Lotto, 141 byte

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

(Sottrai 6 byte :~1,-1se lo spazio bianco iniziale e finale è accettabile.) Richiede Pac-Man nel caso del titolo, ma i fantasmi non fanno distinzione tra maiuscole e minuscole.

Japt , 38 byte (non concorrenti)

Accetta l'input come una matrice di stringhe, genera una matrice di stringhe

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

Provalo online