Préambule

Dans la démarque Stack Exchange, nous utilisons ** pour mettre le texte en gras. Par exemple, cette démarque:

The **quick brown fox jumps over the lazy** dog.

Rend comme:

Le renard brun rapide saute par-dessus le chien paresseux .

Bien sûr, nous utilisons également ** pour fermer l'audace. Donc, moins de réponses seront en gras. Par exemple:

The **quick** brown fox jumps over the **lazy** dog.

Rend comme:

Le renard brun rapide saute par-dessus le chien paresseux .

Cependant, si l'audace n'est pas fermée, elle s'affiche comme non audacieuse :

The **quick brown fox jumps over the lazy dog.

Rend comme:

Le renard brun rapide ** saute par-dessus le chien paresseux.

Si le texte a une seule barre oblique inverse \, la gras ne prend pas effet non plus:

The \**quick brown fox jumps over the lazy dog.**

Rend comme:

Le ** renard brun rapide saute par-dessus le chien paresseux. **

La fin de l'espace blanc entraîne un texte en gras (notez que l'espace blanc après le brun est un onglet unique):

The** quick** brown fox jumps over the lazy dog.**

Rend comme:

Le renard brun ** rapide ** saute par-dessus le chien paresseux. **

Nous pouvons également utiliser __ pour gras, mais notez qu'un seul peut être actif à la fois. Voici un exemple plus compliqué:

The __quick**__ brown **fox__ jumps** over__ the__ lazy **dog.

Rend comme:

Le renard brun rapide ** saute par- dessus le chien paresseux **.

La question:

Vous pouvez écrire un programme ou une fonction, texte ASCII donné soit comme Stringargument ou sur STDIN, où les seuls caractères spéciaux sont **, __, \(pour échapper) et les espaces de fin, déterminer le nombre de caractères gras , il y a. Cette valeur doit être imprimée dans STDOUT ou renvoyée par votre fonction. Vous n'avez pas besoin de prendre en charge de très longues chaînes; La longueur de chaîne est garantie de ne pas dépasser 30K, ce qui est la limite pour une publication Stack Exchange.

Petits caractères:

• Puis-je lever une exception / autre erreur pour un cas et revenir normalement pour l'autre?
  • Non. Il doit s'agir d'une valeur de retour claire, non ambiguë et non erronée pour les deux cas. La sortie STDERR sera ignorée.
• Les espaces entre les mots sont-ils considérés comme gras?
  • Oui. **quick brown**contient 11 caractères en gras.
• Le \in \**, s'il est en gras, doit-il être compté?
  • Non. Il s'affiche comme **, donc s'il doit être en gras, il ne comportera que 2 caractères.
• Soyez tout à fait clair: que voulez-vous dire par combien de personnages?
  • Nombre total de caractères à rendre en gras. Cela signifie que ce **n'est pas rendu s'il transforme du texte, mais il est rendu s'il ne le fait pas.
  • Notez qu'il est possible de faire **être mis en gras de plusieurs manières, par exemple **\****-> ** .
  • Ne considérez pas la possibilité que du texte puisse être converti en italique. La seule règle de démarque à considérer est ** = gras *.
• Sur Stack Exchange, HTML Bold fonctionne également. c'est-à-dire <b> </b>
  • Oui, je suis au courant. Ne considérez pas ce cas, c'est du texte normal.
• Qu'en est-il du HTML entite? par exemple <-><
  • Ceux-ci doivent également être considérés comme du texte normal, il n'y a pas de conversion d'entité HTML.
• J'ai pensé à un exemple que vous n'avez pas couvert ci-dessus!
  • Les règles fonctionnent exactement comme si le texte était publié sur Stack Exchange, dans une réponse (pas un commentaire), sauf que les blocs de code ne sont pas considérés comme des caractères spéciaux . Le type quatre espaces et le type backtick. Si vous n'êtes pas sûr de la façon dont le texte doit être rendu, jetez-le simplement dans une boîte de réponse quelque part comme test, ce sont les règles que vous devez suivre.

Exemples:

Contribution:

The **quick brown fox jumps over the lazy** dog.

Production:

35

Contribution:

The **quick brown fox jumps over the lazy dog.

Production:

0

Contribution:

The __quick**__ brown **fox__ jumps** over__ the__ lazy **dog.

Production:

18

Contribution:

The __quick\____ brown fox **jumps over\** the** lazy \**dog.

Production:

23

Contribution:

The****quick brown fox****jumps over **the****lazy** dog.

Production:

11

Les échappatoires standard sont interdites.

rs , 107 octets

\t/ 
(?<!\\)((\*|_){2})((?=\S)(?!\2)(\\\2|.)*?)?(?<=\S)\1/(\n)^^((^^\3))\3
\\(\*|_)/\t
[^\t\n]/
\n/_
\t_?/
(_*)/(^^\1)

Démonstration en direct et cas de test.

C'est une chose assez folle ...

Le cas de test le plus récent ne fonctionne pas encore. WIP ...

Explication

\t/ 

Remplacez les tabulations par des espaces. Ils ont le même nombre de caractères et les tabulations sont utilisées plus tard comme caractère spécial.

(?<!\\)((\*|_){2})((?=\S)(?!\2)(\\\2|.)*?)?(?<=\S)\1/(\n)^^((^^\3))\3

Remplacez tout texte de longueur Ndevant être mis en gras par des Nretours à la ligne suivis du texte d'origine.

\\(\*|_)/\t

Remplacez toutes les occurrences d'un délimiteur immédiatement précédées d'une barre oblique avec une tabulation. C'est pour s'assurer que les entrées comme **a\***ont un nombre de caractères de 2 au lieu de 3.

[^\t\n]/

Supprimez tout caractère qui n'est pas un onglet ou une nouvelle ligne.

\n/_

Remplacez toutes les nouvelles lignes par des traits de soulignement.

\t_?/

Supprimez tous les onglets (qui représentent les délimiteurs échappés), ainsi que les traits de soulignement qui peuvent les suivre. Ceci est lié au problème ci-dessus du nombre de caractères avec les délimiteurs de fin échappés.

(_*)/(^^\1)

Remplacez la séquence de soulignement par sa longueur. Ceci est le nombre de caractères.

Python: 133 caractères

import re
f=lambda s:sum(len(x[0])-4for x in re.findall(r'(([_*])\2\S.*?\2\2+)',re.sub(r'([_*])\1\1\1','xxxx',re.sub(r'\\.','x',s))))

Cela devrait fonctionner de manière identique dans Python 2 et 3. La fonction fretourne le nombre de caractères gras qui seront dans la chaîne, il est passé lors du formatage par le système de démarque de Stack Overflow.

Je pense que la plupart des cas d'angle sont corrects (y compris tous ceux mentionnés dans les commentaires jusqu'à présent), mais ce n'est toujours pas entièrement parfait. Je ne comprends pas pourquoi x***x**ne rend pas le *xen gras (comme le ***x**fait), donc mon code aura au moins quelques entrées erronées.

Le code comporte quatre étapes principales. Le premier fait un remplacement regex de toute barre oblique inverse suivie par n'importe quel caractère avec un caractère 'x'. La deuxième étape remplace toute séquence de quatre astérisques ou traits de soulignement par quatre caractères «x». La troisième étape utilise une expression régulière findallpour trouver tous les blocs qui seront en italique. La dernière étape est une expression de générateur à l'intérieur d'un sumappel, qui additionne les longueurs de ces blocs, en soustrayant 4 caractères de chacun, car nous ne voulons pas inclure les délimiteurs dans notre décompte.

Voici quelques résultats de test:

>>> f('The **quick brown fox jumps over the lazy** dog.')
35
>>> f('The **quick brown fox jumps over the lazy dog.')
0
>>> f('The \**quick brown fox jumps over the lazy dog.**')
0
>>> f('The** quick** brown fox jumps over the lazy dog.**')
0
>>> f('The __quick\____ brown fox **jumps over\** the** lazy \**dog.')
23
>>> f('The****quick brown fox****jumps over **the****lazy** dog.')
11
>>> f('\***a**')
1
>>> f('x***x**') # this one doesn't match the Stack Overflow input box
2

JavaScript ES6, 91 octets

s=>(o=0,s.replace(/\\(.)\1/g,'..').replace(/(\*\*|__)(?=\S)(.*?\S)\1/g,l=>o+=l.length-4),o)

Traite toutes les évasions avant la main, puis utilise une expression régulière. Beaucoup de potentiel golfique.

Explication

s=>( // Function with argument s
  o=0, // Set var "o" to 0
  s.replace( // Replace...
    /\\(.)\1/g,  // Matches \ followed by two the same characters. g means "global"
    ".." // Replace with two arbitrary characters
  ).replace( // Replace again...
     /(\*\*|__) // Match ** or __, store in "group 1"
       (?=\S)   // Make sure next character isn't whitespace
       (.*?\S)\1  // Match all characters until "group 1".
                  // Make sure last character isn't whitespace
     /g, l=> // Take the match...
       o+= // Increase o by...
         l.length // the length of the match
         - 4 // minus 4 to account for ** and __
  ), o) // Return o