Trong phiên bản arcade của trò chơi, Pac-Man ăn pac-dot. Tuy nhiên, trong thử thách này, anh ta thèm khát các ký tự chữ và số và dấu câu trong một chuỗi.

Nhiệm vụ của bạn là tạo ra một hàm cung cấp cho Pac-Man một chuỗi, đánh giá xem anh ta có thể ăn nó hay không và trả về chuỗi có vị trí của Pac-Man trong đó.

Pac-Man ( <) ăn các nhân vật từ trái sang phải, để lại dấu gạch dưới hoặc khoảng trắng cho mỗi nhân vật khi anh ta đi và mục tiêu của anh ta là đi từ vị trí đầu tiên-1 đến vị trí cuối cùng + 1:

1. <Pac
2. _<ac
3. __<c
4. ___<

Tuy nhiên, kẻ thù tự nhiên của Pac-Man, hồn ma, sẽ ngăn anh ta lại nếu anh ta gặp một trong những chữ cái trong từ "GHOST" (không phân biệt chữ hoa chữ thường). Hàm của bạn sẽ trả về chuỗi có vị trí của Pac-Man khi anh ta gặp ghostnhân vật:

1. <No!
2. _<o!

Thứ duy nhất có thể đánh bại một con ma là một viên năng lượng. Nếu Pac-Man đạt được một chữ cái trong từ "PELLET" (cũng không phân biệt chữ hoa chữ thường) trước khi đến với một con ma, anh ta sẽ ăn ma và tiếp tục di chuyển, và viên đó sẽ được sử dụng hết. Viên năng lượng có thể xếp chồng lên nhau (tức là trong ppggcả hai con ma sẽ bị ăn). Ký tự T tồn tại vừa là ma vừa là viên, vì vậy nó có thể bị bỏ qua (được coi như bất kỳ chữ cái nào khác, như a).

1. <Pop
2. _<op
3. __<p
4. ___<

Để làm rõ hơn, trong chuỗi "Pac-Man thua ở đây", các thao tác sau xảy ra:

P <P, +1 Pellet (1 pellet)
a <a
c <c
- <-
M <M
a <a
n <n
  <[space]
l <l, +1 Pellet (2 pellets)
o <o, -1 Pellet (1 pellet)
s <s, -1 Pellet (0 pellets)
e <e, +1 Pellet (1 pellet)
s <s, -1 Pellet (0 pellets)
  <[space]
h <h, ghost wins, returns
e
r
e

Ví dụ

Input: Pacman wins!
Output: ____________<

Input: Pacman loses wah-wah :(
Output: _______________<h-wah :(

Input: PELLET PELLET GHOST
Output: ___________________<

Input: Hello World!
Output: <Hello World!

Input: <_!@12<_<_<
Output: ___________<

Đây là mã golf - điểm thấp nhất trong các chiến thắng byte.

Thạch, 34 33 byte

Œl“ʋʋ“ṁḍ»ċ€Ð€IF+\‘0ṭi0ð’”_×;”<;ṫ@

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

Tôi nghĩ rằng cuối cùng tôi cũng bắt đầu hiểu Jelly. Cảm thấy hơi đáng sợ.

Võng mạc , 55 38 byte

i`^(([elp])|[^ghos]|(?<-2>.))*
$.&$*_<

Hãy thử trực tuyến! (Dòng đầu tiên chỉ cho phép chạy một số trường hợp thử nghiệm cùng một lúc.)

Giải trình

Vấn đề cơ bản là tìm ra tiền tố dài nhất không có dấu ngoặc đơn đóng chưa từng có. Ngoại trừ việc chúng ta có thể sử dụng một trong hai e, lhoặc pthay (và một trong hai g, h, ohoặc sthay ).

Do đó, giải pháp này gần như là một ví dụ trong sách giáo khoa về các nhóm cân bằng. Tôi sẽ không đi sâu vào chi tiết về cách chúng hoạt động, vì mã này về cơ bản giống như ví dụ tiêu chuẩn bạn có thể đọc trong câu trả lời SO của tôi về các nhóm cân bằng .

Do đó, toàn bộ chương trình là một sự thay thế regex duy nhất. Các ikích hoạt trường hợp không nhạy cảm. Sau đó, chúng ta hoặc ghép một viên với [elp]và tăng bộ đếm độ sâu (dưới dạng nhóm bắt giữ của nhóm 2) hoặc chúng ta ghép một thứ không phải là ma với [ghos]hoặc chúng ta ghép một con ma với .và làm giảm bộ đếm độ sâu bằng cách bật ra từ ngăn xếp 2. Tất nhiên, về nguyên tắc, điều này cho phép kết hợp một viên với [^ghos]phần hoặc không ma với .phần đó, nhưng nhờ kết hợp tham lam và cách regex được quay lại, những khả năng này không bao giờ được thử bởi công cụ regex.

Việc thay thế sau đó sử dụng hai tính năng cụ thể của Retina: $*lặp lại ký tự bên phải nhiều lần theo quy định của mã thông báo bên trái. Mã thông báo $.&đó là độ dài của toàn bộ trận đấu. Điều này chỉ có nghĩa là chúng ta thay thế từng nhân vật trong trận đấu bằng a _. Và sau đó chúng tôi cũng nối thêm <vào những dấu gạch dưới. Phần đầu vào không ăn chỉ đơn giản là không bị ảnh hưởng bởi sự thay thế.

Python 2, 114 113 108 byte

s=raw_input()
p=i=0
for c in s:
 p+=(c in'plePLE')-(c in'ghosGHOS')
 if p<0:break
 i+=1
print'_'*i+'<'+s[i:]

Python 2, 89 byte

Đôi khi quyết tâm bướng bỉnh của tôi để biến Python thành một ngôn ngữ chức năng có lợi ích của nó.

def f(s,l=1):l+=(s[:1]in'plePLE')-(s[:1]in'ghosGHOS');return s*l and'_'+f(s[1:],l)or'<'+s

(Hơi) vô duyên:

def f(s, l=1):
    l += (s[:1] in 'plePLE') - (s[:1] in 'ghosGHOS')
    return (s * l) and ('_' + f(s[1:], l)) or ('<' + s)

Xây dựng chuỗi kết quả bằng cách sử dụng đệ quy. Bản cập nhật cho l(cho "cuộc sống") thêm 1 cho viên ( True - False == 1), trừ 1 cho ma ( False - True == -1) và thêm 0 cho bất kỳ nhân vật nào khác. Nó cũng thêm 0 khi schuỗi rỗng, nhờ vào lát cắt của Python và thực tế là '' in any_str == Truevậy, nên viên và ma hủy bỏ.

Câu lệnh return sử dụng test and b or athay a if test else bcho một byte. Trường hợp cơ sở đệ quy xảy ra khi chuỗi kết thúc hoặc Pac-Man hết viên, được biểu diễn ngắn gọn là s*p, bằng ''(và do đó đánh giá là sai) khi hoặc s == ''hoặc p == 0.

C #, 269 256 232 212 211 byte

Lần đầu tiên được đăng trên đây, vì vậy điều này có thể dài hơn rất nhiều so với nó có thể (và có lẽ vì nó nằm trong C #). Bất kỳ lời khuyên về nơi tôi có thể rút ngắn nó sẽ là tuyệt vời!

Cảm ơn tất cả mọi người trong các ý kiến ​​đã giúp tôi!

Phiên bản chơi gôn

static void p(string x){int p=0,i=0;string t='<'+x;var s=t.ToCharArray();for(;++i<s.Length;){if("PELpel".Contains(s[i]))p++;if("GHOSghos".Contains(s[i])&&--p<0)break;s[i]='<';if(i>0)s[i-1]='_';}Console.Write(s);}

Phiên bản ung dung

static void p(string x) {
 int p = 0, i = 0;
 string t = '<' + x;
 var s = t.ToCharArray();
 for (; ++i < s.Length;) {
  if ("PELpel".Contains(s[i])) p++;
  if ("GHOSghos".Contains(s[i]) && --p < 0) break;
  s[i] = '<';
  if (i > 0) s[i - 1] = '_';
 }
 Console.Write(s);
}

Pyth, 53 48 44 byte

4 byte nhờ @ Pietu1998 cho thủ thuật !!@-> }(chỉ những người biết Pyth mới có thể hiểu)

++ * Jf <@ + sM._m - !! @ d "PELpel" !! @ d "GHOSghos" Q_1T00 \ _ \ <> QJ 
++ * Jf << !! @ d "GHOS" rQ1_1T00 \ _ \ <> QJ
++ * Jf <@ + sM._m-} d "PEL"} d "GHOS" rz1_1T00 \ _ \ <> zJ

Bộ thử nghiệm.

MATL , 37 36 35 byte

tkt'ghos'mw'pel'm-Ys1=Y>&)g95*60bhh

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

Giải trình

tkt      % Input string implicitly. Duplicate, convert to lower case, duplicate
'ghos'm  % True for "ghost" characters
w'pel'm  % Swap to bring lowercase copy to top. True for "pellet" characters
-Ys      % Subtract, cumulative sum. Pac-Man can reach until the first "1"
1=       % True for entries that equal 1
Y>       % Cumulative maximum. This gives false until the first true is found, and
         % true from there on
&)       % Split original string in two parts, given by the zeros and ones respectively
g95*     % Convert the first part into ones and multiply by 95. This gives a numerical
         % array containing number 95 (ASCII for '_')
60       % Push 60 (ASCII for '<')
b        % Bubble up second part of original string
hh       % Concatenate the three strings/arrays, automatically converting to char

JavaScript (ES6), 98 byte

s=>s.replace(/./g,c=>p<0?c:(p+=/[elp]/i.test(c)-/[ghos]/i.test(c))<0?"<"+c:"_",p=0)+"<".slice(p<0)

Giải thích: pduy trì số lượng viên hiện tại. Nếu nó đã âm, chúng ta chỉ cần trả lại ký tự và tiếp tục, để phần còn lại của chuỗi không bị ảnh hưởng. Mặt khác, chúng tôi kiểm tra ký tự hiện tại và nếu điều đó làm cho pâm tính, chúng tôi chèn <ký tự đó, nếu không, chúng tôi thay thế ký tự hiện tại bằng _. Cuối cùng, nếu pkhông bao giờ trở thành âm, chúng ta thêm một <chuỗi vào chuỗi.

Bình thường, 47 46 44 byte

++*\_Kh+f!h=+Z-}Jr@zT0"pel"}J"ghos"Uzlz\<>zK

Hãy thử trực tuyến. Bộ thử nghiệm.

Hoàn toàn là một cách tiếp cận khác với Leaky Nun, và tôi khá chắc chắn rằng điều này có thể được đánh gôn hơn nữa.

Lua, 198 190 184 185 163 byte

Ok, tôi thừa nhận, điều này là dài. Rất dài. Lua có một số công cụ để chơi xung quanh với các chuỗi, nhưng nó bị hạn chế, tương tự đối với các điều kiện cần nhiều không gian.

Chỉnh sửa: cảm ơn @LeakyNun vì đã tiết kiệm cho tôi 9 byte :) Mất một số byte để sửa lỗi

Chỉnh sửa 2: Giải pháp 163 byte được tìm thấy bởi @LeakyNun

i=0p=0n=...for c in n:gmatch"."do
p=p+(c:find"[ghosGHOS]"and-1or c:find"[pelPEL]"and 1or 0)if p<0then
break else i=i+1 end end print(('_'):rep(i)..'<'..n:sub(i+1))

185 cũ

p=0z=(...):gsub(".",function(c)p=p+(c:find"[ghosGHOS]"and-1or
c:find"[pelPEL]"and 1or 0)s=p<0 and 1or s
return s and c or'_'end)_,i,s=z:find"(_+)"print((s or'')..'<'..z:sub(1+(i or 0)))

Ung dung

i=0                        -- number of characters eaten
p=0                        -- pellet counter
n=...                      -- shorthand for the argument
for c in n:gmatch"."       -- iterate over each characters in the input
do
  p=p+(c:find"[ghosGHOS]"  -- if the current char is a GHOST
        and-1              -- decrement the pellet counter
      or c:find"[pelPEL]"  -- if it's a PELLET
        and 1              -- increment it
      or 0)                -- else, leave it alone
  if p<0                   -- if we try to eat a ghost without pellet
  then 
    break                  -- stop iterating
  else
    i=i+1                  -- else, increment our score
  end
end

print(('_'):rep(i)         -- print i*'_'
  ..'<'                    -- appended with Pacman
  ..n:sub(i+1))            -- appended with the remaining characters if we died

Python 3, 176 157 150 149 134 133 124 byte

Xác định hàm có tên flấy chuỗi làm đối số

def f(s):
 n=i=0
 for c in s:
  if c in"GgHhOoSs":
   if n:n-=1
   else:break
  n+=c in"PpEeLl";i+=1
 return"_"*i+"<"+s[i:]

Có thể được chơi golf nhiều hơn

Cảm ơn mọi người đã bình luận: D

Python 3, 114 110 byte

Mã golf đầu tiên của tôi.

Cảm ơn Dr Green Eggs và Iron Man vì đã tiết kiệm được 4 byte.

l,x=1,0
f,y,s="ghosGHOS","pelPEL",input()
while s[x:]*l:l+=(s[x]in y)-(s[x]in f);x+=l>0
print("_"*x+"<"+s[x:])

Sử dụng việc đánh giá các giá trị booleans thành một và bằng 0 để cô đọng logic VÀ thành một phép nhân. (0 * 0 = 0, 1 * 0 = 0, 1 * 1 = 1). Tôi hy vọng đây là một thử đầu tiên tốt.

Quyền hạn, 185

{$l=1;$o="";for($i=0;($i -lt $_.Length) -or (($o+="<") -and 0); $i++){if ($_[$i] -match '[pel]'){$l++}if($_[$i] -match '[ghos]'){$l--}if(!$l){$o+="<"+$_.substring($i);break}$o+="_"}$o}

Ung dung:

("Pacman wins!",
"Pacman loses wah-wah :(",
"PELLET PELLET GHOST",
"Hello World!"
) | 
% {
    $l=1;$o="";
    for($i = 0; ($i -lt $_.Length) -or (($o+="<") -and 0); $i++) {
        if ($_[$i] -match '[pel]') { $l++ }
        if ($_[$i] -match '[ghos]') { $l--}
        if (!$l) { $o+="<"+$_.substring($i); break }        
        $o += "_"
    }
    $o
}

Python3, 211 184 byte

Đối số 's' là một chuỗi

def f(s):
    p=c=0
    for i in s:
        if i in "gGhHoOsS":
            if p<1:break
            else:p-=1
        if i in "pPeElL":p+=1
        c+=1
    return"_"*c + "<" + s[c:]

Tôi sẽ đánh giá cao bất kỳ mẹo chơi golf nào vì đây là lần thử golf đầu tiên của tôi

Cảm ơn đã bình luận :)

Haskell, 119 113 byte

Cảm ơn Daniel Wagner cho 6 byte ít hơn.

p=(0!)
n!(c:s)|elem c"ghosGHOS"=if n<1then '<':c:s else(n-1)&s|elem c"elpELP"=(n+1)&s|0<1=n&s
_!_="<"
n&s='_':n!s

Gọi nó là p "Hello World!".

Đây 1thenlà trường hợp cạnh được diễn giải chính xác trong GHC của tôi (7.10), nhưng nó ném ra hầu hết các tô sáng cú pháp. Vì vậy, nó có thể được giải thích khác nhau trong trình biên dịch của bạn.

Ung dung:

pacman string = go 0 string

-- | In the golfed version: (!)
go _   []                   = "<"                            -- won
go pellets (char:string)
 | char `elem` "ghosGHOS"
 = if pellets < 1        then '<':char:string                -- lost
                         else nextStep (pellets - 1) string  -- ghost
 | char `elem` "elpELP"
 =                            nextStep (pellets + 1) string  -- pellet
 | otherwise
 =                            nextStep  pellets      string  -- anything else

-- | In the golfed version: (&)
nextStep pellets string = '_':(go pellets string)

C, 237 byte

#include<stdio.h>
#include<string.h>
main(p,i,j){char s[99];fgets(s,99,stdin);for(p=i=0;s[i];++i){if(strchr("GHOSghos",s[i])){if(p)p--;else break;}else if(strchr("PELpel",s[i]))p++;}j=i-(s[i]==0);while(j--)printf("_");printf("<%s",s+i);}

C ++, 315 373 327 byte

(Lưu ý: vẫn chơi gôn)

#include <iostream>
#include <string>
using namespace std;
int main(){string input;getline(cin, input);
if(input.find("Pac-Man loses")!=string::npos||input.find("Pacman loses")!=string::npos)
    cout<<"<"<<input.substr(15,input.length()-1);
else{for(unsigned i=0;i<=input.length();++i)
    cout << "_";
cout<<"<";
}return 0;
}

Ruby, (119 byte)

q=i=0;a=$**" ";a.split(//).each{|c|q+=((c+?p=~/[ple]/i)^1)-((c+?g=~/[ghos]/i)^1);q<0?break : i+=1};p ?_*i+?<+a[i..-1]

Có lẽ có một số thứ tôi đang thiếu vì tôi chưa quen với điều này ...

Ruby là bạn của tôi :)

Perl, 54 (52 + 2) byte

s/([pel](?1)*[ghos]|[^ghos
])*/'_'x(length$&).'<'/ei

Cần -pđược chỉ định trong các tùy chọn dòng lệnh.

Giải trình:

Các -ptùy chọn nguyên nhân báo cáo kết quả để được bao bọc trong một vòng lặp đọc sửa đổi-in, nơi trong mỗi lần lặp, $_chứa một dòng đầu vào, bao gồm cả dòng delimiter.

Regex phần lớn là ý tưởng giống như trong câu trả lời của Retina.

Gọi mẫu tìm kiếm là ([pel](?1)*[ghos]|[^ghos ])*"chấp nhận được". Sau đó, nó có thể được định nghĩa đệ quy là:

Một chuỗi là "chấp nhận được" nếu:

• Đó là một ký tự PELLETngoại trừ T, theo sau là một chuỗi chấp nhận được, theo sau là một ký tự GHOSTngoại trừ T.
• Đó là một nhân vật không GHOSTngoại trừ Tđó không phải là một nhân vật mới.
• Nó là sự kết hợp của bất kỳ số nào (bao gồm 0) của các chuỗi có thể chấp nhận.

Định nghĩa này cho phép nhiều viên hơn ma: một PELnhân vật có thể được ghép thành một nhân vật hoặc một nhân vật không phải là ma.

Chuỗi trống được coi là chấp nhận được, do đó regex được đảm bảo khớp ở vị trí 0, trong đó chuỗi con dài nhất có thể chấp nhận sẽ được khớp.

Chuỗi con dài nhất có thể chấp nhận này sau đó được khớp bởi các dấu gạch dưới có độ dài bằng nhau, theo sau là <.