Preambolo

Nel markdown di Stack Stack, usiamo ** per mettere in grassetto il testo. Ad esempio, questo markdown:

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

Rendering come:

La rapida volpe marrone salta sopra il cane pigro .

Naturalmente, usiamo anche ** per chiudere l'audacia. Quindi meno della risposta sarà in grassetto. Per esempio:

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

Rendering come:

La rapida volpe marrone salta sopra il cane pigro .

Tuttavia, se l'audacia non è chiusa, viene visualizzata come non audace :

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

Rendering come:

La ** veloce volpe marrone salta sopra il cane pigro.

Se il testo ha una singola barra rovesciata \, il grassetto non ha effetto:

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

Rendering come:

La ** veloce volpe marrone salta sopra il cane pigro. **

Lo spazio bianco finale genera un testo non piegato (nota, lo spazio bianco dopo il marrone è una singola scheda):

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

Rendering come:

La ** veloce ** volpe marrone salta sopra il cane pigro. **

Possiamo anche usare __ anche in grassetto, ma nota che solo uno può essere attivo alla volta. Ecco un esempio più complicato:

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

Rendering come:

La veloce ** volpe marrone _ salta sopra__ il _ cane pigro **.

La domanda:

Si può scrivere un programma o una funzione, dato testo ASCII o come un Stringargomento o su STDIN, dove gli unici caratteri speciali sono **, __, \(per sfuggire) e spazio bianco in coda, determinare il numero di caratteri in grassetto ci sono. Questo valore deve essere stampato su STDOUT o restituito dalla funzione. Non è necessario supportare stringhe molto lunghe; La lunghezza della stringa è garantita non più di 30K, che è il limite per un post di Stack Stack.

Stampa fine:

• Posso generare un'eccezione / altro errore per un caso e restituire normalmente per l'altro?
  • No. Deve essere un valore di ritorno chiaro, inequivocabile e non errato per entrambi i casi. L'uscita STDERR verrà ignorata.
• Gli spazi tra le parole sono considerati in grassetto?
  • Sì. **quick brown**contiene 11 caratteri in grassetto.
• Se l' \a \**, se grassetto, contare?
  • No. Viene visualizzato come **, quindi se deve essere in grassetto dovrebbe contenere solo 2 caratteri.
• Sii completamente chiaro: cosa intendi con quanti personaggi?
  • Caratteri totali che renderebbero grassetto. Ciò significa che non** viene visualizzato se trasforma il testo, ma viene visualizzato in caso contrario.
  • Nota che è possibile **essere in grassetto in diversi modi, ad es. **\****-> ** .
  • Non considerare la possibilità che alcuni testi possano essere convertiti in corsivo. L' unica regola di markdown da considerare è ** = grassetto *.
• Su Stack Exchange, anche HTML Bold funziona. cioè <b> </b>
  • Sì, lo so. Non considerare questo caso, questo è un testo normale.
• Che dire di HTML entit? es. <-><
  • Anche questi dovrebbero essere considerati come testo normale, non esiste una conversione di entità HTML.
• Ho pensato ad un esempio che non hai trattato sopra!
  • Le regole funzionano esattamente come se il testo fosse pubblicato su Stack Exchange, in una risposta (non in un commento), tranne per il fatto che i blocchi di codice non sono considerati caratteri speciali . Entrambi i quattro tipi di spazio e il tipo di backtick. Se non si è sicuri su come debba essere eseguito il rendering del testo, basta inserirlo in una casella di risposta da qualche parte come test, queste sono le regole da seguire.

Esempi:

Ingresso:

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

Produzione:

35

Ingresso:

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

Produzione:

0

Ingresso:

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

Produzione:

18

Ingresso:

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

Produzione:

23

Ingresso:

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

Produzione:

11

Le scappatoie standard sono vietate.

rs , 107 byte

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

Demo live e casi di test.

Questa è una cosa piuttosto folle ...

Il nuovo test case non funziona ancora. WIP ...

Spiegazione

\t/ 

Sostituisci le schede con spazi. Hanno lo stesso numero di caratteri e le schede vengono utilizzate in seguito come carattere speciale.

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

Sostituisci qualsiasi testo di lunghezza Nche dovrebbe essere in grassettoN nuove righe seguite dal testo originale.

\\(\*|_)/\t

Sostituisci le occorrenze di un delimitatore immediatamente preceduto da una barra con una scheda. Questo per assicurarsi che le voci piacciano**a\*** abbiano un numero di caratteri pari a 2 anziché 3.

[^\t\n]/

Rimuovi qualsiasi personaggio che non sia una scheda o una nuova riga.

\n/_

Sostituisci tutte le newline con underscore.

\t_?/

Rimuovere tutte le schede (che rappresentano i delimitatori con escape), insieme a tutti i trattini bassi che possono seguirli. Ciò è correlato al problema precedente relativo al conteggio dei caratteri con delimitatori di fine di escape.

(_*)/(^^\1)

Sostituisci la sequenza di sottolineatura con la sua lunghezza. Questo è il conteggio dei personaggi.

Python: 133 caratteri

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

Questo dovrebbe funzionare in modo identico in Python 2 e 3. La funzione f restituisce il numero di caratteri in grassetto che si troveranno nella stringa che viene passata quando formattata dal sistema di markdown Stack Overflow.

Penso di avere la maggior parte dei casi d'angolo giusti (compresi tutti quelli citati finora nei commenti), ma non è ancora del tutto perfetto. Non capisco perché x***x**non rende il*x in grassetto (come ***x**fa), quindi il mio codice avrà almeno alcuni input sbagliati.

Il codice ha quattro passaggi principali. Il primo esegue una sostituzione regex di qualsiasi barra rovesciata seguita da qualsiasi carattere con un carattere "x". Il secondo passaggio sostituisce qualsiasi sequenza di quattro asterix o caratteri di sottolineatura con quattro caratteri "x". Il terzo passo usa una regexfindall per trovare tutti i blocchi che saranno in corsivo. Il passaggio finale è un'espressione generatrice all'interno di una sumchiamata, che somma le lunghezze di quei blocchi, sottraendo 4 caratteri da ciascuno, poiché non vogliamo includere i delimitatori nel nostro conteggio.

Ecco alcuni risultati del 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 byte

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

Affronta prima tutte le fughe, quindi usa un'espressione regolare. Un sacco di potenziale per il golf.

Spiegazione

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