Dans la version arcade du jeu, Pac-Man mange des pac-dots. Cependant, dans ce défi, il a soif de caractères alphanumériques et de ponctuation dans une chaîne.

Votre tâche consiste à créer une fonction qui alimente une chaîne avec Pac-Man, évalue s’il peut la manger ou non, et renvoie la chaîne contenant la localisation de Pac-Man.

Pac-Man ( <) mange les personnages de gauche à droite, en laissant un trait de soulignement ou un espace pour chaque personnage au fur et à mesure de son passage, et son objectif est de passer de la première position à la dernière position + 1:

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

Cependant, l'ennemi naturel de Pac-Man, le fantôme, l'arrêtera s'il rencontre l'une des lettres du mot "GHOST" (non sensible à la casse). Votre fonction devrait renvoyer la chaîne contenant l'emplacement de Pac-Man lorsqu'il rencontre le ghostpersonnage:

1. <No!
2. _<o!

La seule chose qui peut vaincre un fantôme est une pastille de pouvoir. Si Pac-Man parvient à une lettre contenant le mot "PELLET" (sans tenir compte de la casse) avant d' arriver à un fantôme, il mangera le fantôme et continuera à avancer, et ce pellet sera utilisé. Les granules de pouvoir peuvent empiler (c.-à-d., Les ppggfantômes seraient mangés) Le caractère T existe à la fois comme un fantôme et une pastille, de sorte qu'il peut être ignoré (traité comme toute autre lettre, comme a).

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

Pour clarifier davantage, dans la chaîne "Pac-Man perd ici", les opérations suivantes ont lieu:

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

Exemples

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

Ceci est code-golf - le score le plus bas en octets gagne.

Gelée, 34 33 octets

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

Essayez-le en ligne!

Je pense que je commence enfin à comprendre Jelly. Se sent un peu effrayant.

Retina , 55 38 octets

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

Essayez-le en ligne! (La première ligne permet simplement d'exécuter plusieurs cas de test à la fois.)

Explication

Le problème est essentiellement de trouver le préfixe le plus long qui n’ait pas de parenthèse fermante sans correspondance. Sauf que nous pouvons utiliser soit e, lou pà la place (et soit g, h, oou sà la place de ).

Par conséquent, cette solution est presque un exemple classique d'équilibrage de groupes. Je n’entrerai pas dans les détails sur leur fonctionnement, car ce code est essentiellement le même que l’exemple standard que vous pouvez lire dans ma réponse au SO sur l’équilibrage des groupes .

L'ensemble du programme est donc une substitution de regex unique. Le iactive insensibilité à la casse. Ensuite, nous apparions une pastille [elp]et incrémentons le compteur de profondeur (sous la forme de la pile de capture du groupe 2), ou nous associons quelque chose qui n'est pas un fantôme [ghos]ou nous associons un fantôme avec .et décrémentons le compteur de profondeur en sautant de la pile. 2. Bien sûr, cela permet en principe de faire correspondre une pastille avec la [^ghos]section ou un non-fantôme avec la .section, mais grâce à la correspondance gourmande et au retour en arrière de la regex, ces possibilités ne sont jamais tentées par le moteur de regex.

La substitution utilise ensuite deux fonctionnalités spécifiques à Retina: $*répète le caractère à sa droite autant de fois que spécifié par le jeton à sa gauche. Ce jeton est $.&la longueur de la partie entière. Cela signifie simplement que nous remplaçons chaque caractère du match par un _. Et puis nous ajoutons aussi un a <à ces traits de soulignement. La partie de l'entrée qui n'est pas consommée reste simplement non affectée par la substitution.

Python 2, 114 113 108 octets

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 octets

Parfois, ma détermination obstinée à faire de Python un langage fonctionnel a ses avantages.

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égèrement) 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)

Construit la chaîne de résultat en utilisant la récursivité. La mise à jour de l(pour "vies") ajoute 1 pour pellets ( True - False == 1), soustrait 1 pour fantômes ( False - True == -1) et ajoute 0 pour tout autre personnage. Il ajoute également 0 quand sest la chaîne vide, grâce au découpage en Python et au fait que '' in any_str == True, de sorte que la pastille et le fantôme s'annulent.

La déclaration return utilise test and b or aà la place de a if test else bpour sauvegarder un octet. Le cas de base de la récursivité se produit lorsque la chaîne se termine ou que Pac-Man manque de pastilles, représentées succinctement par s*pce qui est égal à ''(et donc égal à faux) lorsque s == ''ou p == 0.

C #, 269 256 232 212 211 octets

Tout premier message ici, c'est probablement beaucoup plus long que prévu (et probablement parce qu'il est en C #). Des conseils sur où je pourrais raccourcir ce serait génial!

Merci à tout le monde dans les commentaires qui m'a aidé!

Version golfée

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

Version non-golfée

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 octets

4 octets grâce à @ Pietu1998 pour le !!@-> }trick (dont seuls les gens qui savent Pyth peut comprendre)

++ * 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 de tests.

MATL , 37 36 35 octets

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

Essayez-le en ligne!

Explication

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 octets

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

Explication: pconserve le nombre actuel de pellets. Si c'est déjà négatif, nous retournons simplement le personnage et passons à autre chose, afin que le reste de la chaîne ne soit pas touché. Sinon, nous examinons le caractère actuel et si cela pdevient négatif, nous insérons le <caractère, sinon nous remplaçons le caractère actuel par _. Enfin, si pjamais devient négatif, nous ajoutons un suffixe a <à la chaîne.

Pyth, 47 46 44 octets

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

Essayez-le en ligne. Suite de tests.

Une approche très différente de celle de Leaky Nun, et je suis tout à fait sûr que cela peut être joué plus loin.

Lua, 198 190 184 185 163 Octets

Ok, je l'avoue, c'est long. Très long. Lua a quelques outils pour jouer avec les chaînes, mais il est limité, il en va de même pour les conditionnelles qui prennent beaucoup d'espace.

Edit: merci @ LeakyNun pour m'avoir sauvé 9 octets :) Perdu quelques octets pour corriger un bogue

Edit 2: solution de 163 octets trouvée par @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))

Vieux 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 octets

Définir une fonction nommée fqui prend la chaîne en argument

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

Peut être probablement joué au golf plus

Merci à tous ceux qui ont commenté: D

Python 3, 114 110 octets

Mon premier code golf.

Merci au Dr Green Eggs et à Iron Man d’avoir économisé 4 octets.

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

Utilise l'évaluation des booléens à un et zéro pour condenser un ET logique en une multiplication. (0 * 0 = 0, 1 * 0 = 0, 1 * 1 = 1). J'espère que c'est un bon premier essai.

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 octets

L'argument 's' est une chaîne

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

J'apprécierais tous les conseils de golf car c'est ma première tentative de code de golf

Merci d'avoir commenté :)

Haskell, 119 113 octets

Merci à Daniel Wagner pour 6 octets de moins.

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

Appelez ça comme p "Hello World!".

Le 1thenest un cas de bord qui est interprété correctement dans mon GHC (7.10), mais il jette la plupart des surligneurs de syntaxe. Cela pourrait donc aussi être interprété différemment dans votre compilateur.

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 octets

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

(Note: toujours en train de jouer)

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

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]

Il y a probablement des choses qui me manquent car je suis novice dans ce domaine ...

Ruby est mon amie :)

Perl, 54 (52 + 2) octets

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

Doit -pêtre spécifié dans les options de ligne de commande.

Explication:

L' -poption entraîne l'enveloppe de l'instruction dans une boucle lecture-modification-impression, où, lors de chaque itération de la boucle, $_contient une ligne d'entrée, y compris le délimiteur de ligne.

La regex est en grande partie la même idée que dans la réponse de la rétine.

Appelez le motif de recherche ([pel](?1)*[ghos]|[^ghos ])*"acceptable". Ensuite, il peut être défini de manière récursive comme:

Une chaîne est "acceptable" si:

• C'est un caractère à l' PELLETexception de T, suivi d'une chaîne acceptable, suivi d'un caractère à l' GHOSTexception de T.
• Ce n'est pas un caractère GHOSTsauf que Tce n'est pas un caractère de nouvelle ligne.
• C'est une concaténation d'un nombre quelconque (y compris 0) de chaînes acceptables.

Cette définition autorise plus de pastilles que de fantômes: un PELpersonnage peut être comparé en tant que personnage de pastille ou non fantôme.

La chaîne vide est considérée comme acceptable. Par conséquent, il est garanti que la regex correspond à la position 0, où la sous-chaîne acceptable la plus longue sera recherchée.

Cette sous-chaîne acceptable la plus longue est ensuite comparée à des traits de soulignement de longueur égale, suivis de <.