Neste desafio, dada uma lista de fantasmas do Pac-Man, você deve exibir quais fantasmas estão faltando. Você deve fazer isso no menor número de bytes possível

Entrada

A entrada consistirá em uma sequência ou lista, que incluirá um número de fantasmas, que pode incluir;

• Blinky
• Inky
• Pinky
• Clyde

No entanto, a entrada também pode incluir o Pac-Man (com essa pontuação). Portanto, a quantidade máxima de itens em uma lista será cinco, em qualquer ordem. Pode-se supor que nenhum item inválido estará na lista

Saída

A saída consistirá em uma sequência ou lista. Isso incluirá todos os fantasmas que não estão na entrada, em nenhuma ordem. No entanto, se Pac-Man estiver na entrada, todos os fantasmas serão considerados desaparecidos (porque ele os come).

Casos de teste

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

Este é um codegolf, portanto, quanto menor o número de bytes, melhor.

Geléia , 25 22 bytes

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

Esta é uma função monádica. A E / S está na forma de listas. Experimente online!

Como funciona

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 bytes

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

O avanço de linha à direita é significativo. Entrada e saída são separadas por vírgula.

Experimente online! (A primeira linha ativa um conjunto de testes separado por avanço de linha.)

Explicação

Eu não esperava poder exibir a última adição da Retina (estágios de desduplicação) tão cedo, mas é realmente útil para esse desafio. :)

Etapa 1: Anti-Grep

A`-

Os estágios do anti-grep descartam todas as linhas que correspondem ao regex especificado. O regex é justo -e a entrada é sempre uma única linha; portanto, isso descarta todos os fantasmas se a entrada contiverPac-Man .

Etapa 2: Substituição

$
,;BliNClyde,INPiN

Isso simplesmente acrescenta a sequência fixa ,;BliNClyde,INPiN. Esta será a lista de fantasmas na saída após alguma limpeza.

Etapa 3: Substituição

N
nky,

Observe que escrevemos os três *nkyfantasmas com umN no estágio anterior (e omitimos a vírgula após eles), e agora expandimos essa abreviação, que economiza alguns bytes. Agora existe uma vírgula após cada fantasma, e temos os fantasmas de entrada e a lista de todos os fantasmas separados por ponto e vírgula.

Etapa 3: Desduplicação

D`\w+,

Esta é a nova parte. Os estágios de redução de redundância localizam todas as instâncias do regex especificado e descartam todas as substrings correspondentes que são iguais a uma substring correspondente anterior. A regex simplesmente corresponde a todos os fantasmas, tanto na entrada quanto na lista de possíveis saídas. Se a entrada contiver um fantasma, o mesmo fantasma será correspondido novamente na segunda lista e será descartado. Caso contrário, o fantasma é correspondido pela primeira vez na segunda lista e mantido. Então, depois disso, a lista após o ponto e vírgula é a saída desejada. Tudo o que resta é um pouco de limpeza:

Etapa 5: Substituição

.*;|,$

Simplesmente combinamos tudo até o ponto-e-vírgula e a vírgula no final da string e os removemos.

Python 3, 75 bytes

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

A entrada é uma sequência separada por vírgula e a saída será uma lista.

JavaScript ES6, 85 78 bytes

Como uma função anônima

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

Hoje eu aprendi sobre essa filterfunção. Diversão!

15 bytes salvos graças 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"]

Ruby, 55 49 bytes

Experimente online!

-6 bytes de @MartinEnder

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

As matrizes Ruby podem sofrer subtração de conjunto, facilitando a remoção dos fantasmas apropriados.

Perl, 51 bytes

Código de 50 bytes + 1 para -n

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

Uso

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

Posso alterar a saída, se necessário, adicionando um espaço após cada fantasma, para + 3 bytes substituindo print$@ porprint"$@ " .

-6 bytes graças a @MartinEnder !

Perl, 53 bytes

Código de 51 bytes + 2 para -na

Uma solução alternativa, usando o operador smartmatch:

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

Uso

Requer uma lista de entradas separada por espaço:

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 byte a mais, graças a Leaky Nun!

A entrada deve ser delimitada por espaço, todas em minúsculas; produz fantasmas ausentes em linhas separadas, a menos que pac-man esteja na entrada.

C, 171 bytes

Passe uma matriz de seqüências terminada em NULL para f()e ela imprimirá os nomes ausentes.

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

Experimente em ideone.

PowerShell v4 +, 107 bytes

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

Um pouco desajeitado em comparação com outros, pois o PowerShell não possui um operador ternário ou qualquer tipo de map operador estilo. Como resultado, construímos nossos próprios.

Recebe a entrada $ncomo uma matriz explícita de strings (por exemplo, .\which-ghosts-are-missing.ps1 @('Clyde','Blinky')o resto do programa é um pseudo-ternário que é composto por uma matriz na qual indexamos por meio de alguma lógica [...]. A lógica é simplesmente se o -caractere está em algum lugar da matriz de entrada -joineditado juntos em uma única string e depois convertida novamente como uma charmatriz, a fim de usar o -inoperador.Portanto, se Pac-Manestiver na matriz de entrada, esse será $TRUEo segundo elemento da matriz pseudo-ternária, caso contrário, o primeiro será ser escolhido.

Se for o caso que Pac-Mannão está na matriz, a primeira parte da matriz pseudo-ternária é emitida. Essa é uma combinação da matriz de entrada $nconcatenada com uma matriz de todos os fantasmas (salvos em $x). Canalizamos essa nova matriz na Group-Objectqual agrupamos itens semelhantes e, em seguida, selecionamos usando Where-Object(aliasizado |?{...}apenas pelos itens em que eles .countsão -equal 1. Isso é tudo encapsulado em uma parênteses, e selecionamos a .Namepropriedade. É aí que entra o requisito da v4, como na v4, você pode fazer referência a um rótulo de hashtable como este, em vez de usar algo como|Select Name , o que economiza vários bytes.

Caso contrário, como Pac-Manestá na matriz de entrada, precisamos gerar todos os fantasmas. Felizmente, já salvamos aqueles em$x , então essa é a escolha neste caso. De qualquer forma, o pipeline agora contém uma matriz de fantasmas e a saída está implícita.

Exemplos

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)

A entrada deve ser uma lista, a saída será uma sequência de nomes separados por a ,.

Versão de 61 bytes que não lida com o Pac-Man:

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

Entrada é uma lista de cadeias. Ele decide se deve usar a lista como está ou fazer uma diferença de lista com base na presença de "Pac-Man".

Para diversão extra, aqui não é o Pac-Man:

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

Estará melhorando esta resposta em breve, fez super tarde da noite.

Python 3, 77 bytes

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

Aqui está outra resposta com 89 bytes em que eu estava jogando, mas não deu certo :(

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

E aqui está o original em 85 bytes:

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

Todos eles usam uma única sequência de nomes separados por espaços / vírgulas.

05AB1E, 47 44 bytes

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

Explicação

•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

Experimente online

Python 2, 151 bytes

Como já existem respostas em Python usando conjuntos e seqüências de caracteres, decidi me restringir ao trabalho com listas, que se mostraram bastante longas e pouco competitivas. No entanto, como a abordagem adotada é diferente da utilizada, aqui está:

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

onde a entrada esperada é uma lista de cadeias.

A abordagem é aplicar força bruta em todas as combinações possíveis (sem levar em consideração a ordem) de 0,1,2,3 e 4 elementos. Isso é feito por

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

que retorna

[[], ['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 encontre o que, além da lista de entrada, resulta na lista completa de fantasmas.

Então é verificado se a string 'Pac-Man' faz parte da entrada e, no caso, a lista inteira de fantasmas é retornada. Caso contrário, somente os que não fazem parte da entrada são retornados.

Observe que a lista que contém todos os nomes fantasmas ( o) é classificada em ordem alfabética e o mesmo vale para a lista criada como ( sorted(l+x)). Isto é devido ao fato de que em Python, ['a','b']==['b','a']é avaliada como Falseenquanto ['a','b']==['a','b']é avaliada comoTrue .

Podem ser salvos 3 bytes se for permitido retornar a resposta como uma lista de listas (removendo a compreensão [0]no final da primeira lista). Mas como não tenho certeza se é uma saída válida, estou contando-os.

Objeto Pascal, 204 200 bytes

Dois loops, usando um binário para descobrir quais fantasmas + pacman estão presentes. Aceita os argumentos da linha de comando. Obrigado a @manatwork por salvar mais alguns 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.

Versão antiga usando um conjunto, 227 209 bytes

Dois loops, usando um conjunto para descobrir quais fantasmas + pacman estão presentes. Aceita os argumentos da linha de 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.

Programa PHP, 84 bytes

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

• recebe argumentos da linha de comando, imprime o resultado como uma matriz.
• nome do arquivo não deve ser nenhum dos fantasmas ou 'Pac-Man'!
• colapso curto: remove (se 'Pac-Man' estiver em argumentos: nada, mais todos os argumentos) de todos os fantasmas; imprimir resultado recursivamente

exemplos:

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

Função PHP, 90 bytes

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

pega e retorna uma matriz, use matriz vazia para entrada vazia, nenhum outro valor falso!

pensamentos adicionais

• substitua in_array(...)por strstr(join($argv),'-')para detectar em -vez de Pac-Man(-2)
• usar ereg('-',join($argv)) vez disso (outro -2)
• programa pode perder outros 6 bytes no PHP <5.4 com register_globalson
• para fazer com que o programa imprima uma lista separada por vírgula: substitua <?print_r(por <?=join(',',(+2). Convém adicionar ;echo""à chamada uma quebra de linha

jq, 69 caracteres

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

A entrada é JSON, a saída é JSON, a sintaxe condicional é problemática.

Exemplo de execução:

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

Teste on-line:

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

TSQL (sqlserver 2016), 114 bytes

Golfe:

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

Idioma do Lotus Notes @Formula, 85 84 75 74 caracteres

-1 caractere invertendo a atribuição @If

-9 Alterou @Contains (i; "-") para @Like (i; "% -%") e removeu @Trim (não é necessário se exibido usando o espaço como separador)

-1 removendo a nova linha

Crie um formulário com dois campos: i (Texto, Editável, Multi-valor) e o (Texto, Computado, Multi-valor). Digite a seguinte fórmula em o:

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

No cliente Notes, crie um novo documento usando o formulário, insira os nomes no campo i e pressione F9 para atualizar o documento. Resposta exibida no campo o.

Isso tira proveito do fato de que @Like e @Replace podem ser usados ​​tanto em uma string quanto em uma lista de strings.

C # 135 bytes 126 bytes

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

(onde i é uma matriz de cadeias contendo a entrada)

Depois de examinar os outros exemplos, vejo que o C # é uma linguagem detalhada :)

Pyke, 45 39 38 37 32 bytes

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

Experimente aqui!

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

Lote, 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%

(Subtraia 6 bytes para :~1,-1se os espaços em branco à esquerda e à direita forem aceitáveis.) Requer Pac-Man na maiúscula, mas os fantasmas não fazem distinção entre maiúsculas e minúsculas.

Japt , 38 bytes (Não concorrente)

Recebe entrada como uma matriz de strings, gera uma matriz de strings

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

Experimente online