Trong thử thách này, được đưa ra một danh sách các hồn ma từ Pac-Man, bạn phải xuất ra những con ma nào bị thiếu. Bạn phải làm điều đó trong vài byte như bạn có thể

Đầu vào

Đầu vào sẽ bao gồm một chuỗi hoặc danh sách, sẽ bao gồm một số ma, có thể bao gồm;

• Nháy mắt
• Inky
• Hồng
• Clyde

Tuy nhiên, đầu vào cũng có thể bao gồm Pac-Man (với dấu chấm câu đó). Vì vậy, số lượng mục tối đa trong danh sách sẽ là năm, theo bất kỳ thứ tự nào. Có thể giả định rằng sẽ không có mục nào không hợp lệ trong danh sách

Đầu ra

Đầu ra sẽ bao gồm một chuỗi, hoặc danh sách. Điều này sẽ bao gồm tất cả các bóng ma không có trong đầu vào, theo bất kỳ thứ tự nào. Tuy nhiên, nếu Pac-Man ở trong đầu vào, tất cả các hồn ma sẽ bị coi là mất tích (vì anh ta ăn chúng).

Các trường hợp thử nghiệm

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

Đây là codegolf, do đó, bytecount càng thấp thì càng tốt.

Thạch , 25 22 byte

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

Đây là một chức năng đơn âm. I / O ở dạng danh sách. Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Võng mạc , 45 byte

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

Các linefeed trailing là đáng kể. Đầu vào và đầu ra được phân tách bằng dấu phẩy.

Hãy thử trực tuyến! (Dòng đầu tiên cho phép bộ kiểm tra được phân tách bằng nguồn cấp.)

Giải trình

Tôi không mong đợi có thể sớm thể hiện sự bổ sung mới nhất của Retina (giai đoạn lặp lại), nhưng nó thực sự hữu ích cho thử thách này. :)

Giai đoạn 1: Chống Grep

A`-

Các giai đoạn chống grep loại bỏ tất cả các dòng khớp với biểu thức chính quy. Regex chỉ là -và đầu vào luôn là một dòng duy nhất, vì vậy điều này sẽ loại bỏ tất cả các bóng ma nếu đầu vào chứa Pac-Man.

Giai đoạn 2: Thay thế

$
,;BliNClyde,INPiN

Điều này chỉ đơn giản nối thêm chuỗi cố định ,;BliNClyde,INPiN. Đây sẽ là danh sách các bóng ma trong đầu ra sau khi dọn dẹp.

Giai đoạn 3: Thay thế

N
nky,

Lưu ý rằng chúng tôi đã viết ba *nkycon ma với một Ngiai đoạn trước (và bỏ qua dấu phẩy sau chúng) và bây giờ chúng tôi mở rộng tốc ký này, giúp tiết kiệm một vài byte. Bây giờ có một dấu phẩy sau mỗi một con ma, và chúng ta đã có những bóng ma đầu vào và danh sách tất cả các con ma được phân tách bằng dấu chấm phẩy.

Giai đoạn 3: Chống trùng lặp

D`\w+,

Đây là phần mới. Các giai đoạn trùng lặp tìm thấy tất cả các trường hợp của biểu thức chính quy đã cho và loại bỏ tất cả các chuỗi con phù hợp bằng với một chuỗi con được so khớp trước đó. Regex đơn giản chỉ phù hợp với tất cả các bóng ma, cả trong đầu vào và trong danh sách các đầu ra tiềm năng. Nếu đầu vào chứa một con ma, thì con ma tương tự sẽ được khớp lại trong danh sách thứ hai và bị loại bỏ. Mặt khác, con ma được khớp lần đầu tiên trong danh sách thứ hai và được giữ lại. Vì vậy, sau này, danh sách sau dấu chấm phẩy là đầu ra mong muốn của chúng tôi. Tất cả những gì còn lại là một chút dọn dẹp:

Giai đoạn 5: Thay thế

.*;|,$

Chúng tôi chỉ đơn giản khớp mọi thứ cho đến dấu chấm phẩy cũng như dấu phẩy ở cuối chuỗi và xóa chúng.

Python 3, 75 byte

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

Đầu vào là một chuỗi được phân tách bằng dấu phẩy và đầu ra sẽ là một danh sách.

JavaScript ES6, 85 78 byte

Là một chức năng ẩn danh

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

Hôm nay tôi đã tìm hiểu về filterchức năng này . Vui vẻ!

15 byte được lưu nhờ Neil.

Sử dụng:

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

Hãy thử trực tuyến!

-6 byte từ @MartinEnder

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

Các mảng Ruby có thể trải qua phép trừ được thiết lập, làm cho nó rất dễ dàng để loại bỏ các bóng ma thích hợp.

Perl, 51 byte

Mã 50 byte + 1 cho -n

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

Sử dụng

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

Tôi có thể sửa đổi đầu ra nếu cần thiết, thêm một khoảng trắng sau mỗi bóng ma, cho + 3 byte thay thế print$@bằng print"$@ ".

-6 byte nhờ @MartinEnder !

Perl, 53 byte

Mã 51 byte + 2 cho -na

Một giải pháp thay thế, sử dụng toán tử smartmatch:

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

Sử dụng

Yêu cầu một danh sách đầu vào được phân tách bằng dấu cách:

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 hơn nhờ Leaky Nun!

Đầu vào phải được phân cách không gian, tất cả chữ thường; xuất ra bóng ma bị thiếu trên các dòng riêng biệt trừ khi pac-man ở đầu vào.

C, 171 byte

Truyền một mảng kết thúc bằng chuỗi NULL f()và nó sẽ in ra các tên còn thiếu.

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

Hãy thử nó trên ideone.

PowerShell v4 +, 107 byte

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

Một chút lộn xộn so với những người khác, vì PowerShell thiếu một toán tử ternary hoặc bất kỳ loại maptoán tử kiểu nào. Kết quả là, chúng tôi xây dựng riêng của chúng tôi.

Đưa đầu vào $nthành một chuỗi rõ ràng của chuỗi (ví dụ: .\which-ghosts-are-missing.ps1 @('Clyde','Blinky')Phần còn lại của chương trình là một chuỗi giả bao gồm một mảng mà chúng ta lập chỉ mục thông qua một số logic [...]. Logic đơn giản là liệu -ký tự có ở bất kỳ vị trí nào trong mảng đầu vào -joined với nhau không thành một chuỗi duy nhất và sau đó đúc lại thành một charmảng, để sử dụng -intoán tử. Do đó, nếu Pac-Manở trong mảng đầu vào, $TRUEphần tử này sẽ là phần tử thứ hai của mảng giả sẽ được chọn, nếu không thì phần đầu tiên sẽ được chọn được chọn

Nếu đó là trường hợp Pac-Mankhông nằm trong mảng, phần đầu tiên của mảng giả ba là đầu ra. Đó là sự kết hợp của mảng đầu vào được $nnối với một mảng gồm tất cả các bóng ma (được lưu vào $x). Chúng tôi đưa mảng mới vào Group-Objectđó sẽ nhóm các mục giống nhau lại với nhau, sau đó chọn sử dụng Where-Object(bí danh |?{...}chỉ thông qua các mục mà chúng .countlà -eqthông thường 1. Tất cả được gói gọn trong một parens và chúng tôi chọn thuộc .Nametính. Đây là nơi yêu cầu v4 xuất hiện, như dưới v4, bạn có thể tham chiếu nhãn có thể băm như thế này thay vì sử dụng một cái gì đó như |Select Name, giúp tiết kiệm một vài byte.

Mặt khác, vì Pac-Mannằm trong mảng đầu vào, chúng ta cần xuất tất cả các bóng ma. Rất may, chúng tôi đã lưu chúng vào $x, vì vậy đó là lựa chọn trong trường hợp này. Dù bằng cách nào, đường ống hiện chứa một chuỗi các bóng ma và đầu ra là ẩn.

Ví dụ

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)

Đầu vào phải là một danh sách, đầu ra sẽ là một chuỗi các tên được phân tách bằng a ,.

Phiên bản 61 byte không xử lý 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"]

Đầu vào là một danh sách các chuỗi. Nó quyết định nên sử dụng danh sách nguyên trạng hay thực hiện phân biệt danh sách dựa trên sự hiện diện của "Pac-Man".

Để thêm phần thú vị, ở đây không có Pac-Man:

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

Sẽ sớm cải thiện câu trả lời này, làm nó siêu muộn vào ban đêm.

Python 3, 77 byte

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

Đây là một câu trả lời khác với 89 byte mà tôi đã chơi nhưng không giải quyết được :(

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

Và đây là bản gốc với 85 byte:

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

Tất cả đều có một chuỗi các tên được phân tách bằng dấu cách / dấu phẩy.

05AB1E, 47 44 byte

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

Giải thích

•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

Dùng thử trực tuyến

Python 2, 151 byte

Vì đã có câu trả lời Python bằng cách sử dụng các bộ và chuỗi, tôi quyết định hạn chế bản thân làm việc với các danh sách, hóa ra nó khá dài và không cạnh tranh. Tuy nhiên, vì cách tiếp cận được thực hiện khác với cách tiếp cận phổ biến được sử dụng, đây là:

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

trong đó đầu vào dự kiến ​​là một danh sách các chuỗi.

Cách tiếp cận là bruteforce tất cả các kết hợp có thể (không tính đến thứ tự) gồm 0,1,2,3 và 4 yếu tố. Điều này được thực hiện bởi

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

trả về

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

và tìm một trong đó, ngoài danh sách đầu vào dẫn đến danh sách ma hoàn chỉnh.

Sau đó, nó được kiểm tra nếu chuỗi 'Pac-Man'là một phần của đầu vào và, trong trường hợp đó, toàn bộ danh sách ma được trả về. Nếu không, chỉ những cái không phải là một phần của đầu vào được trả về.

Lưu ý rằng danh sách chứa tất cả các tên ma ( o) được sắp xếp theo thứ tự abc và tương tự với danh sách được xây dựng là ( sorted(l+x)). Điều này là do thực tế là trong Python, ['a','b']==['b','a']được đánh giá là Falsetrong khi ['a','b']==['a','b']được đánh giá là True.

3 byte có thể được lưu nếu được phép trả về câu trả lời dưới dạng danh sách các danh sách (bằng cách xóa [0]phần cuối của phần hiểu danh sách đầu tiên). Nhưng vì tôi không chắc đó là đầu ra hợp lệ nên tôi đang đếm chúng.

Đối tượng Pascal, 204 200 byte

Hai vòng lặp, sử dụng nhị phân để tìm ma nào + pacman có mặt. Đưa ra các đối số từ dòng lệnh. Cảm ơn @manatwork vì đã lưu thêm một số 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.

Ung dung:

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.

Phiên bản cũ sử dụng một bộ, 227 209 byte

Hai vòng lặp, sử dụng một bộ để tìm ma nào + pacman có mặt. Đưa ra các đối số từ dòng lệnh.

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.

Ung dung:

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.

Chương trình PHP, 84 byte

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

• lấy đối số từ dòng lệnh, in kết quả dưới dạng một mảng.
• Tên tệp không được là bất kỳ con ma nào hoặc 'Pac-Man'!
• phân tích ngắn: xóa (nếu 'Pac-Man' nằm trong các đối số: không có gì, tất cả các đối số khác) khỏi tất cả các bóng ma; in kết quả đệ quy

ví dụ:

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

Hàm PHP, 90 byte

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

lấy và trả về một mảng, sử dụng mảng trống cho đầu vào trống, không có giá trị giả nào khác!

suy nghĩ thêm

• thay thế in_array(...)bằng strstr(join($argv),'-')để phát hiện -thay vì Pac-Man(-2)
• sử dụng ereg('-',join($argv))thay thế (-2 khác)
• chương trình có thể mất thêm 6 byte trong PHP <5.4 với register_globalstrên
• để làm cho chương trình in một danh sách được phân tách bằng dấu phẩy: thay thế <?print_r(bằng <?=join(',',(+2). Bạn có thể muốn thêm ;echo""vào cuộc gọi để ngắt dòng

jq, 69 ký tự

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

Đầu vào là JSON, đầu ra là JSON, cú pháp có điều kiện là đau.

Chạy mẫu:

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

Bài kiểm tra trực tuyến:

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

TSQL (sqlserver 2016), 114 byte

Chơi gôn

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

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

Ung dung:

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

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

Vĩ cầm

Lotus Notes @Formula ngôn ngữ, 85 84 75 74 ký tự

-1 ký tự bằng cách đảo ngược phép gán @ If

-9 Đã thay đổi @Contains (i; "-") thành @Like (i; "% -%") và xóa @Trim (không cần thiết nếu được hiển thị bằng cách sử dụng khoảng trắng dưới dạng ngăn cách)

-1 bằng cách xóa dòng mới

Tạo một biểu mẫu với hai trường: i (Văn bản, Có thể chỉnh sửa, Đa giá trị) và o (Văn bản, Tính toán, Đa giá trị). Nhập công thức sau vào o:

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

Từ ứng dụng ghi chú, tạo tài liệu mới bằng biểu mẫu, nhập tên trong trường i và nhấn F9 để làm mới tài liệu. Câu trả lời hiển thị trong trường o.

Điều này lợi dụng thực tế là cả @Like và @Replace đều có thể được sử dụng trên cả chuỗi hoặc trên danh sách các chuỗi.

C # 135 byte 126 byte

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

(trong đó i là một chuỗi chuỗi chứa đầu vào)

Sau khi xem các ví dụ khác, tôi thấy rằng C # là một ngôn ngữ dài dòng :)

Pyke, 45 39 38 37 32 byte

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

Hãy thử nó ở đây!

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

Mẻ, 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%

(Trừ 6 byte cho :~1,-1nếu khoảng trắng đầu và cuối có thể chấp nhận được.) Yêu cầu Pac-Man trong trường hợp tiêu đề nhưng bóng ma không phân biệt chữ hoa chữ thường.

Japt , 38 byte (Không cạnh tranh)

Lấy đầu vào là một chuỗi các chuỗi, xuất ra một chuỗi các chuỗi

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

Dùng thử trực tuyến