Dalam versi gim arcade, Pac-Man makan pac-dots. Namun, dalam tantangan ini, dia haus akan karakter alfanumerik dan tanda baca dalam sebuah string.

Tugas Anda adalah membuat fungsi yang memberi makan Pac-Man sebuah string, mengevaluasi apakah dia bisa memakannya atau tidak, dan mengembalikan string dengan lokasi Pac-Man di dalamnya.

Pac-Man ( <) makan karakter dari kiri ke kanan, meninggalkan garis bawah atau spasi untuk setiap karakter saat ia berjalan, dan tujuannya adalah untuk mendapatkan dari posisi pertama-1 ke posisi terakhir +1:

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

Namun, musuh alami Pac-Man, hantu, akan menghentikannya jika ia menemukan salah satu huruf dalam kata "GHOST" (tidak peka huruf besar kecil). Fungsi Anda harus mengembalikan string dengan lokasi Pac-Man saat ia menemukan ghostkarakter:

1. <No!
2. _<o!

Satu-satunya hal yang dapat mengalahkan hantu adalah pelet kekuatan. Jika Pac-Man mencapai huruf dalam kata "PELLET" (juga tidak peka huruf besar-kecil) sebelum datang ke hantu, ia akan memakan hantu itu dan terus bergerak, dan pelet itu akan habis. Pelet listrik dapat ditumpuk (yaitu, di ppggkedua hantu akan dimakan). The T karakter ada sebagai baik sebagai hantu dan pelet, sehingga dapat diabaikan (diperlakukan sebagai surat lainnya, seperti a).

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

Untuk lebih memperjelas, dalam string "Pac-Man kehilangan di sini", operasi berikut terjadi:

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

Contohnya

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

Ini adalah kode-golf - skor terendah dalam byte yang menang.

Jelly, 34 33 byte

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

Cobalah online!

Saya pikir saya akhirnya mulai mengerti Jelly. Terasa agak menakutkan.

Retina , 55 38 byte

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

Cobalah online! (Baris pertama hanya memungkinkan menjalankan beberapa test case sekaligus.)

Penjelasan

Masalahnya adalah pada dasarnya untuk menemukan awalan terpanjang yang tidak memiliki kurung tutup yang tidak cocok. Kecuali bahwa kita dapat menggunakan salah e, latau pdi tempat (dan baik g, h, oatau sdi tempat ).

Oleh karena itu, solusi ini hampir merupakan contoh buku teks dari kelompok penyeimbang. Saya tidak akan membahas terlalu banyak tentang cara kerjanya, karena kode ini pada dasarnya sama dengan contoh standar yang dapat Anda baca di dalam jawaban SO saya tentang menyeimbangkan kelompok .

Oleh karena itu seluruh program merupakan pengganti satu regex. The imengaktifkan kasus-ketidakpekaan. Kemudian kami mencocokkan pelet dengan [elp]dan menambah penghitung kedalaman (dalam bentuk tumpukan tangkapan kelompok 2), atau kami mencocokkan sesuatu yang bukan hantu dengan [ghos]atau kami mencocokkan hantu dengan .dan mengurangi penghitung kedalaman dengan muncul dari tumpukan 2. Tentu saja, pada prinsipnya ini memungkinkan pencocokan pelet dengan [^ghos]bagian atau non-hantu dengan .bagian, tetapi berkat pencocokan serakah dan cara regex mundur, kemungkinan ini tidak pernah dicoba oleh mesin regex.

Substitusi kemudian menggunakan dua fitur khusus Retina: $*mengulang karakter ke kanan sebanyak yang ditentukan oleh token di sebelah kirinya. Token itu $.&adalah panjang dari seluruh pertandingan. Ini hanya berarti bahwa kami mengganti setiap karakter dalam pertandingan dengan a _. Dan kemudian kami juga menambahkan <ke garis bawah itu. Bagian dari input yang tidak dimakan tetap tidak terpengaruh oleh substitusi.

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

Terkadang tekad saya yang keras kepala untuk menjadikan Python sebagai bahasa fungsional memiliki manfaatnya.

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

(Sedikit) tidak berbulu:

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

Membangun string hasil menggunakan rekursi. Pembaruan ke l(untuk "live") menambahkan 1 untuk pelet ( True - False == 1), kurangi 1 untuk hantu ( False - True == -1), dan tambahkan 0 untuk karakter lainnya. Ini juga menambahkan 0 kapan sstring kosong, terima kasih untuk mengiris Python dan fakta bahwa '' in any_str == True, sehingga pelet dan hantu membatalkan.

Penggunaan pernyataan kembali test and b or adi tempat a if test else buntuk menyimpan satu byte. Kasus dasar rekursi terjadi ketika string berakhir atau Pac-Man kehabisan pelet, secara ringkas direpresentasikan sebagai s*p, yang sama dengan ''(dan karenanya bernilai false) ketika salah satu s == ''atau p == 0.

C #, 269 256 232 212 211 Bytes

Posting pertama di sini, jadi ini mungkin jauh lebih lama daripada yang seharusnya (dan mungkin karena itu dalam C #). Setiap tips di mana saya bisa mempersingkat itu akan menjadi luar biasa!

Terima kasih kepada semua orang di komentar yang membantu saya!

Versi golf

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

Versi tidak disatukan

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 terima kasih kepada @ Pietu1998 untuk trik !!@-> }(yang hanya orang yang tahu Pyth bisa mengerti)

++ * 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

Suite uji.

MATL , 37 36 35 byte

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

Cobalah online!

Penjelasan

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)

Penjelasan: pmempertahankan jumlah pelet saat ini. Jika sudah negatif, kita cukup mengembalikan karakter dan melanjutkan, sehingga sisa string tidak tersentuh. Jika tidak, kami memeriksa karakter saat ini, dan jika itu pmenjadi negatif, kami menyisipkan <karakter, jika tidak kami ganti dengan karakter saat ini _. Akhirnya, jika ptidak pernah menjadi negatif, kita sufiks a <ke string.

Pyth, 47 46 44 byte

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

Cobalah online. Suite uji.

Pendekatan yang sangat berbeda dari Leaky Nun, dan saya cukup yakin ini bisa bermain golf lebih lanjut.

Lua, 198 190 184 185 163 Bytes

Ok, saya akui, ini panjang. Sangat panjang. Lua memiliki beberapa alat untuk bermain-main dengan string, tetapi terbatas, hal yang sama berlaku untuk persyaratan yang membutuhkan banyak ruang.

Sunting: terima kasih @LeakyNun karena telah menyelamatkan saya 9 byte :) Kehilangan beberapa byte untuk memperbaiki bug

Sunting 2: 163 Bytes solusi ditemukan oleh @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 tahun

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

Tidak disatukan

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

Tentukan fungsi bernama fyang mengambil string sebagai argumen

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

Mungkin bisa bermain golf lebih banyak

Terima kasih kepada semua orang yang berkomentar: D

Python 3, 114 110 byte

Golf kode pertama saya.

Terima kasih kepada Dr Green Eggs dan Iron Man untuk menghemat 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:])

Memanfaatkan evaluasi booleans ke satu dan nol untuk menyingkat logika DAN ke perkalian. (0 * 0 = 0, 1 * 0 = 0, 1 * 1 = 1). Saya harap ini adalah percobaan pertama yang baik.

Powershell, 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}

Tidak Disatukan:

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

Argumen 'adalah' string

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

Saya akan menghargai tips golf karena ini adalah upaya golf kode pertama saya

Terima kasih telah berkomentar :)

Haskell, 119 113 Bytes

Terima kasih kepada Daniel Wagner untuk 6 byte lebih sedikit.

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

Sebut saja sebagai p "Hello World!".

Ini 1thenadalah kasus tepi yang ditafsirkan dengan benar di GHC saya (7,10), tetapi itu melemparkan sebagian besar penyorot sintaks. Jadi itu mungkin ditafsirkan berbeda di kompiler Anda juga.

Tidak Disatukan:

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 Bytes

(Catatan: masih bermain golf)

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

Mungkin ada beberapa hal yang saya lewatkan karena saya baru dalam hal ini ...

Ruby adalah temanku :)

Perl, 54 (52 + 2) byte

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

Harus -pditentukan dalam opsi baris perintah.

Penjelasan:

The -ppilihan menyebabkan pernyataan untuk dibungkus dalam sebuah loop read-memodifikasi-print, di mana selama setiap iterasi loop, $_berisi garis masukan, termasuk pembatas jalur.

Regex sebagian besar ide yang sama seperti pada jawaban Retina.

Panggil pola pencarian ([pel](?1)*[ghos]|[^ghos ])* "dapat diterima". Kemudian dapat didefinisikan secara rekursif sebagai:

Sebuah string "dapat diterima" jika:

• Ini adalah karakter dalam PELLETkecuali untuk T, diikuti oleh string yang dapat diterima, diikuti oleh karakter dalam GHOSTkecuali untuk T.
• Ini adalah karakter yang tidak ada di dalam GHOSTkecuali untuk Tyang bukan karakter baris baru.
• Ini adalah gabungan dari sejumlah (termasuk 0) string yang dapat diterima.

Definisi ini memungkinkan lebih banyak pelet daripada hantu: PELkarakter dapat dicocokkan sebagai karakter pelet, atau karakter non-hantu.

String kosong dianggap dapat diterima, oleh karena itu regex dijamin akan cocok pada posisi 0, di mana substring yang paling lama diterima akan dicocokkan.

Substring yang paling lama diterima ini kemudian dicocokkan dengan garis bawah dengan panjang yang sama, diikuti oleh <.