ในเกมอาร์เคดของ Pac-Man จะกิน pac-dot อย่างไรก็ตามในการท้าทายนี้เขารู้สึกหิวสำหรับตัวอักษรและตัวเลขและเครื่องหมายวรรคตอนในสตริง

งานของคุณคือการสร้างฟังก์ชั่นที่ดึงสตริงของ Pac-Man ประเมินว่าเขาสามารถกินได้หรือไม่และส่งคืนสตริงด้วยตำแหน่งของ Pac-Man ในนั้น

Pac-Man ( <) กินอักขระจากซ้ายไปขวาปล่อยขีดเส้นใต้หรือช่องว่างสำหรับอักขระแต่ละตัวขณะที่เขาไปและเป้าหมายของเขาคือการได้รับจากตำแหน่งแรก -1 ถึงตำแหน่งสุดท้าย + 1:

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

อย่างไรก็ตามผีศัตรูธรรมชาติของแพค - แมนจะหยุดเขาหากเขาพบตัวอักษรหนึ่งตัวในคำว่า "GHOST" (ไม่ต้องตรงตามตัวพิมพ์ใหญ่ - เล็ก) ฟังก์ชั่นของคุณควรคืนสตริงด้วยตำแหน่งของ Pac-Man ในขณะที่เขาพบghostตัวละคร:

1. <No!
2. _<o!

สิ่งเดียวที่สามารถเอาชนะผีได้คือเม็ดพลังงาน หาก Pac-Man ถึงตัวอักษรในคำว่า "PELLET" (ไม่ต้องตรงตามตัวพิมพ์เล็กและตัวพิมพ์ใหญ่) ก่อนที่จะมาหาผีเขาจะกินผีและเคลื่อนไหวต่อไปและเม็ดนั้นจะหมดไป เม็ดพลังงานสามารถสแต็ค (เช่นในppggทั้งสองผีจะถูกกิน) Tตัวละครอยู่ในฐานะเป็นทั้งผีและเม็ดจึงสามารถละเลย (ถือว่าเป็นตัวอักษรอื่น ๆ เช่นa)

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

เพื่อชี้แจงเพิ่มเติมในสตริง "Pac-Man สูญเสียที่นี่" การดำเนินการดังต่อไปนี้เกิดขึ้น:

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

ตัวอย่าง

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: ___________<

นี่คือโค้ดกอล์ฟ - คะแนนต่ำสุดที่ชนะเป็นไบต์

เยลลี่, 34 33 ไบต์

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

ลองออนไลน์!

ฉันคิดว่าในที่สุดฉันก็เริ่มเข้าใจเจลลี่ รู้สึกกลัวเล็กน้อย

เรติน่า , 55 38 ไบต์

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

ลองออนไลน์! (บรรทัดแรกเพียงแค่อนุญาตให้เรียกใช้กรณีทดสอบหลายรายการพร้อมกัน)

คำอธิบาย

ปัญหาสำคัญคือการค้นหาคำนำหน้าที่ยาวที่สุดที่ไม่มีวงเล็บปิดที่ไม่ตรงกัน ยกเว้นว่าเราสามารถใช้อย่างใดอย่างหนึ่งe, lหรือpในสถานที่(และทั้งg, h, oหรือในสถานที่ของs)

ดังนั้นวิธีนี้จึงเป็นตัวอย่างตำราเรียนของกลุ่มการทรงตัว ฉันจะไม่ไปลงรายละเอียดมากเกินไปเกี่ยวกับวิธีการทำงานเป็นรหัสนี้เป็นหลักเช่นเดียวกับตัวอย่างมาตรฐานคุณสามารถอ่านข้อมูลเกี่ยวกับในคำตอบของฉันดังนั้นกลุ่มสมดุล

โปรแกรมทั้งหมดจึงเป็นการทดแทน regex เดียว iป็นกรณีความไม่รู้สึก จากนั้นเราจะจับคู่เม็ดกับ[elp]และเพิ่มตัวนับความลึก (ในรูปแบบของสแต็กการจับกลุ่ม2) หรือเราจับคู่สิ่งที่ไม่ใช่ผีกับ[ghos]หรือจับคู่ผีกับ.และลดระดับเคาน์เตอร์ลึกโดยการโผล่จากกอง2. แน่นอนว่าในหลักการนี้จะช่วยให้การจับคู่เม็ดกับ[^ghos]ส่วนหรือไม่ใช่ส่วนที่มีผี.แต่ด้วยการจับคู่โลภและวิธีการที่ regex ย้อนรอยความเป็นไปได้เหล่านี้จะไม่ถูกใช้โดยโปรแกรม regex

การทดแทนนั้นใช้คุณสมบัติเฉพาะของ Retina สองประการ: $*ทำซ้ำอักขระทางด้านขวาหลาย ๆ ครั้งตามที่ระบุโดยโทเค็นทางด้านซ้าย โทเค็นนั้น$.&คือความยาวของการแข่งขันทั้งหมด _เพียงแค่นี้ก็หมายความว่าเราแทนที่ตัวละครแต่ละตัวในการแข่งขันด้วย และจากนั้นเราก็ผนวก a <ไปสู่ขีดล่างเหล่านั้น ส่วนของอินพุตที่ไม่ได้กินก็ยังคงไม่ได้รับผลกระทบจากการทดแทน

Python 2, 114 113 108 bytes

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 ไบต์

บางครั้งความมุ่งมั่นของฉันที่จะทำให้ Python เป็นภาษาที่ใช้งานได้ประโยชน์

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

(เล็กน้อย) ungolfed:

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

สร้างสตริงผลลัพธ์โดยใช้การสอบถามซ้ำ การอัปเดตเป็นl(สำหรับ "ชีวิต") จะเพิ่ม 1 สำหรับเม็ด ( True - False == 1) ลบ 1 สำหรับผี ( False - True == -1) และเพิ่ม 0 สำหรับอักขระอื่น ๆ นอกจากนี้ยังเพิ่ม 0 เมื่อsเป็นสตริงว่างด้วยการแบ่งส่วนของ Python และความจริงที่ว่า'' in any_str == Trueดังนั้นเม็ดและผีจึงถูกยกเลิก

คำสั่ง return ใช้test and b or aแทนa if test else bการบันทึกหนึ่งไบต์ กรณีฐานเรียกซ้ำเกิดขึ้นเมื่อทั้งปลายสตริงหรือ Pac-Man ไหลออกมาจากเม็ดตัวแทนชัดถ้อยชัดคำเป็นs*pซึ่งเท่ากับ''(และดังนั้นจึงประเมินเท็จ) เมื่อทั้งสองหรือs == ''p == 0

C #, 269 256 232 212 211 ไบต์

โพสต์ครั้งแรกที่นี่ดังนั้นนี่น่าจะนานกว่านั้นมาก (และอาจเป็นเพราะมันอยู่ใน C #) เคล็ดลับใด ๆ ที่ฉันสามารถทำให้สั้นลงได้

ขอบคุณทุกคนในความคิดเห็นที่ช่วยฉัน!

รุ่น Golfed

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

เวอร์ชันที่ไม่ดี

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 ไบต์

ขอบคุณ 4 ไบต์สำหรับ @ Pietu1998 สำหรับเคล็ดลับ!!@-> }(ซึ่งมีเพียงคนที่รู้จัก Pyth สามารถเข้าใจได้)

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

ชุดทดสอบ

MATL , 37 36 35 ไบต์

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

ลองออนไลน์!

คำอธิบาย

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 ไบต์

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

คำอธิบาย: pเก็บรักษาจำนวนเม็ดปัจจุบัน ถ้ามันเป็นค่าลบเราเพียงแค่ส่งคืนตัวละครและเดินหน้าต่อไปเพื่อไม่ให้แตะส่วนที่เหลือ มิฉะนั้นเราจะตรวจสอบตัวละครในปัจจุบันและหากที่ทำให้pกลายเป็นเชิงลบเราใส่ตัวละครมิฉะนั้นเราแทนที่ตัวละครในปัจจุบันมี< _ในที่สุดถ้าpไม่เคยกลายเป็นลบเราต่อท้าย<สตริง

Pyth, 47 46 44 ไบต์

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

ลองออนไลน์ ชุดทดสอบ

ค่อนข้างเป็นวิธีที่แตกต่างจากของ Leaky Nun และฉันค่อนข้างแน่ใจว่านี่สามารถเล่นกอล์ฟต่อไปได้

Lua, 198 190 184 185 163 Bytes

ตกลงฉันยอมรับว่ามันยาว นานมาก. Lua มีเครื่องมือบางอย่างที่ใช้เล่นกับสตริง แต่มีข้อ จำกัด เช่นเดียวกับเงื่อนไขที่ใช้พื้นที่จำนวนมาก

แก้ไข: ขอบคุณ @LeakyNun สำหรับการบันทึกฉัน 9 ไบต์ :) ทำไบต์หายบางส่วนเพื่อแก้ไขข้อบกพร่อง

แก้ไข 2: 163 Bytes พบโดย @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

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

Ungolfed

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 ไบต์

กำหนดฟังก์ชั่นชื่อfซึ่งใช้สตริงเป็นอาร์กิวเมนต์

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

สามารถเล่นกอล์ฟได้มากกว่านี้

ขอบคุณทุกคนที่แสดงความคิดเห็น: D

Python 3, 114 110 ไบต์

รหัสกอล์ฟครั้งแรกของฉัน

ขอบคุณ Dr Green Eggs และ Iron Man สำหรับการบันทึก 4 ไบต์

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

ใช้การประเมินผลของบูลีนกับหนึ่งและศูนย์เพื่อย่อตรรกะและการคูณ (0 * 0 = 0, 1 * 0 = 0, 1 * 1 = 1) ฉันหวังว่านี่จะเป็นการลองครั้งแรกที่ดี

พาวเวอร์เซลล์, 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}

Ungolfed:

("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 ไบต์

อาร์กิวเมนต์ 's' เป็นสตริง

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

ฉันขอขอบคุณเคล็ดลับการเล่นกอล์ฟเพราะนี่เป็นความพยายามครั้งแรกของฉันในการเล่นกอล์ฟ

ขอบคุณสำหรับการแสดงความคิดเห็น :)

Haskell, 119 113 ไบต์

ขอบคุณ Daniel Wagner น้อยกว่า 6 ไบต์

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

p "Hello World!"เรียกว่าเป็น

นี่1thenคือกรณีขอบที่ตีความได้อย่างถูกต้องใน GHC ของฉัน (7.10) แต่มันก็มีไฮไลท์ไวยากรณ์ส่วนใหญ่ ดังนั้นมันอาจถูกตีความต่างกันในคอมไพเลอร์ของคุณเช่นกัน

Ungolfed:

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 ไบต์

#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 ไบต์

(หมายเหตุ: ยังคงเล่นกอล์ฟ)

#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 ไบต์)

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]

อาจมีบางสิ่งที่ฉันขาดไปเพราะฉันใหม่กับสิ่งนี้ ...

Ruby เป็นเพื่อนของฉัน :)

Perl, 54 (52 + 2) ไบต์

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

จำเป็น-pต้องระบุในตัวเลือกบรรทัดคำสั่ง

คำอธิบาย:

-pตัวเลือกที่เป็นสาเหตุของคำสั่งที่จะห่อในวงอ่านแก้ไขพิมพ์ซึ่งในแต่ละวงย้ำ$_มีสายของท่านรวมทั้งตัวคั่นบรรทัด

Regex นั้นเป็นแนวคิดเดียวกันกับในคำตอบของ Retina

เรียกรูปแบบการค้นหา([pel](?1)*[ghos]|[^ghos ])*"ยอมรับได้" จากนั้นมันสามารถนิยามซ้ำ:

สตริงเป็น "ยอมรับ" ถ้า:

• มันเป็นตัวละครในPELLETยกเว้นTตามด้วยสตริงที่ยอมรับตามตัวละครในยกเว้นGHOSTT
• มันเป็นตัวละครที่ไม่ได้อยู่ในนั้นGHOSTยกเว้นTว่าไม่ใช่ตัวอักษรขึ้นบรรทัดใหม่
• มันคือการเชื่อมต่อของจำนวนใด ๆ (รวมถึง 0) ของสตริงที่ยอมรับได้

คำจำกัดความนี้อนุญาตให้ใช้เม็ดมากกว่าผี: PELตัวละครอาจถูกจับคู่เป็นตัวละครเม็ดหรือตัวละครที่ไม่ใช่ผี

สตริงว่างถือเป็นที่ยอมรับได้ดังนั้น regex จึงรับประกันว่าจะจับคู่ที่ตำแหน่ง 0 โดยที่สตริงย่อยที่ยอมรับได้ยาวที่สุดจะถูกจับคู่

<ยอมรับย่อยที่ยาวที่สุดนี้จะถูกจับคู่แล้วโดยขีดความยาวเท่ากันตามมาด้วย