Pac-Man peut-il manger cette corde?


46

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.


29
Donc, les pellets n'ont pas de date d'expiration?
Rɪᴋᴇʀ

Les tabulations de fin sont-elles acceptées dans la sortie?
Katenkyo

7
+1 pour le fait que "ici" est l'endroit où pacman perd. Cas de test intelligent.
Olivier Dulac

5
> [E] n dans ce défi, il a soif de caractères alphanumériques et de ponctuation dans une chaîne. ... Yacc -man?
Kaz

9
Maintenant, je vois un pacman gris camouflé avec des lèvres noires à chaque fois que je regarde le <symbole ...
QBrute

Réponses:


16

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.


5
Je commencerais à m'inquiéter quand vous pourrez le lire couramment :)
quetzalcoatl

30

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.


Bel abus de capturer des groupes!
Leaky Nun

11
@ LeakyNun Abuse? C'est pour cela que les groupes d'équilibrage sont faits. : D
Martin Ender

1
Hé, regardez, une réponse de la rétine qui ressemble à distance à la regex que j'utilise
cat

10

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

Votre fonction revient None, pas la réponse. Et comment comptez-vous 107? Je compte 110.
Stefan Pochmann

@StefanPochmann les doubles-espaces sont des onglets et il est permis d'imprimer la réponse plutôt que de la renvoyer
Bleu

@ Muddyfish Ah, merci. Ils ne semblent pas être des onglets ici, cependant, même quand je vais à "éditer". Et le problème dit clairement "retour" ... existe-t-il des règles applicables à l'ensemble du site qui l'ignorent? (Je suis assez nouvelle ici et je ne sais pas)
Stefan Pochmann

Les onglets @StefanPochmann sont mangés par SE (normalement convertis en 4 espaces). Sauf indication explicite, l'impression dans une fonction est autorisée. Le PO n'a probablement pas eu l'intention de passer outre cela
Bleu

Je pense qu'il est raisonnable de dire qu'il devrait toujours soit revenir si c'est une fonction, soit lire à partir de stdin et imprimer. Je vais passer à la lecture de stdin, qui devrait être plus courte de toute façon.
Arfie

8

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.


8

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

1
Vous pouvez remplacer des types dans variabledeclerations en utilisant le mot-clé var. Par exemple, var temp = '' + input; La boucle for peut être réécrite pour économiser 4 caractères: for (var i = 0; i ++ <s.Length;)
CSharpie

1
Vous pouvez utiliser des virgules pour les déclarations "int i = 0, p = 0; chaîne P =" PELpel ", G =" GHOSghos ", t = '' + x;" et le changement de @CSharpie, faisant de la boucle "pour (; i ++ <s.Length;)". De plus, vous pouvez "Console.Write (s);" directement pour un total de 235 octets.
Nickson

1
Je pense que cela devrait également fonctionner sans elseenregistrer 5 caractères supplémentaires. Et en démarrant la boucle à, i = 1vous devriez pouvoir supprimer le dernier si le code peut être exécuté à chaque fois.
Frozn

1
Vous pouvez vous débarrasser de votre déclaration c et simplement en ligne l’ s[i]accès pour 5 caractères.
JustinM

1
Est-ce la peine d'attribuer P="PELpel"et G="GHOSghos"? Vous ne les utilisez qu'une fois chacun. Est-ce que je manque quelque chose, ou est-ce seulement 4 caractères supplémentaires? Aussi, avez-vous besoin de else? "PELpel".Contains(c)et "GHOSghos".Contains(c)devrait être mutuellement exclusif.
jpmc26

7

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.


17
que seules les personnes connaissant Pyth peuvent comprendre Bien, comme le reste du code, naturellement
Luis Mendo

4
@LuisMendo Pour être juste envers les gens qui ne connaissent pas Pyth, je suis presque certain que la plupart d'entre eux pourraient comprendre que l'intersection d'un jeu avec un autre groupe ayant un membre est équivalente à celle d'un membre du groupe étant le même. ensemble plus large: P
FryAmTheEggman

1
@FryAmTheEggman est donc évidemment !!@un trigraphe pour }, non? : p
CAD97

7

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

7

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.


4

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.


Utilisez Zau lieu de Get changez f!pourf!h
Leaky Nun

@ LeakyNun vient juste de comprendre cela dans un autre onglet aussi. Merci.
PurkkaKoodari

2
Je pense que le tdans "ghost"devrait être enlevé
Leaky Nun

Si nous continuons à jouer au golf avec nos solutions, quelle est la différence entre nos solutions?
Leaky Nun

@ LeakyNun Je ne sais pas lequel de ces éléments est le plus proche, mais ma première tentative m'a permis d'obtenir 43 octets et je ne pense pas avoir besoin d'ajouter une troisième réponse. Peut-être devrions-nous travailler ensemble dans la salle de discussion Pyth?
FryAmTheEggman

4

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

Supprimez d=c:lower()et recherchez également les caractères majuscules
Leaky Nun

and 1or s and 1or s s and s
Leaky Nun

@ LeakyNun n'a pas vu qu'il serait plus court d'écrire toutes les lettres ... Merci. En outre, le deuxième commentaire a mentionné quelque chose que j'ai changé, mais seulement dans le non-golf> _ <
Katenkyo

print(('').rep('_',i)..','..z:sub(i+1))
Leaky Nun

@ LeakyNun Je travaille sur une solution similaire, mais le problème vient du fait que cela ipeut êtrenil
Katenkyo

3

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


1
Enlever x=c.upper()et rechercher les correspondances minuscules
Leaky Nun

Vous pouvez en sauvegarder certaines en écrivant des expressions sur la même ligne, séparées par un, ;plutôt que de les avoir chacune sur sa propre ligne. Vous pouvez également utiliser Python 2, qui vous permet d’utiliser des espaces comme premier niveau d’intention et des onglets comme second.
Denker

n=i=0, pas n=0et i=0. t[i]="_"au lieu de t[i] = "_", la même chose pour t[i] = "<". return''.join(t), supprimez cet espace.
Erik the Outgolfer

@LeakyNun Il y a des majuscules dans les cas de test.
TuxCrafting

@ TùxCräftîñg Non, ils veulent dire "GgHhOoSs"et "PpEeLl".
Erik the Outgolfer

2

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.


Bonne réponse, et bienvenue sur le site! Quelle version de python utilisez-vous? Vous voudrez peut-être préciser cela. De plus, je ne l'ai pas testé, mais vous pourrez peut-être while s[x:]*lsupprimer 4 octets.
DJMcMayhem

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}

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
}

1

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


2
Bienvenue dans Programming Puzzles & Code Golf! Quelques conseils: Il y a beaucoup d'espaces non nécessaires entre les opérateurs. Les supprimer permettrait d’économiser une bonne quantité d’octets. Vous pouvez également utiliser Python 2, qui vous permet d'utiliser des espaces comme premier niveau d'intention et des onglets pour les autres.
Denker

1
Vous pouvez remplacer le premier return "_"*c + "<" + s[c:]par un simple breakcar ce code sera exécuté après la boucle for de toute façon.
Arfie

Essayez-le en ligne! Au fait, j'ai 183 octets. Y a-t-il une nouvelle ligne de fuite que vous avez comptée?
Pavel

1

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)

1
Vous pouvez économiser quelques octets en plaçant tous les gardes sur la même ligne, par exemple n!(c:s)|elem c"blah"=blah|elem c"blah"=blah|0<1=blah.
Daniel Wagner

@Daniel Wagner Bon conseil, merci!
MarLinn

Pouvez-vous ajouter un lien TIO ? Je continue à avoir des erreurs quand j'essaie de le faire fonctionner.
Pavel

1

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

1

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

1
Pac-Man ne perd pas quand c'est censé être.
tildearrow

Bonjour @tildearrow, merci d'avoir revu mon code! Je mettrai à jour mon post.
Tachma

Je pense que cela peut être joué plus au golf. Essayez de supprimer / espaces après les sauts de lignes if()et la suppression des espaces autour !=, ||, =, -et <=. Aussi, ne cin>>inputfonctionne pas au lieu de getline? Vous pouvez aussi vous condenser ;.
NoOneIsHere

@NoOneIsHere, merci pour votre commentaire! En fait, je suis un nouveau venu dans le code-golf, alors je vais essayer de jouer encore plus au code et mettre à jour mon message. Si vous avez un autre conseil utile sur le golf de code, je l'apprécierais vraiment.
Tachma

1
Vous pouvez consulter Conseils pour le golf C / C ++ .
NoOneIsHere

1

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


1
Bienvenue chez PPCG!
FlipTack

0

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


Les drapeaux iirc tels que -p comptent pour un octet chacun.
Pavel

1
@Pavel C'est compliqué. Si l'appel normal sans -pdéjà utilisé -, par exemple perl -e-> perl -pe, alors -est libre. Mais je pense que la perl -eversion est plus longue à cause de la citation, donc je pense que je ne peux pas l'utiliser ici.
hv
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.