Na versão arcade do jogo, Pac-Man come pac-dots. No entanto, neste desafio, ele tem fome de caracteres alfanuméricos e pontuação em uma sequência.

Sua tarefa é criar uma função que alimente uma sequência de caracteres do Pac-Man, avalie se ele pode ou não comê-la e retorne a sequência com a localização do Pac-Man.

Pac-Man ( <) come caracteres da esquerda para a direita, deixando um sublinhado ou espaço para cada personagem à medida que avança, e seu objetivo é ir da primeira posição-1 à última posição + 1:

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

No entanto, o inimigo natural do Pac-Man, o fantasma, irá detê-lo se ele encontrar uma das letras da palavra "FANTASMA" (não diferencia maiúsculas de minúsculas). Sua função deve retornar a string com a localização do Pac-Man quando ele encontrar o ghostpersonagem:

1. <No!
2. _<o!

A única coisa que pode derrotar um fantasma é um pellet de poder. Se o Pac-Man alcançar uma letra com a palavra "PELLET" (também não diferencia maiúsculas de minúsculas) antes de chegar a um fantasma, ele o comerá e continuará se movendo, e esse pellet será usado. Grânulos de poder podem empilhar (ou seja, em ppggambos os fantasmas seriam comidos). O caractere T existe como um fantasma e um pellet, para que possa ser ignorado (tratado como qualquer outra letra, como a).

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

Para esclarecer, na sequência "Pac-Man perde aqui", ocorrem as seguintes operações:

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

Exemplos

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

Isso é código-golfe - a menor pontuação em bytes ganha.

Geléia, 34 33 bytes

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

Experimente online!

Acho que finalmente estou começando a entender Jelly. Parece um pouco assustador.

Retina , 55 38 bytes

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

Experimente online! (A primeira linha apenas permite executar vários casos de teste ao mesmo tempo.)

Explicação

O problema é essencialmente encontrar o prefixo mais longo que não tem um parêntese de fechamento incomparável. Exceto que podemos usar e, lou pno lugar de (e ou g, h, oou sno lugar de ).

Portanto, essa solução é quase um exemplo de grupo de balanceamento. Não entrarei em muitos detalhes sobre como eles funcionam, pois esse código é essencialmente o mesmo que o exemplo padrão que você pode ler na minha resposta SO sobre grupos de balanceamento .

O programa inteiro é, portanto, uma única substituição de regex. A iativa caso insensibilidade. Em seguida, combinamos um pellet [elp]e incrementamos o contador de profundidade (na forma da pilha de captura de grupo 2), ou combinamos com algo que não é um fantasma [ghos]ou com um fantasma .e diminuímos o contador de profundidade ao sair da pilha 2. Obviamente, em princípio, isso permite combinar um pellet com a [^ghos]seção ou um não-fantasma com a .seção, mas, graças à correspondência gananciosa e à maneira como a regex é retornada, essas possibilidades nunca são tentadas pelo mecanismo de regex.

A substituição usa dois recursos específicos da Retina: $*repete o caractere à sua direita quantas vezes for especificado pelo token à sua esquerda. Esse token é $.&a duração de toda a partida. Isso significa apenas que substituímos cada personagem da partida por a _. E também anexamos a <a esses sublinhados. A parte da entrada que não é consumida simplesmente não é afetada pela substituição.

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 bytes

Às vezes, minha determinação obstinada de tornar o Python uma linguagem funcional tem seus benefícios.

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

(Levemente) não destruído:

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

Constrói a sequência de resultados usando recursão. A atualização para l(para "vidas") adiciona 1 para pellets ( True - False == 1), subtrai 1 para fantasmas ( False - True == -1) e adiciona 0 para qualquer outro caractere. Ele também adiciona 0 quando sa string vazia, graças ao fatiamento do Python e ao fato de que '' in any_str == True, portanto, o pellet e o ghost são cancelados.

A declaração de retorno usa test and b or ano lugar de a if test else bpara salvar um byte. O caso da base de recursão ocorre quando a corda termina ou o Pac-Man fica sem pellets, representado sucintamente como s*p, o que é igual ''(e, portanto, avalia falso) quando é s == ''ou p == 0.

C #, 269 256 232 212 211 Bytes

Primeiro post aqui, então isso provavelmente é muito mais longo do que poderia ser (e provavelmente porque está em C #). Qualquer dica sobre onde eu poderia encurtar seria ótimo!

Obrigado a todos nos comentários que me ajudaram!

Versão 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);}

Versão ungolfed

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

Pitão, 53 48 44 bytes

4 bytes graças a @ Pietu1998 pelo truque !!@-> }(que somente pessoas que conhecem Pyth podem entender)

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

Suíte de teste.

MATL , 37 36 35 bytes

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

Experimente online!

Explicação

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 bytes

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

Explicação: pmantém o número atual de pelotas. Se já é negativo, retornamos o caractere e seguimos em frente, para que o restante da string seja intocado. Caso contrário, examinamos o caractere atual e, se isso se ptornar negativo, inserimos o <caractere, caso contrário, substituímos o caractere atual por _. Por fim, se pnunca se tornar negativo, temos o sufixo <a na string.

Pitão, 47 46 44 bytes

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

Experimente online. Suíte de teste.

Uma abordagem bem diferente da da Leaky Nun's, e tenho certeza de que isso pode ser ainda mais importante.

Lua, 198 190 184 185 185 163 Bytes

Ok, eu admito, isso é longo. Muito longo. Lua tem algumas ferramentas para brincar com strings, mas é limitado, o mesmo vale para condicionais que ocupam muitos espaços.

Edit: obrigado @LeakyNun por me salvar 9 bytes :) Perdi alguns bytes para corrigir um erro

Edit 2: 163 Bytes solution found by @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))

Antigo 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 bytes

Defina uma função nomeada fque aceita a string como argumento

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

Provavelmente pode ser jogado mais

Obrigado a todos que comentaram: D

Python 3, 114 110 bytes

Meu primeiro código de golfe.

Agradecimentos ao Dr. Green Eggs e Iron Man por salvar 4 bytes.

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

Utiliza a avaliação de booleanos para um e zero para condensar um AND lógico a uma multiplicação. (0 * 0 = 0, 1 * 0 = 0, 1 * 1 = 1). Espero que seja uma boa primeira tentativa.

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 bytes

O argumento 's' é uma 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:]

Gostaria muito de receber algumas dicas de golfe, pois esta é minha primeira tentativa de golfe com código

Obrigado por comentar :)

Haskell, 119 113 bytes

Obrigado a Daniel Wagner por 6 bytes a menos.

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

Chame como p "Hello World!".

O 1thené um caso extremo que é interpretado corretamente no meu GHC (7,10), mas ele lança da maioria dos marcadores de sintaxe. Portanto, também pode ser interpretado de forma diferente no seu compilador.

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 bytes

#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

(Nota: ainda jogando golfe)

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

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]

Provavelmente há algumas coisas que estou perdendo, pois sou novo nisso ...

Ruby é meu amigo :)

Perl, 54 (52 + 2) bytes

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

Precisa -pser especificado nas opções da linha de comandos.

Explicação:

A -popção faz com que a instrução seja quebrada em um loop de leitura-modificação-impressão, onde durante cada iteração do loop, $_contém uma linha de entrada, incluindo o delimitador de linha.

O regex é basicamente a mesma idéia da resposta da Retina.

Chame o padrão de pesquisa ([pel](?1)*[ghos]|[^ghos ])*"aceitável". Em seguida, pode ser definido recursivamente como:

Uma string é "aceitável" se:

• É um caractere em PELLETexceto por T, seguido por uma sequência aceitável, seguido por um caractere em GHOSTexceto por T.
• É um caractere que não está, GHOSTexceto Tque não é um caractere de nova linha.
• É uma concatenação de qualquer número (incluindo 0) de cadeias aceitáveis.

Essa definição permite mais pellets do que fantasmas: um PELcaractere pode ser correspondido como um caractere de pellet ou um caractere não fantasma.

A cadeia vazia é considerada aceitável; portanto, é garantido que o regex corresponde à posição 0, onde a substring aceitável mais longa será correspondida.

Essa substring aceitável mais longa é correspondida por sublinhados de comprimento igual, seguidos por <.