У аркадній версії гри Pac-Man їсть pac-крапки. Однак у цьому виклику він прагне буквено-цифрових символів та пунктуації в рядку.

Ваше завдання - створити функцію, яка подає 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на місці ).

Отже, це рішення є майже підручниковим прикладом балансування груп. Я не буду надто детально розповідати про те, як вони працюють, оскільки цей код по суті той самий, що і стандартний приклад, про який ви можете прочитати в моїй відповіді "SO" про балансуючі групи .

Отже, вся програма є однією заміною регулярних виразів. iАктивує прецедентне нечутливість. Тоді ми або узгоджуємо гранулу із [elp]збільшенням лічильника глибини (у формі стека захоплення групи 2), або ми узгоджуємо щось, що не є привидом, [ghos]або ми співставляємо привид з .та зменшуємо лічильник глибини, вискакуючи зі стека 2. Звичайно, в принципі це дозволяє зіставити гранулу з [^ghos]секцією або не-привид з .секцією, але завдяки жадібному зіставленню та способу зворотного відтворення регексу, ці можливості ніколи не намагаються використовувати двигун регулярного виведення.

Потім підстановка використовує дві особливості Retina: $*повторює символ праворуч стільки разів, скільки визначено лексемою зліва. Цей жетон - $.&це довжина всього матчу. Це просто означає, що ми замінюємо кожного символу в матчі на "a" _. І тоді ми також додаємо <до цих підкреслень. Частина введення, яку не їдять, просто не впливає на заміну.

Python 2, 114 113 108 байт

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

(Злегка) невольф:

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 #). Будь-які поради щодо того, де я могла би скоротити це було б чудово!

Дякую всім за коментарі, які мені допомогли!

Гольф-версія

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ніколи не стає негативним, ми суфікс a <до рядка.

Pyth, 47 46 44 байт

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

Спробуйте в Інтернеті. Тестовий набір.

Зовсім інший підхід від Leaky Nun's, і я цілком впевнений, що це можна пограти в гольф далі.

Луа, 198 190 184 185 163 байт

Гаразд, зізнаюся, це довго. Дуже довго. У Lua є кілька інструментів для гри зі струнами, але вона обмежена, це стосується і умовних умов, які займають багато місця.

Редагувати: дякую @LeakyNun за те, що врятував мені 9 байт :) Втратив кілька байтів, щоб виправити помилку

Редагувати 2: 163 байт рішення, знайдене @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)))

Безумовно

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

Пітон 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 байт

Мій перший гольф-код.

Завдяки д-р Зелені яйця та Залізна людина за збереження 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). Я сподіваюся, що це хороша перша спроба.

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}

Безголівки:

("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 байт

Завдяки Даніелю Вагнеру на 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), але він кидає більшість підсвічувачів синтаксису. Тож це може трактуватися і по-різному у вашому компіляторі.

Безголівки:

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]

Напевно, є деякі речі, яких мені не вистачає, коли я новачок у цьому ...

Рубі - мій друг :)

Perl, 54 (52 + 2) байт

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

Необхідно -pвказати в параметрах командного рядка.

Пояснення:

Цей -pпараметр призводить до того, що оператор загортається у цикл читання-модифікація-друк, де під час кожної ітерації циклу $_міститься рядок введення, включаючи роздільник рядка.

Зворотній вираз є значною мірою тією ж ідеєю, що і у відповіді Ретина.

Назвіть шаблон пошуку ([pel](?1)*[ghos]|[^ghos ])*"прийнятним". Тоді це може бути рекурсивно визначено як:

Рядок є "прийнятним", якщо:

• Це символ, за PELLETвинятком T, за ним - прийнятна рядок, а потім - символ у, GHOSTкрім T.
• Це не символ, за GHOSTвинятком того, Tщо це не символ нового рядка.
• Це об'єднання будь-якого числа (включаючи 0) прийнятних рядків.

Це визначення дозволяє отримати більше гранул, ніж привидів: PELперсонаж може відповідати або символу гранул, або символу, що не привид.

Порожній рядок вважається прийнятним, тому гарантується, що регулярний вираз буде відповідати в позиції 0, де буде узгоджена найдовша прийнятна підрядка.

Потім ця довга прийнятна підрядок узгоджується з підкресленнями однакової довжини, за якими слід <.