Dans ce défi, étant donné une liste de fantômes de Pac-Man, vous devez générer les fantômes manquants. Vous devez le faire en aussi peu d'octets que possible

Contribution

L'entrée consistera en une chaîne ou une liste, qui comprendra un certain nombre de fantômes, qui pourraient inclure;

• Blinky
• Inky
• Pinky
• Clyde

Cependant, l'entrée peut également inclure Pac-Man (avec cette ponctuation). Ainsi, le nombre maximal d'éléments dans une liste sera de cinq, dans n'importe quel ordre. On peut supposer qu'aucun élément invalide ne figurera dans la liste

Sortie

La sortie consistera en une chaîne ou une liste. Cela comprendra tous les fantômes qui ne sont pas dans l'entrée, dans n'importe quel ordre. Cependant, si Pac-Man est en entrée, tous les fantômes seront considérés comme manquants (car il les mange).

Cas de 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

Il s'agit de codegolf, donc plus le bytecount est bas, mieux c'est.

Gelée , 25 22 octets

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

Il s'agit d'une fonction monadique. Les E / S se présentent sous forme de listes. Essayez-le en ligne!

Comment ça marche

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

Rétine , 45 octets

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

Le saut de ligne arrière est important. L'entrée et la sortie sont séparées par des virgules.

Essayez-le en ligne! (La première ligne active une suite de tests séparés par un saut de ligne.)

Explication

Je ne m'attendais pas à pouvoir montrer le dernier ajout de Retina (étapes de déduplication) si tôt, mais c'est vraiment utile pour ce défi. :)

Étape 1: Anti-Grep

A`-

Les étapes anti-grep rejettent toutes les lignes qui correspondent à l'expression régulière donnée. Le regex est juste -et l'entrée est toujours une seule ligne, donc cela rejette tous les fantômes si l'entrée contient Pac-Man.

Étape 2: substitution

$
,;BliNClyde,INPiN

Cela ajoute simplement la chaîne fixe ,;BliNClyde,INPiN. Ce sera la liste des fantômes dans la sortie après un nettoyage.

Étape 3: substitution

N
nky,

Notez que nous avons écrit les trois *nkyfantômes avec un Ndans l'étape précédente (et omis la virgule après eux), et nous développons maintenant ce raccourci, qui économise quelques octets. Il y a maintenant une virgule après chaque fantôme, et nous avons les fantômes d'entrée et la liste de tous les fantômes séparés par un point-virgule.

Étape 3: déduplication

D`\w+,

Ceci est la nouvelle partie. Les étapes de déduplication trouvent toutes les instances de l'expression régulière donnée et ignorent toutes les sous-chaînes correspondantes qui sont égales à une sous-chaîne correspondante précédente. Le regex correspond simplement à tous les fantômes, à la fois dans l'entrée et dans la liste des sorties potentielles. Si l'entrée contient un fantôme, le même fantôme sera à nouveau mis en correspondance dans la deuxième liste et sera rejeté. Sinon, le fantôme est mis en correspondance pour la première fois dans la deuxième liste et conservé. Donc après cela, la liste après le point-virgule est notre sortie souhaitée. Tout ce qui reste est un peu de nettoyage:

Étape 5: Substitution

.*;|,$

Nous faisons simplement correspondre le tout au point-virgule ainsi qu'à la virgule à la fin de la chaîne et les supprimons.

Python 3, 75 octets

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

L'entrée est une chaîne séparée par des virgules et la sortie sera une liste.

JavaScript ES6, 85 78 octets

En tant que fonction anonyme

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

Aujourd'hui, j'ai découvert cette filterfonction. Amusement!

15 octets économisés grâce à Neil.

Usage:

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

Rubis, 55 49 octets

Essayez-le en ligne!

-6 octets de @MartinEnder

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

Les tableaux Ruby peuvent subir une soustraction d'ensemble, ce qui permet de supprimer très facilement les fantômes appropriés.

Perl, 51 octets

Code 50 octets + 1 pour -n

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

Usage

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

Je peux modifier la sortie si nécessaire, en ajoutant un espace après chaque fantôme, pour + 3 octets en remplaçant print$@parprint"$@ " .

-6 octets grâce à @MartinEnder !

Perl, 53 octets

Code de 51 octets + 2 pour -na

Une solution alternative, utilisant l'opérateur smartmatch:

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

Usage

Nécessite une liste d'entrées séparées par des espaces:

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 octets

=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 octet de plus grâce à Leaky Nun!

L'entrée doit être délimitée par des espaces, toutes en minuscules; affiche les fantômes manquants sur des lignes distinctes sauf si pac-man est en entrée.

C, 171 octets

Passez un tableau de chaînes terminé par NULL à f(), et il imprimera les noms manquants.

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

Essayez-le sur ideone.

PowerShell v4 +, 107 octets

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

Un peu maladroit par rapport aux autres, car PowerShell manque d'un opérateur ternaire ou de toute sorte de map opérateur style. En conséquence, nous construisons le nôtre.

Prend l'entrée $ncomme un tableau explicite de chaînes (par exemple .\which-ghosts-are-missing.ps1 @('Clyde','Blinky'),. Le reste du programme est un pseudo-ternaire qui est composé d'un tableau dans lequel nous indexons via une logique [...]. La logique est simplement de savoir si le -caractère est n'importe où dans le tableau d'entrée -joinédité ensemble en une seule chaîne, puis refondue en chartableau, afin d'utiliser l' -inopérateur. Ainsi, si Pac-Manest dans le tableau d'entrée, ce sera $TRUEet le deuxième élément du tableau pseudo-ternaire sera choisi, sinon le premier sera être choisi.

Si c'est le cas qui Pac-Mann'est pas dans le tableau, la première partie du tableau pseudo-ternaire est sortie. C'est une combinaison du tableau d'entrée $nconcaténé avec un tableau de tous les fantômes (enregistrés dans $x). Nous dirigeons ce nouveau tableau vers Group-Objectlequel regrouper les éléments similaires, puis sélectionnons using Where-Object(aliasé |?{...}uniquement par les éléments où leur .countest -equal 1. Tout est encapsulé dans une parens, et nous sélectionnons la .Namepropriété. C'est là que l'exigence v4 entre en jeu, comme sous v4, vous pouvez référencer une étiquette de hachage comme celle-ci plutôt que d'utiliser quelque chose comme|Select Name , ce qui économise plusieurs octets.

Sinon, puisque se Pac-Mantrouve dans le tableau d'entrée, nous devons sortir tous les fantômes. Heureusement, nous les avons déjà enregistrés $x, c'est donc le choix dans ce cas. Dans les deux cas, le pipeline contient désormais un tableau de chaînes de fantômes et la sortie est implicite.

Exemples

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 octets

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

L'entrée doit être une liste, la sortie sera une chaîne de noms séparés par un ,.

Version de 61 octets qui ne gère pas Pac-Man:

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

Haskell, 91 octets

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

L'entrée est une liste de chaînes. Il décide d'utiliser la liste telle quelle ou de faire une différence de liste en fonction de la présence de "Pac-Man".

Pour plus de plaisir, voici pas de Pac-Man:

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

Améliorera bientôt cette réponse, l'a fait très tard dans la nuit.

Python 3, 77 octets

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

Voici une autre réponse à 89 octets avec laquelle je jouais mais qui n'a pas fonctionné :(

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

Et voici l'original à 85 octets:

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

Ils prennent tous une seule chaîne de noms séparés par des espaces / virgules.

05AB1E, 47 44 octets

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

Explication

•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

Essayez-le en ligne

Python 2, 151 octets

Comme il existe déjà des réponses Python utilisant des ensembles et des chaînes, j'ai décidé de me limiter à travailler avec des listes, qui se sont révélées assez longues et non compétitives. Cependant, comme l'approche adoptée est différente de l'approche courante utilisée, la voici:

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

où l'entrée attendue est une liste de chaînes.

L'approche consiste à brutaliser toutes les combinaisons possibles (sans tenir compte de l'ordre) de 0,1,2,3 et 4 éléments. Cela se fait par

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

qui revient

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

et trouver celui qui, en plus de la liste d'entrée, donne la liste complète des fantômes.

Ensuite, il est vérifié si la chaîne 'Pac-Man'fait partie de l'entrée et, si c'est le cas, la liste entière des fantômes est retournée. Sinon, seuls ceux qui ne font pas partie de l'entrée sont retournés.

Notez que la liste contenant tous les noms fantômes ( o) est triée par ordre alphabétique et il en va de même pour la liste construite en tant que ( sorted(l+x)). Cela est dû au fait qu'en Python, ['a','b']==['b','a']est évalué comme Falsealors qu'il ['a','b']==['a','b']est évalué commeTrue .

3 octets peuvent être sauvegardés s'il est permis de renvoyer la réponse sous forme de liste de listes (en supprimant le [0]à la fin de la première compréhension de liste). Mais comme je ne suis pas sûr que ce soit une sortie valide, je les compte.

Pascal Objet, 204 200 octets

Deux boucles, utilisant un binaire pour trouver quels fantômes + pacman sont présents. Prend les arguments de la ligne de commande. Merci à @manatwork d'avoir économisé encore plus d'octets!

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.

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

Ancienne version utilisant un ensemble, 227 209 octets

Deux boucles, en utilisant un ensemble pour trouver quels fantômes + pacman sont présents. Prend les arguments de la ligne de commande.

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.

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

Programme PHP, 84 octets

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

• prend les arguments de la ligne de commande, imprime le résultat sous forme de tableau.
• le nom de fichier ne doit pas être l'un des fantômes ou «Pac-Man»!
• brève ventilation: supprimer (si «Pac-Man» est dans les arguments: rien, sinon tous les arguments) de tous les fantômes; imprimer le résultat récursivement

exemples:

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

Fonction PHP, 90 octets

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

prend et retourne un tableau, utilisez un tableau vide pour une entrée vide, aucune autre valeur falsifiée!

pensées supplémentaires

• remplacer in_array(...)par strstr(join($argv),'-')pour détecter -au lieu de Pac-Man(-2)
• utilisation ereg('-',join($argv)) place (un autre -2)
• programme pourrait perdre encore 6 octets en PHP <5.4 avec register_globals on
• pour que le programme imprime une liste séparée par des virgules: remplacez <?print_r(par <?=join(',',(+2). Vous voudrez peut-être ajouter ;echo""à l'appel pour un saut de ligne

jq, 69 caractères

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

L'entrée est JSON, la sortie est JSON, la syntaxe conditionnelle est douloureuse.

Exemple d'exécution:

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 en ligne:

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

TSQL (sqlserver 2016), 114 octets

Golfé:

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

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

Non golfé:

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

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

Violon

Langue Lotus Notes @Formula, 85 84 75 74 caractères

-1 caractère en inversant l'affectation @If

-9 Changé @Contains (i; "-") en @Like (i; "% -%") et supprimé @Trim (pas nécessaire si affiché en utilisant l'espace comme séparateur)

-1 en supprimant la nouvelle ligne

Créez un formulaire avec deux champs: i (Texte, Modifiable, Multi-valeur) et o (Texte, Calculé, Multi-valeur). Entrez la formule suivante en o:

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

À partir du client Notes, créez un nouveau document à l'aide du formulaire, entrez le (s) nom (s) dans le champ i et appuyez sur F9 pour actualiser le document. Réponse affichée dans le champ o.

Cela profite du fait que @Like et @Replace peuvent tous deux être utilisés soit sur une chaîne, soit sur une liste de chaînes.

C # 135 octets 126 octets

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

(où i est un tableau de chaînes contenant l'entrée)

Après avoir regardé les autres exemples, je vois que C # est plutôt un langage verbeux :)

Pyke, 45 39 38 37 32 octets

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

Essayez-le ici!

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

Lot, 141 octets

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

(Soustrayez 6 octets :~1,-1si les espaces de début et de fin sont acceptables.) Requiert Pac-Man dans le cas de titre mais les fantômes ne sont pas sensibles à la casse.

Japt , 38 octets (non concurrent)

Prend l'entrée comme un tableau de chaînes, génère un tableau de chaînes

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

Essayez-le en ligne