En este desafío, dada una lista de fantasmas de Pac-Man, debe mostrar qué fantasmas faltan. Debes hacerlo en tan pocos bytes como puedas

Entrada

La entrada consistirá en una cadena o lista, que incluirá un número de fantasmas, que podrían incluir;

• Blinky
• Tinta
• Meñique
• Clyde

Sin embargo, la entrada también puede incluir Pac-Man (con esa puntuación). Por lo tanto, la cantidad máxima de elementos en una lista será de cinco, en cualquier orden. Se puede suponer que no habrá elementos inválidos en la lista

Salida

La salida consistirá en una cadena o lista. Esto incluirá todos los fantasmas que no están en la entrada, en cualquier orden. Sin embargo, si Pac-Man está en la entrada, se considerará que faltan todos los fantasmas (porque se los come).

Casos de prueba

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 es codegolf, por lo que cuanto menor sea el bytecount, mejor.

Jalea , 25 22 bytes

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

Esta es una función monádica. I / O está en forma de listas. Pruébalo en línea!

Cómo 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+,
.*;|,$

El avance de línea final es significativo. La entrada y la salida están separadas por comas.

Pruébalo en línea! (La primera línea habilita un conjunto de pruebas separado por salto de línea).

Explicación

No esperaba poder mostrar la última incorporación de Retina (etapas de deduplicación) tan pronto, pero es realmente útil para este desafío. :)

Etapa 1: Anti-Grep

A`-

Las etapas anti-grep descartan todas las líneas que coinciden con la expresión regular dada. La expresión regular es justa -y la entrada siempre es una sola línea, por lo que descarta todos los fantasmas si la entrada contiene Pac-Man.

Etapa 2: sustitución

$
,;BliNClyde,INPiN

Esto simplemente agrega la cadena fija ,;BliNClyde,INPiN. Esta será la lista de fantasmas en la salida después de una limpieza.

Etapa 3: sustitución

N
nky,

Tenga en cuenta que hemos escrito los tres *nkyfantasmas con un Nen la etapa anterior (y omitimos la coma después de ellos), y ahora ampliamos esta taquigrafía, lo que ahorra un par de bytes. Ahora hay una coma después de cada fantasma, y ​​tenemos los fantasmas de entrada y la lista de todos los fantasmas separados por punto y coma.

Etapa 3: deduplicación

D`\w+,

Esta es la nueva parte. Las etapas de deduplicación encuentran todas las instancias de la expresión regular dada y descartan todas las subcadenas coincidentes que son iguales a una subcadena coincidente anterior. La expresión regular simplemente coincide con todos los fantasmas, tanto en la entrada como en la lista de salidas potenciales. Si la entrada contiene un fantasma, el mismo fantasma volverá a coincidir en la segunda lista y se descartará. De lo contrario, el fantasma se compara por primera vez en la segunda lista y se mantiene. Entonces, después de esto, la lista después del punto y coma es nuestra salida deseada. Todo lo que queda es un poco de limpieza:

Etapa 5: sustitución

.*;|,$

Simplemente hacemos coincidir todo con el punto y coma, así como con la coma al final de la cadena y los eliminamos.

Python 3, 75 bytes

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

La entrada es una cadena separada por comas, y la salida será una lista.

JavaScript ES6, 85 78 bytes

Como una función anónima

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

Hoy aprendí sobre esta filterfunción. ¡Divertido!

15 bytes guardados gracias 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

Pruébalo en línea!

-6 bytes de @MartinEnder

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

Las matrices de rubíes pueden sufrir una resta determinada, lo que facilita la eliminación de los fantasmas apropiados.

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

Puedo modificar la salida si es necesario, agregando un espacio después de cada fantasma, para reemplazar print$@con + 3 bytes print"$@ ".

-6 bytes gracias a @MartinEnder !

Perl, 53 bytes

Código de 51 bytes + 2 para -na

Una solución alternativa, utilizando el operador smartmatch:

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

Uso

Requiere una lista de entrada separada por espacios:

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 más gracias a Leaky Nun!

La entrada debe estar delimitada por espacios, todo en minúsculas; genera fantasmas faltantes en líneas separadas a menos que pac-man esté en la entrada.

C, 171 bytes

Pase una serie de cadenas terminadas en NULL f()e imprimirá los nombres que faltan.

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

Pruébalo con ideone.

PowerShell v4 +, 107 bytes

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

Un poco torpe en comparación con otros, ya que PowerShell carece de un operador ternario o cualquier tipo de mapoperador de estilo. Como resultado, construimos el nuestro.

Toma la entrada $ncomo un conjunto explícito de cadenas (p .\which-ghosts-are-missing.ps1 @('Clyde','Blinky'). Ej . , El resto del programa es un pseudoternario que está compuesto por un conjunto que indexamos mediante alguna lógica [...]. La lógica es simplemente si el -carácter está en algún lugar del conjunto de entrada -joineditado conjuntamente en una sola cadena y luego volver a emitir como una charmatriz, para usar el -inoperador. Por lo tanto, si Pac-Manestá en la matriz de entrada, será $TRUEy se elegirá el segundo elemento de la matriz pseudoternaria, de lo contrario, el primero será ser elegido

Si es el caso que Pac-Manno está en la matriz, se emite la primera parte de la matriz pseudoternaria. Esa es una combinación de la matriz de entrada $nconcatenada con una matriz de todos los fantasmas (guardados en $x). Conectamos esa nueva matriz en la Group-Objectque se agruparán los elementos similares, luego seleccionaremos usando Where-Object(alias |?{...}solo a través de los elementos donde .countestán -eqnormalmente 1. Eso está todo encapsulado en un parens, y seleccionamos la .Namepropiedad. Aquí es donde entra el requisito de v4, como en v4 puede hacer referencia a una etiqueta de tabla hash como esta en lugar de usar algo como |Select Name, que ahorra varios bytes.

De lo contrario, dado que Pac-Manestá en la matriz de entrada, necesitamos generar todos los fantasmas. Afortunadamente, ya los guardamos $x, así que esa es la opción en este caso. De cualquier manera, la canalización ahora contiene una serie de cadenas de fantasmas, y la salida es implícita.

Ejemplos

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)

La entrada debe ser una lista, la salida será una cadena de nombres separados por a ,.

Versión de 61 bytes que no maneja 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"]

La entrada es una lista de cadenas. Decide si usar la lista tal como está o hacer una diferencia de lista basada en la presencia de "Pac-Man".

Para mayor diversión, aquí no hay Pac-Man:

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

Estará mejorando esta respuesta pronto, lo hizo muy tarde en la noche.

Python 3, 77 bytes

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

Aquí hay otra respuesta de 89 bytes con la que estaba jugando pero que no funcionó :(

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

Y aquí está el original en 85 bytes:

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

Todos estos toman una sola cadena de los nombres separados por espacios / comas.

05AB1E, 47 44 bytes

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

Explicación

•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

Pruébalo en línea

Python 2, 151 bytes

Como ya hay respuestas de Python utilizando conjuntos y cadenas, decidí limitarme a trabajar con listas, que resultaron ser bastante largas y poco competitivas. Sin embargo, como el enfoque adoptado es diferente al utilizado comúnmente, aquí 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

donde la entrada esperada es una lista de cadenas.

El enfoque consiste en aplicar fuerza bruta a todas las combinaciones posibles (sin tener en cuenta el orden) de 0,1,2,3 y 4 elementos. Esto se hace por

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

que vuelve

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

y encuentre el que, además de la lista de entrada, da como resultado la lista completa de fantasmas.

Luego se verifica si la cadena 'Pac-Man'es parte de la entrada y, en caso de serlo, se devuelve toda la lista de fantasmas. Si no, solo se devuelven los que no son parte de la entrada.

Observe que la lista que contiene todos los nombres de fantasmas ( o) está ordenada alfabéticamente y lo mismo ocurre con la lista creada como ( sorted(l+x)). Esto se debe al hecho de que en Python, ['a','b']==['b','a']se evalúa como Falsemientras que ['a','b']==['a','b']se evalúa como True.

Se pueden guardar 3 bytes si se permite devolver la respuesta como una lista de listas (eliminando la [0]comprensión al final de la primera lista). Pero como no estoy seguro de que sea una salida válida, los estoy contando.

Objeto Pascal, 204 200 bytes

Dos bucles, usando un binario para encontrar qué fantasmas + pacman están presentes. Toma los argumentos de la línea de comandos. ¡Gracias a @manatwork por guardar algunos bytes más!

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.

Sin golf:

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.

Versión anterior que usa un conjunto, 227 209 bytes

Dos bucles, usando un conjunto para encontrar qué fantasmas + pacman están presentes. Toma los argumentos de la línea de comandos.

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.

Sin golf:

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

• toma argumentos de la línea de comando, imprime el resultado como una matriz.
• ¡el nombre de archivo no debe ser ninguno de los fantasmas o 'Pac-Man'!
• breve desglose: eliminar (si 'Pac-Man' está en argumentos: nada, más todos los argumentos) de todos los fantasmas; imprimir resultado de forma recursiva

ejemplos:

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

Función PHP, 90 bytes

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

toma y devuelve una matriz, usa una matriz vacía para la entrada vacía, ¡ningún otro valor falso!

pensamientos adicionales

• reemplazar in_array(...)con strstr(join($argv),'-')para detectar en -lugar de Pac-Man(-2)
• utilizar ereg('-',join($argv))en su lugar (otro -2)
• el programa podría perder otros 6 bytes en PHP <5.4 con register_globalson
• Para hacer que el programa imprima una lista separada por comas: reemplace <?print_r(con <?=join(',',(+2). Es posible que desee agregar ;echo""a la llamada un salto de línea

jq, 69 caracteres

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

La entrada es JSON, la salida es JSON, la sintaxis condicional es dolorosa.

Ejecución de muestra:

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

Prueba en línea:

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

TSQL (sqlserver 2016), 114 bytes

Golfizado:

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

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

Sin golf:

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

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

Violín

Lenguaje Lotus Notes @Formula, 85 84 75 74 caracteres

-1 carácter invirtiendo la asignación @ If

-9 Cambió @Contains (i; "-") a @Like (i; "% -%") y eliminó @Trim (no es necesario si se muestra usando el espacio como separador)

-1 eliminando la nueva línea

Cree un formulario con dos campos: i (Texto, Editable, Valor múltiple) yo (Texto, Computado, Valor múltiple). Ingrese la siguiente fórmula en o:

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

Desde el cliente Notes, cree un nuevo documento utilizando el formulario, ingrese los nombres en el campo i y presione F9 para actualizar el documento. La respuesta se muestra en el campo o.

Esto aprovecha el hecho de que @Like y @Replace pueden usarse tanto en una cadena como en una lista de cadenas.

C # 135 bytes 126 bytes

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

(donde i es una matriz de cadenas que contiene la entrada)

Después de mirar los otros ejemplos, veo que C # es más bien un lenguaje detallado :)

Pyke, 45 39 38 37 32 bytes

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

Pruébalo aquí!

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

(Reste 6 bytes :~1,-1si el espacio en blanco inicial y final es aceptable.) Requiere Pac-Man en el caso del título, pero los fantasmas no distinguen entre mayúsculas y minúsculas.

Japt , 38 bytes (no competidor)

Toma la entrada como una matriz de cadenas, emite una matriz de cadenas

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

Pruébalo en línea