Pac-Man'den bir hayalet listesi verildiğinde, bu zorluğun hangi hayaletlerin eksik olduğunu çıkarmalısınız. Bunu yapabildiğiniz kadar az baytta yapmanız gerekir.

Giriş

Giriş, içerebilecek bir sayı hayaletini içerecek bir dize veya listeden oluşacaktır;

• Blinky
• kapkara
• pembemsi
• Clyde

Bununla birlikte, girdi Pac-Man (bu noktalama işaretleriyle) içerebilir. Bu nedenle, bir listedeki maksimum öğe miktarı herhangi bir sırayla beş olacaktır. Listede geçersiz öğe bulunmayacağı varsayılabilir.

Çıktı

Çıktı bir dize veya listeden oluşacaktır. Bu, girişte olmayan tüm hayaletleri herhangi bir sırayla içerecektir. Ancak, eğer Pac-Man girdi ise, tüm hayaletler eksik sayılır (çünkü onları yer.).

Test durumları

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

Bu codegolf, bayt sayısı ne kadar düşükse o kadar iyidir.

Jöle , 25 22 bayt

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

Bu monadik bir fonksiyondur. G / Ç, listeler halindedir. Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

Sondaki satır besleme hızı önemli. Giriş ve çıkış virgülle ayrılmıştır.

Çevrimiçi deneyin! (İlk satır, satır besleme ayrılmış bir test takımı sağlar.)

açıklama

Retina'nın en son eklemesini (veri tekilleştirme aşamaları) bu kadar kısa sürede göstermeyi beklemiyordum, ancak bu zorluk için gerçekten yardımcı oldu. :)

Aşama 1: Grep Karşıtı

A`-

Aşınma önleme aşamaları, verilen regex ile eşleşen tüm çizgileri atar. Regex adil -ve giriş her zaman tek bir satırdır, bu nedenle giriş varsa tüm hayaletleri atar Pac-Man.

Aşama 2: Değiştirme

$
,;BliNClyde,INPiN

Bu sadece sabit dize ekler ,;BliNClyde,INPiN. Bu, bazı temizlik işlemlerinden sonra çıktıdaki hayaletlerin listesi olacaktır.

Aşama 3: İkame

N
nky,

Üç *nkyhayaleti bir Nönceki aşamada yazdığımızı (ve onlardan sonra virgül almayı bıraktığımızı ) ve şimdi birkaç bayttan tasarruf sağlayan bu kestirme yolu genişlettiğimize dikkat edin. Artık her bir hayaletten sonra virgül var ve biz giriş hayaletlerini ve noktalı virgülle ayrılmış tüm hayaletlerin listesini elde ettik.

Aşama 3: Veri Tekilleştirme

D`\w+,

Bu yeni kısım. Veri tekilleştirme aşamaları verilen regex'in tüm örneklerini bulur ve daha önce eşleşen bir alt dizeye eşit olan tüm eşleşen alt dizeleri atar. Regex, hem girdi hem de potansiyel çıktılar listesindeki tüm hayaletleri basitçe eşleştirir. Girdi bir hayalet içeriyorsa, aynı hayalet ikinci listede tekrar eşleştirilir ve atılır. Aksi halde, hayalet ikinci listede ilk kez eşleştirilir ve saklanır. Bundan sonra, noktalı virgül sonrasındaki liste bizim istenen çıktımızdır. Geride kalan tek şey biraz temizlik:

Aşama 5: İkame

.*;|,$

Her şeyi noktalı virgül ile eşleştirilen dizenin sonundaki virgülle eşleştirip kaldırırız.

Python 3, 75 bayt

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

Giriş virgülle ayrılmış bir dizedir ve çıktı bir liste olacaktır.

JavaScript ES6, 85 78 bayt

Anonim bir işlev olarak

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

Bugün bu filterişlevi öğrendim . Eğlence!

Neil sayesinde 15 bayt kurtarıldı.

Kullanımı:

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

Çevrimiçi deneyin!

@MartinEnder tarafından -6 bayt

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

Yakut dizileri, ayarlanan çıkarma işleminden geçerek uygun hayaletleri çıkarmayı çok kolaylaştırır.

Perl, 51 bayt

50 bayt kodu + 1 -n

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

kullanım

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

Gerekirse, bunu yerine + 3 bayt, her hayalet sonra bir boşluk ekleme çıkış düzeltebilirler print$@ile print"$@ ".

@MartinEnder sayesinde -6 bayt !

Perl, 53 bayt

51 bayt kodu + 2 -na

Smartmatch operatörünü kullanarak alternatif bir çözüm:

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

kullanım

Boşluktan ayrılmış bir girdi listesi gerektirir:

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 Bayt

=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

Leaky Nun sayesinde -1 bayt daha!

Girdiler boşlukla ayrılmış, tümü küçük harf olmalıdır; pac-man girişinde olmadığı sürece eksik hayaletleri ayrı satırlara çıkarır.

C, 171 bayt

NULL olarak sonlandırılmış bir dizge dizisi iletin f()ve eksik isimleri yazdıracak.

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

Ideone üzerinde deneyin.

PowerShell v4 +, 107 bayt

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

PowerShell üçlü bir operatör veya herhangi bir mapstil operatöründen yoksun olduğundan, diğerlerine kıyasla biraz gergin . Sonuç olarak, biz kendimizi inşa ediyoruz.

Girdiyi $naçık bir dizge dizisi olarak alır (örn .\which-ghosts-are-missing.ps1 @('Clyde','Blinky'). Programın geri kalanı, bazı mantıklarla dizine eklediğimiz bir diziden oluşan bir sözde üçlülüktür [...]. Mantık, -karakterin bir -joinarada girilen dizinin herhangi bir yerinde olup olmadığıdır). Tek bir dizgeye girip daha sonra chardiziyi tekrar kullanmak, -inişleci kullanmak için: Böylece, eğer Pac-Mangiriş dizisinde ise, bu olacak $TRUEve sözde üçlü dizinin ikinci elemanı seçilecektir. seçilmek.

Pac-ManDizide olmayan durumda , sözde üçlü dizinin ilk kısmı çıktıdır. Bu, $ntüm hayaletlerin (içine kaydedilmiş $x) bir dizisiyle birleştirilen giriş dizisinin bir birleşimidir . Biz boru yeni dizisi içine Group-Objecthangi öğeleri gibi irade grubu birlikte, daha sonra kullanarak seçmek Where-Objectyoluyla başka ad ( |?{...}onların sadece öğeler .countolduğu -eqiçin UAL 1. Hepsi bir Pars içinde kapsüllü, ve biz seçmek .Nameözelliği. V4 gereksinimi içinde devreye giriyor, v4'te olduğu gibi |Select Name, bir kaç bayttan tasarruf eden, bunun gibi bir şey kullanmak yerine, böyle bir etiketlenebilir etikete başvurabilirsiniz .

Aksi halde, Pac-Mangiriş dizisinde olduğu için tüm hayaletleri çıkarmamız gerekir. Neyse ki biz zaten bunları içine kaydettik $x, bu yüzden bu durumda seçim. Her iki durumda da, boru hattı artık bir dizi hayalet dizisi içeriyor ve çıktılar kapalı.

Örnekler

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 bayt

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

Giriş bir liste olmalı, çıkış a ile ayrılmış bir isim dizisi olacaktır ,.

Pac-Man'ı işlemeyen 61 byte sürümü:

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

Haskell, 91 bayt

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

Giriş, dizelerin bir listesidir. Listeyi olduğu gibi kullanmaya veya "Pac-Man" in varlığına bağlı olarak bir liste farkı oluşturmaya karar verir.

Ekstra eğlence için, burada Pac-Man yok:

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

Yakında bu cevabı geliştirecek, gece geç saatlerde süper yaptım.

Python 3, 77 bayt

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

İşte 89 byte ile oynadığım ancak çözemediğim başka bir cevap :(

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

Ve işte 85 bayttaki orijinal:

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

Bunların hepsi boşluk / virgülle ayrılmış adların tek bir dizesini alır.

05AB1E, 47 44 bayt

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

Açıklama

•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

Çevrimiçi deneyin

Python 2, 151 bayt

Python kümeleri ve dizgileri kullanan cevapları olduğu için, kendimi listelerle çalışmam konusunda kısıtlamaya karar verdim. Ancak, alınan yaklaşım kullanılandan farklı olduğundan, burada:

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

beklenen girdi, dizelerin bir listesidir.

Yaklaşım, 0,1,2,3 ve 4 elementlerin olası tüm kombinasyonlarını (hesaba katmadan) kaba bir şekilde uygulamaktır. Bu tarafından yapılır

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

hangi döner

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

ve giriş listesine ek olarak, hayaletlerin tam listesini veren sonucunu bulun.

Ardından dizgenin 'Pac-Man'girişin bir parçası olup olmadığı kontrol edilir ve olması durumunda tüm hayaletlerin listesi döndürülür. Aksi takdirde, yalnızca girişin bir parçası olmayanlar döndürülür.

Tüm hayalet adlarını ( o) içeren listenin alfabetik olarak sıralandığına ve aynı şekilde ( sorted(l+x)) olarak oluşturulan listeye gittiğine dikkat edin . Bu Python'da olmasından kaynaklanmaktadır ['a','b']==['b','a']olarak değerlendirilir Falseise ['a','b']==['a','b']olarak değerlendirilir True.

Cevabın bir liste listesi olarak geri alınmasına izin verilirse 3 bayt kaydedilebilir ( [0]ilk liste kavramasının sonunda çıkarılarak ). Ama bunun geçerli bir çıktı olduğundan emin olmadığım için onları sayıyorum.

Nesne Pascal, 204 200 bayt

İki hayalet, hangi hayaletlerin + pacman'ın olduğunu bulmak için bir ikili kullanarak. Argümanları komut satırından alır. Biraz daha bayt tasarrufu için @ manatwork teşekkürler!

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.

Bir kümeyi kullanarak eski sürüm, 227 209 bayt

Hangi hayaletlerin + pacman'ın bulunduğunu bulmak için bir set kullanarak iki döngü. Argümanları komut satırından alır.

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 programı, 84 bayt

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

• komut satırından argümanları alır, sonucu bir dizi olarak yazdırır.
• dosya adı hiçbir hayalet veya 'Pac-Man' olmamalıdır!
• kısa arıza: kaldır (eğer 'Pac-Man' argümanlardaysa: hiçbir şey, diğer tüm argümanlar) tüm hayaletlerden; sonucu tekrarlayarak yazdır

örnekler:

>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 işlevi, 90 bayt

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

bir dizi alır ve döndürür, boş girdi için boş bir dizi kullanın, başka bir sahte değer yoktur!

başka düşünceler

• (-2) yerine algılamak için in_array(...)ile değiştirinstrstr(join($argv),'-')-Pac-Man
• kullanmak ereg('-',join($argv))yerine (başka bir -2)
• ile programı PHP <5.4 başka 6 bayt kaybedebilir register_globalsüzerinde
• Programı virgülle ayrılmış bir liste halinde yazdırmak için: (+2) <?print_r(ile değiştirin <?=join(',',. ;echo""Satır sonu için aramaya eklemek isteyebilirsiniz.

jq, 69 karakter

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

Giriş JSON, çıktı JSON, koşullu sözdizimi ağrıdır.

Örnek çalışma:

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

Çevrimiçi test:

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

TSQL (sqlserver 2016), 114 bayt

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

Keman

Lotus Notes @Formula dili, 85 84 75 74 karakter

@If atamasını tersine çevirerek -1 karakter

-9 @Contains (i; "-") ila @Like (i; "% -%") değiştirildi ve @Trim (seper olarak boşluk kullanılarak görüntüleniyorsa gerekli değil) kaldırıldı

-1 satırsonunu kaldırarak

İki alanlı bir form oluşturun: i (Metin, Düzenlenebilir, Çoklu Değer) ve o (Metin, Bilgisayar, Çoklu Değer). Aşağıdaki formülü o'ya girin:

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

Notes istemciden formu kullanarak yeni bir belge oluşturun, i alanına adları girin ve belgeyi yenilemek için F9 tuşuna basın. Cevap o alanında görüntülenir.

Bu, @Like ve @Replace'in hem bir dizgede hem de bir dizgiler listesinde kullanılabileceği gerçeğinden yararlanır.

C # 135 bayt 126 bayt

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

(i girişi içeren bir dize dizisidir)

Diğer örneklere baktıktan sonra, C # 'nın oldukça ayrıntılı bir dil olduğunu görüyorum :)

Pyke, 45 39 38 37 32 bayt

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

Burada dene!

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

Toplu iş, 141 bayt

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

(Öndeki :~1,-1ve takip eden boşlukların kabul edilebilir olup olmadığı için 6 bayt'ı çıkarın .) Başlık durumunda Pac-Man gereklidir, ancak hayaletler büyük / küçük harfe duyarsızdır.

Japt , 38 bayt ( Yarışmıyor )

Bir dizge dizisi olarak girdi alır, bir dizge dizisi çıkarır

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

Çevrimiçi deneyin