In der Arcade-Version des Spiels isst Pac-Man Pac-Dots. Bei dieser Herausforderung ist er jedoch hungrig nach alphanumerischen Zeichen und Satzzeichen in einer Zeichenfolge.

Ihre Aufgabe ist es, eine Funktion zu erstellen, die Pac-Man eine Zeichenfolge zuführt, bewertet, ob er sie essen kann oder nicht, und die Zeichenfolge mit der Position von Pac-Man darin zurückgibt.

Pac-Man ( <) frisst die Zeichen von links nach rechts und hinterlässt für jedes Zeichen einen Unterstrich oder ein Leerzeichen. Sein Ziel ist es, von der ersten Position-1 bis zur letzten Position + 1 zu gelangen:

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

Pac-Mans natürlicher Feind, der Geist, wird ihn jedoch stoppen, wenn er auf einen der Buchstaben im Wort "GHOST" stößt (ohne Berücksichtigung der Groß- und Kleinschreibung). Ihre Funktion sollte den String mit Pac-Mans Position zurückgeben, wenn er auf das ghostZeichen stößt :

1. <No!
2. _<o!

Das Einzige, was einen Geist besiegen kann, ist ein Kraftpellet. Wenn Pac-Man einen Buchstaben im Wort "PELLET" erreicht (auch ohne Berücksichtigung der Groß- und Kleinschreibung), bevor er zu einem Geist kommt, wird er den Geist essen und in Bewegung bleiben, und das Pellet wird aufgebraucht. Kraftpellets können sich stapeln (dh in ppggbeiden Geistern würde gegessen). Das T- Zeichen existiert sowohl als Geist als auch als Pellet, so dass es ignoriert werden kann (wie jeder andere Buchstabe auch a).

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

Zur weiteren Verdeutlichung werden in der Zeichenfolge "Pac-Man verliert hier" die folgenden Vorgänge ausgeführt:

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

Beispiele

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

Dies ist Code-Golf - die niedrigste Punktzahl in Bytes gewinnt.

Jelly, 34 33 Bytes

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

Probieren Sie es online!

Ich glaube, ich fange endlich an, Jelly zu verstehen. Fühlt sich ein bisschen unheimlich an.

Retina , 55 38 Bytes

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

Probieren Sie es online! (In der ersten Zeile können nur mehrere Testfälle gleichzeitig ausgeführt werden.)

Erläuterung

Das Problem besteht im Wesentlichen darin, das längste Präfix zu finden, das keine unübertroffene schließende Klammer enthält. Abgesehen davon, dass wir entweder verwenden können e, loder panstelle von (und entweder g, h, ooder sanstelle von ).

Somit ist diese Lösung fast ein Lehrbuchbeispiel für Bilanzkreise. Ich werde nicht zu detailliert darauf eingehen, wie sie funktionieren, da dieser Code im Wesentlichen mit dem Standardbeispiel übereinstimmt, das Sie in meiner SO-Antwort zu Bilanzkreisen nachlesen können .

Das gesamte Programm ist daher eine einzelne Regex-Ersetzung. Das iaktiviert die Groß- und Kleinschreibung. Dann passen wir entweder ein Pellet an [elp]und erhöhen den Tiefenzähler (in Form des Erfassungsstapels der Gruppe 2), oder wir passen etwas an, das kein Geist ist, [ghos]oder wir passen einen Geist an .und dekrementieren den Tiefenzähler, indem wir vom Stapel springen 2. Grundsätzlich ist es damit zwar möglich, ein Pellet mit dem [^ghos]Abschnitt oder ein Nicht-Ghost mit dem .Abschnitt abzugleichen, aber dank des gierigen Abgleichs und der Art und Weise, wie der Regex zurückverfolgt wird, werden diese Möglichkeiten von der Regex-Engine nie ausprobiert.

Die Ersetzung verwendet dann zwei Retina-spezifische Merkmale: $*Wiederholt das Zeichen zu seiner Rechten so oft, wie durch den Token zu seiner Linken angegeben. Dieser Token ist $.&die Länge des gesamten Matches. Dies bedeutet nur, dass wir jedes Zeichen in der Übereinstimmung mit einem ersetzen _. Und dann hängen wir <an diese Unterstriche auch ein an. Der nicht verzehrte Teil der Eingabe bleibt von der Ersetzung einfach unberührt.

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

Manchmal hat meine hartnäckige Entschlossenheit, Python zu einer funktionalen Sprache zu machen, ihre Vorteile.

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

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

Baut die Ergebniszeichenfolge mithilfe von Rekursion auf. Das Update auf l(für "Leben") addiert 1 für Pellets ( True - False == 1), subtrahiert 1 für Geister ( False - True == -1) und addiert 0 für jedes andere Zeichen. Außerdem wird 0 hinzugefügt, wenn sder String leer ist, dank Pythons Aufteilen und der Tatsache '' in any_str == True, dass Pellet und Ghost abbrechen.

In der return-Anweisung wird test and b or aanstelle von a if test else bein Byte gespeichert. Der Grundfall der Rekursion tritt auf, wenn entweder die Zeichenfolge endet oder Pac-Man keine Pellets mehr hat, kurz dargestellt als s*p, was ''entweder s == ''oder gleich ist (und daher falsch ergibt) p == 0.

C #, 269 256 232 212 211 Bytes

Poste zum ersten Mal hier, das ist wahrscheinlich viel länger als es sein könnte (und wahrscheinlich, weil es in C # ist). Irgendwelche Tipps, wo ich es verkürzen könnte, wären toll!

Vielen Dank an alle in den Kommentaren, die mir geholfen haben!

Golf Version

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

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 Bytes

4 Bytes danke an @ Pietu1998 für den !!@-> }Trick (den nur Leute verstehen können, die Pyth kennen)

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

Testsuite.

MATL , 37 36 35 Bytes

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

Probieren Sie es online!

Erläuterung

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)

Erläuterung: pBehält die aktuelle Anzahl der Pellets bei. Wenn es bereits negativ ist, geben wir einfach das Zeichen zurück und fahren fort, so dass der Rest der Zeichenkette unberührt bleibt. Andernfalls untersuchen wir das aktuelle Zeichen, und wenn dies pnegativ wird, fügen wir das <Zeichen ein, andernfalls ersetzen wir das aktuelle Zeichen durch _. Wenn das pErgebnis nie negativ wird, setzen wir ein Suffix <an die Zeichenfolge.

Pyth, 47 46 44 Bytes

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

Probieren Sie es online aus. Testsuite.

Eine ganz andere Herangehensweise als die von Leaky Nun, und ich bin mir ziemlich sicher, dass man hier weiter Golf spielen kann.

Lua, 198 190 184 185 163 Bytes

Ok, ich gebe zu, das ist lang. Sehr lang. Lua hat einige Werkzeuge, um mit Streichern herumzuspielen, aber es ist begrenzt, dasselbe gilt für Bedingungen, die viel Platz beanspruchen.

Edit: danke @LeakyNun für das Speichern von 9 Bytes :) Einige Bytes verloren, um einen Fehler zu beheben

Edit 2: 163 Bytes Lösung gefunden von @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))

Alt 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

Definieren Sie eine Funktion mit dem Namen f, die den String als Argument verwendet

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

Kann wohl mehr golfen werden

Vielen Dank an alle, die kommentiert haben: D

Python 3, 114 110 Bytes

Mein erster Code Golf.

Vielen Dank an Dr. Green Eggs und Iron Man für die Einsparung von 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:])

Verwendet die Auswertung von Booleschen Werten auf eins und null, um ein logisches UND zu einer Multiplikation zu verdichten. (0 * 0 = 0, 1 * 0 = 0, 1 * 1 = 1). Ich hoffe, das ist ein guter erster Versuch.

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

Das Argument 's' ist eine Zeichenfolge

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

Ich würde mich über Golftipps freuen, da dies mein erster Code-Golfversuch ist

Danke für den Kommentar :)

Haskell, 119 113 Bytes

Danke an Daniel Wagner für 6 Bytes weniger.

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

Nennen Sie es als p "Hello World!".

Dies 1thenist ein Randfall, der in meinem GHC (7.10) korrekt interpretiert wird, aber die meisten Syntax-Highlighter auslöst. Es könnte also auch in Ihrem Compiler anders interpretiert werden.

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

(Hinweis: noch Golf spielen)

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

Rubin, (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]

Es gibt wahrscheinlich einige Dinge, die mir fehlen, da ich neu in diesem Bereich bin ...

Ruby ist mein Freund :)

Perl, 54 (52 + 2) Bytes

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

Muss -pin den Befehlszeilenoptionen angegeben werden.

Erläuterung:

Die -pOption bewirkt, dass die Anweisung in eine Lese-Änderungs-Druck-Schleife eingeschlossen wird, in der während jeder Schleifeniteration $_eine Eingabezeile einschließlich des Zeilentrennzeichens enthalten ist.

Der reguläre Ausdruck ist im Wesentlichen derselbe wie in der Retina-Antwort.

Nennen Sie das Suchmuster ([pel](?1)*[ghos]|[^ghos ])*"akzeptabel". Dann kann es rekursiv definiert werden als:

Eine Zeichenfolge ist "akzeptabel", wenn:

• Es ist ein Zeichen in PELLETexcept for T, gefolgt von einer akzeptablen Zeichenfolge, gefolgt von einem Zeichen in GHOSTexcept for T.
• Es ist ein Zeichen, das nicht enthalten ist, mit der GHOSTAusnahme, Tdass es sich nicht um ein Newline-Zeichen handelt.
• Es ist eine Verkettung einer beliebigen Anzahl (einschließlich 0) zulässiger Zeichenfolgen.

Diese Definition erlaubt mehr Pellets als Geister: Ein PELZeichen kann entweder als Pellet-Zeichen oder als Nicht-Geister-Zeichen abgeglichen werden.

Die leere Zeichenfolge wird als akzeptabel angesehen, daher wird garantiert, dass die Regex an Position 0 übereinstimmt, an der die längste akzeptable Teilzeichenfolge übereinstimmt.

Diese längste akzeptable Teilzeichenfolge wird dann von gleich langen Unterstrichen gefolgt <.