Oyunun arcade sürümünde, Pac-Man pac-noktalar yiyor. Ancak, bu mücadelede, bir dizgede alfanümerik karakterler ve noktalama işaretleri için aç.

Göreviniz, Pac-Man'i bir dize besleyen, yiyip yemediğini değerlendiren ve Pac-Man'in içinde bulunduğu yere geri döndüren bir işlev oluşturmaktır.

Pac-Man ( <) karakterleri soldan sağa yiyor, her karakter için bir alt çizgi veya boşluk bırakıyor ve hedefi ilk-1'den son + 1'e kadar olan pozisyonları almak.

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

Bununla birlikte, Pac-Man'in doğal düşmanı olan hayalet, "GHOST" kelimesindeki harflerden biriyle karşılaştığında onu durduracaktır (büyük / küçük harf duyarlı değildir). İşleviniz ghostkarakterle karşılaştığında Pac-Man'ın bulunduğu dizgeyi döndürmelidir :

1. <No!
2. _<o!

Bir hayaleti yenebilecek tek şey bir güç topağıdır. Eğer Pac-Man bir hayalete gelmeden önce "PELLET" (harf büyük / küçük harfe duyarlı değildir) kelimesinde bir harfe ulaşırsa , hayaleti yer ve hareket etmeye devam eder ve o pelet kullanılır. Güç peletleri istiflenebilir (yani ppggher iki hayalette de yenilecektir). T o (olduğu gibi, herhangi bir başka harfi olarak tedavi göz ardı edilebilir, böylece bir karakter, bir hayalet ve pelet olarak her ikisi de mevcut a).

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

Daha açıklığa kavuşturmak için "Pac-Man burada kaybeder" dizisinde aşağıdaki işlemler gerçekleşir:

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

Örnekler

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

Bu kod golf - bayt cinsinden en düşük puan kazanır.

Jöle, 34 33 bayt

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

Çevrimiçi deneyin!

Galiba sonunda Jelly'i anlamaya başladım. Biraz korkutucu geliyor.

Retina , 55 38 bayt

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

Çevrimiçi deneyin! (İlk satır aynı anda birkaç test senaryosunun çalıştırılmasına izin verir.)

açıklama

Asıl sorun, eşsiz bir kapanış parantezine sahip olmayan en uzun öneki bulmaktır. Biz birini kullanabilirsiniz Bunun dışında e, lya pyerine (ve ya g, h, oveya syerine ).

Dolayısıyla, bu çözüm neredeyse dengeleme gruplarının bir ders kitabı örneğidir. Nasıl çalıştıkları hakkında çok fazla ayrıntıya girmeyeceğim, çünkü bu kod temelde dengeleme grupları hakkındaki SO cevabımda okuyabileceğiniz standart örnek ile aynı .

Bu nedenle, programın tamamı tek bir regex ikamesidir. Büyük / iküçük harf duyarlılığını etkinleştirir. Sonra ya bir topağı eşleştirip [elp]derinlik sayacını artırabiliriz (grubun yakalama yığını şeklinde 2) ya da hayalet olmayan bir şeyle eşleştirebiliriz [ghos]ya da bir hayaletle eşleşebiliriz .ve derinlik sayacını yığmadan çıkararak azaltabiliriz 2. Tabii ki, bu prensipte [^ghos]bölüm ile bir pelet veya bölüm ile bir hayalet olmayan eşleştirmeye izin verilir ., ancak açgözlü eşleştirme ve regex'in geri çekilme şekli sayesinde bu olasılıklar asla regex motoru tarafından denenmez.

Daha sonra oyuncu değişikliği Retina'ya özgü iki özellik kullanır: $*karakteri solda belirteçle belirtilen sayıda sağa tekrar eder. Bu simge $.&tüm maçın uzunluğu. Bu sadece maçtaki her karakteri a ile değiştirdiğimiz anlamına gelir _. Ve sonra biz de <bu vurguyu ekleriz. Girişin yenilmeyen kısmı, ikame işleminden etkilenmeden kalır.

Python 2, 114 113 108 bayt

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 bayt

Bazen Python'u işlevsel bir dil haline getirme konusundaki kararlılığımın yararları vardır.

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

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

Özyineleme kullanarak sonuç dizesini oluşturur. l("Yaşamlar" için) güncellemesi, peletler ( True - False == 1) için 1 ekler , hayaletler için (1) çıkarır False - True == -1ve başka bir karakter için 0 ekler. Ayrıca s, Python'un dilimlemesi ve '' in any_str == Truepelet ve hayaleti iptal etmesi sayesinde boş dize olduğunda 0 ekler .

Return ifadesi bir bayt kaydetmek test and b or ayerine kullanır a if test else b. Özyinelemeli temel durum, dize bittiğinde ya da Pac-Man topaklardan bittiğinde, kısaca tam olarak temsil edilen s*p, ''ya s == ''da ya da ne zaman yanlıştır p == 0.

C #, 269 256 232 212 211 Bayt

Buraya ilk mesaj attığınızdan, bu muhtemelen olabileceğinden çok daha uzun (ve muhtemelen C # da olduğu için). Kısaltabileceğim herhangi bir ipucu harika olurdu!

Bana yardımcı olan yorumlarda herkese teşekkür ederiz!

Golf versiyonu

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

Ungolfed versiyonu

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 bayt

@ !!@> }Hile için @ Pietu1998'e 4 byte (sadece Pyth'i bilenlerin anlayabildiği)

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

Test odası.

MATL , 37 36 35 bayt

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

Çevrimiçi deneyin!

açıklama

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 bayt

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

Açıklama: pMevcut pelet sayısını korur. Zaten negatifse, sadece karakteri döndürür ve devam ederiz, böylece dizenin geri kalanına dokunulmaz. Aksi takdirde, şu anki karakteri inceleriz ve eğer bu pnegatif olursa , <karakteri ekleriz, aksi takdirde mevcut karakteri değiştiririz _. Son olarak, pasla negatif olmazsa <, dizgeye a eklenir .

Pyth, 47 46 44 bayt

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

Çevrimiçi deneyin. Test odası.

Leaky Nun'unkinden oldukça farklı bir yaklaşım ve bunun daha fazla golf oynayabileceğinden eminim.

Lua, 198 190 184 185 163 Bayt

Tamam, itiraf ediyorum, bu çok uzun. Çok uzun. Lua, dizelerle oynamak için bazı araçlara sahiptir, ancak sınırlıdır, aynı şey çok fazla alan gerektiren şartlar için de geçerlidir.

Düzenleme: beni 9 bayt kaydetmek için teşekkürler @LeakyNun :) Bir hatayı düzeltmek için bazı bayt kaybetti

Edit 2: 163 Bytes çözümü @LeakyNun tarafından bulundu

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

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

Dizeyi fargüman olarak alan bir fonksiyon tanımlayın

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

Muhtemelen daha çok golf oynayabilir

Yorum yapan herkese teşekkürler: D

Python 3, 114 110 bayt

İlk golf kodum.

Dr Green Eggs ve Iron Man'e 4 byte tasarruf sağladığı için teşekkür ederiz.

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

Mantıksal VE çarpma işlemlerini yoğunlaştırmak için booleanların değerlendirmesini bir veya sıfıra kullanır. (0 * 0 = 0, 1 * 0 = 0, 1 * 1 = 1). Umarım bu iyi bir ilk denemedir.

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}

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 bayt

'S' argümanı bir dizedir.

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

Bu benim ilk kod golf girişimi olduğu gibi herhangi bir golf ipuçları takdir ediyorum

Yorumunuz için teşekkürler :)

Haskell, 119 113 Bayt

Daniel Wagner'e 6 bayt daha az teşekkürler.

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

Olarak adlandır p "Hello World!".

1thenBenim ghc (7.10) doğru yorumlanır, bir kenar olduğu, ancak en sözdizimi highlighters atar. Dolayısıyla derleyicinizde de farklı şekilde yorumlanabilir.

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 bayt

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

(Not: hala 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;
}

Yakut, (119 bayt)

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]

Muhtemelen bu konuda yeniyken kaçırdığım bazı şeyler var ...

Ruby benim arkadaşım :)

Perl, 54 (52 + 2) bayt

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

İhtiyaç -pkomut satırı seçeneklerinde belirtilecek.

Açıklama:

-pSeçenek her döngü yineleme sırasında bir okuma-değiştirme baskı döngüsü, sarılmış olması deyimi neden $_hattı sınırlayıcı içeren girdi bir çizgi içerir.

Regex, Retina cevabındaki ile aynı fikirdir.

Arama modelini ([pel](?1)*[ghos]|[^ghos ])*"kabul edilebilir" olarak adlandırın. Ardından özyinelemeli olarak şu şekilde tanımlanabilir:

Bir dize "kabul edilebilir" ise:

• Bunun PELLETdışında bir karakter T, ardından kabul edilebilir bir dize, ardından GHOSTdışında bir karakterdir T.
• Yeni olmayan bir karakter olması GHOSTdışında T, içinde olmayan bir karakter.
• Kabul edilebilir dizelerin herhangi bir sayısının (0 dahil) bir birleşimidir.

Bu tanım, hayaletlerden daha fazla pelet sağlar: Bir PELkarakter, pelet karakter veya hayalet olmayan bir karakter olarak eşlenebilir.

Boş dizginin kabul edilebilir olduğu kabul edilir, bu nedenle regex'in kabul edilebilir en uzun altlığın eşleşeceği 0 konumunda eşleşmesi garanti edilir.

Bu kabul edilebilir en uzun alt halka daha sonra eşit uzunlukta alt çizgilerle eşleştirilir, ardından takip edilir <.