Nella versione arcade del gioco, Pac-Man mangia punti di pace. Tuttavia, in questa sfida, ha fame di caratteri alfanumerici e punteggiatura in una stringa.

Il tuo compito è quello di creare una funzione che alimenta Pac-Man una stringa, valuta se può mangiarla o meno e restituisce la stringa con la posizione di Pac-Man in essa.

Pac-Man ( <) mangia personaggi da sinistra a destra, lasciando un carattere di sottolineatura o spazio per ogni personaggio mentre procede, e il suo obiettivo è quello di ottenere dalla prima posizione-1 all'ultima posizione + 1:

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

Tuttavia, il nemico naturale di Pac-Man, il fantasma, lo fermerà se incontra una delle lettere nella parola "GHOST" (senza distinzione tra maiuscole e minuscole). La tua funzione dovrebbe restituire la stringa con la posizione di Pac-Man mentre incontra il ghostpersonaggio:

1. <No!
2. _<o!

L'unica cosa che può sconfiggere un fantasma è un granello di potere. Se Pac-Man raggiunge una lettera con la parola "PELLET" (anche senza distinzione tra maiuscole e minuscole) prima di arrivare a un fantasma, mangerà il fantasma e continuerà a muoversi e quel pellet verrà consumato. I granuli di potere possono accumularsi (cioè, in ppggentrambi i fantasmi verrebbero mangiati). Il personaggio T esiste sia come un fantasma che come una pallina, quindi può essere ignorato (trattato come qualsiasi altra lettera, come a).

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

Per chiarire ulteriormente, nella stringa "Pac-Man perde qui", si verificano le seguenti operazioni:

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

Esempi

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

Questo è code-golf - vince il punteggio più basso in byte.

Gelatina, 34 33 byte

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

Provalo online!

Penso che finalmente sto iniziando a capire Jelly. Sembra un po 'spaventoso.

Retina , 55 38 byte

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

Provalo online! (La prima riga consente di eseguire diversi casi di test contemporaneamente).

Spiegazione

Il problema è essenzialmente quello di trovare il prefisso più lungo che non ha una parentesi di chiusura senza eguali. Se non fosse che siamo in grado di utilizzare sia e, lo pal posto di (eo g, h, oo sal posto di ).

Quindi, questa soluzione è quasi un esempio da manuale di gruppi di bilanciamento. Non entrerò in troppi dettagli su come funzionano, poiché questo codice è essenzialmente lo stesso dell'esempio standard che puoi leggere nella mia risposta SO sui gruppi di bilanciamento .

L'intero programma è quindi una singola sostituzione regex. Il iattiva caso-insensibilità. Quindi abbiniamo un pellet [elp]e incrementiamo il contatore di profondità (nella forma dello stack di acquisizione del gruppo 2), oppure abbiniamo qualcosa che non è un fantasma [ghos]o abbiniamo un fantasma con .e diminuiamo il contatore di profondità saltando dallo stack 2. Naturalmente, in linea di principio ciò consente di abbinare un pellet alla [^ghos]sezione o un non-fantasma con la .sezione, ma grazie alla corrispondenza avida e al modo in cui il regex viene spostato indietro, queste possibilità non vengono mai tentate dal motore regex.

La sostituzione utilizza quindi due funzioni specifiche di Retina: $*ripete il personaggio alla sua destra tutte le volte specificato dal token alla sua sinistra. Quel token è $.&la lunghezza dell'intera partita. Questo significa solo che sostituiamo ogni personaggio della partita con a _. E poi aggiungiamo anche un carattere <di sottolineatura. La parte dell'input che non viene mangiata rimane semplicemente inalterata dalla sostituzione.

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

A volte la mia ostinata determinazione nel rendere Python un linguaggio funzionale ha i suoi vantaggi.

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

(Leggermente) non golfato:

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

Crea la stringa del risultato usando la ricorsione. L'aggiornamento a l(per "vite") aggiunge 1 per pellet ( True - False == 1), sottrae 1 per ghosts ( False - True == -1) e aggiunge 0 per qualsiasi altro personaggio. Aggiunge anche 0 quando sè la stringa vuota, grazie all'affettamento di Python e al fatto che '' in any_str == True, quindi il pellet e il fantasma si annullano.

L'istruzione return viene utilizzata test and b or aal posto di a if test else bper salvare un byte. Il caso base di ricorsione si verifica quando la stringa termina o Pac-Man esaurisce il pellet, rappresentato in modo succinto come s*p, che equivale ''(e quindi viene valutato falso) quando uno s == ''o p == 0.

C #, 269 256 232 212 211 byte

Prima post qui, quindi probabilmente è molto più lungo di quanto potrebbe essere (e probabilmente perché è in C #). Qualche consiglio su dove potrei accorciare sarebbe fantastico!

Grazie a tutti nei commenti che mi hanno aiutato!

Versione golfizzata

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

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

Pyth, 53 48 44 byte

4 byte grazie a @ Pietu1998 per il trucco !!@-> }(che solo le persone che conoscono Pyth possono capire)

++ * 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 di test.

MATL , 37 36 35 byte

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

Provalo online!

Spiegazione

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)

Spiegazione: pmantiene il numero attuale di pellet. Se è già negativo, restituiamo semplicemente il personaggio e andiamo avanti, in modo che il resto della stringa non sia toccato. Altrimenti, esaminiamo il carattere corrente e, se ciò pdiventa negativo, inseriamo il <carattere, altrimenti sostituiamo il carattere corrente con _. Infine, se pnon diventa mai negativo, aggiungiamo <a alla stringa.

Pyth, 47 46 44 byte

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

Provalo online. Suite di test.

Un approccio completamente diverso da quello di Leaky Nun, e sono abbastanza sicuro che questo possa essere ulteriormente approfondito.

Lua, 198 190 184 185 163 byte

Ok, lo ammetto, questo è lungo. Molto lungo. Lua ha alcuni strumenti per giocare con le stringhe, ma è limitato, lo stesso vale per i condizionali che occupano molti spazi.

Modifica: grazie @LeakyNun per avermi salvato 9 byte :) Ho perso alcuni byte per correggere un bug

Modifica 2: soluzione di 163 byte trovata da @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))

Vecchio 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 byte

Definire una funzione denominata fche accetta la stringa come argomento

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

Probabilmente si può giocare a golf di più

Grazie a tutti coloro che hanno commentato: D

Python 3, 114 110 byte

Il mio primo codice golf.

Grazie a Dr Green Eggs e Iron Man per aver salvato 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:])

Utilizza la valutazione di booleani a uno e zero per condensare un AND logico in una moltiplicazione. (0 * 0 = 0, 1 * 0 = 0, 1 * 1 = 1). Spero sia un buon primo tentativo.

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 byte

L'argomento 's' è una stringa

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

Gradirei qualsiasi consiglio sul golf in quanto questo è il mio primo tentativo di golf con codice

Grazie per aver commentato :)

Haskell, 119 113 byte

Grazie a Daniel Wagner per 6 byte in meno.

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

Chiamalo come p "Hello World!".

Il 1thenè un caso limite che viene interpretata correttamente nel mio GHC (7,10), ma la maggior parte tiri di evidenziatori di sintassi. Quindi potrebbe essere interpretato diversamente anche nel tuo compilatore.

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

(Nota: ancora giocare a 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]

Probabilmente ci sono alcune cose che mi mancano perché sono nuovo in questo ...

Ruby è mio amico :)

Perl, 54 (52 + 2) byte

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

Deve -pessere specificato nelle opzioni della riga di comando.

Spiegazione:

L' -popzione fa sì che l'istruzione sia racchiusa in un ciclo di lettura-modifica-stampa, dove durante ogni iterazione di ciclo, $_contiene una riga di input, incluso il delimitatore di riga.

La regex è in gran parte la stessa idea della risposta Retina.

Chiamare il modello di ricerca ([pel](?1)*[ghos]|[^ghos ])*"accettabile". Quindi può essere definito ricorsivamente come:

Una stringa è "accettabile" se:

• È un carattere in ad PELLETeccezione di T, seguito da una stringa accettabile, seguito da un carattere in ad GHOSTeccezione di T.
• È un personaggio non presente GHOSTtranne Tche non è un personaggio newline.
• È una concatenazione di qualsiasi numero (incluso 0) di stringhe accettabili.

Questa definizione consente più palline che fantasmi: un PELpersonaggio può essere abbinato sia come personaggio a pellet, sia come personaggio non fantasma.

La stringa vuota è considerata accettabile, pertanto si garantisce che regex corrisponderà alla posizione 0, dove verrà adattata la sottostringa più lunga accettabile.

Questa sottostringa più lunga accettabile viene quindi abbinata a trattini bassi di uguale lunghezza, seguiti da <.