Preambuła

W wycenie stosu wymiany używamy ** do pogrubienia tekstu. Na przykład to przecena:

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

Renderuje jako:

Szybki brązowy lis przeskoczył nad leniwym psem.

Oczywiście używamy ** również do zamykania odwagi. Więc mniej odpowiedzi będzie odważne. Na przykład:

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

Renderuje jako:

Szybkie brązowy lis przeskoczył nad leniwym psem.

Jeśli jednak pogrubienie nie zostanie zamknięte, zostanie wyświetlone jako pogrubione :

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

Renderuje jako:

** Szybki brązowy lis przeskakuje nad leniwym psem.

Jeśli tekst ma pojedynczy odwrotny ukośnik \, śmiałość nie działa:

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

Renderuje jako:

** szybki brązowy lis przeskakuje nad leniwym psem. **

Końcowa biała spacja powoduje, że tekst nie jest pogrubiony (uwaga, biała spacja po brązie to pojedyncza karta):

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

Renderuje jako:

** szybki ** brązowy lis przeskakuje nad leniwym psem. **

Możemy również użyć __ dla pogrubienia, ale pamiętaj, że tylko jeden może być aktywny na raz. Oto bardziej skomplikowany przykład:

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

Renderuje jako:

Szybkie ** brązowy fox__ skacze over__ the__ leniwe ** psa.

Pytanie:

Można napisać program lub funkcję, podany tekst ASCII albo jako Stringargumentu lub standardowego wejścia, gdzie tylko znaki specjalne **, __, \(dla ucieczki) i końcowe białe znaki, ustalić, ile znaków są pogrubione. Ta wartość powinna być wydrukowana do STDOUT lub zwrócona z twojej funkcji. Nie musisz obsługiwać bardzo długich łańcuchów; Długość łańcucha nie może być większa niż 30K, co stanowi limit dla postu wymiany stosu.

Drobnym drukiem:

• Czy mogę zgłosić wyjątek / inny błąd dla jednej sprawy i wrócić normalnie dla drugiej?
  • Nie. Musi to być wyraźna, jednoznaczna, nieskomplikowana wartość zwracana w obu przypadkach. Dane wyjściowe STDERR zostaną zignorowane.
• Czy spacje między słowami są uważane za pogrubione?
  • Tak. **quick brown**ma w nim 11 pogrubionych znaków.
• Gdyby \w \**razie pogrubienie, liczone?
  • Nie. Renderuje się jako **, więc jeśli powinien być pogrubiony, miałby tylko 2 znaki.
• Wyjaśnij całkowicie: co rozumiesz przez liczbę znaków?
  • Wszystkie znaki, które byłyby pogrubione. Oznacza to, że nie** jest renderowany, jeśli przekształca tekst, ale jest renderowany, jeśli nie.
  • Pamiętaj, że **pogrubienie można wykonać na kilka sposobów, np. **\****-> ** .
  • Nie bierz pod uwagę możliwości konwersji niektórych tekstów na kursywę. Tylko Przecena reguła do rozważenia jest ** = pogrubiony *.
• Na stosie wymiany działa również pogrubienie HTML. tj. <b> </b>
  • Tak, jestem tego świadomy. Nie bierz tego pod uwagę, to zwykły tekst.
• Co z kodami HTML? np. <-><
  • Te również należy traktować jako zwykły tekst, nie ma konwersji encji HTML.
• Pomyślałem o przykładzie, którego nie opisałeś powyżej!
  • Reguły działają dokładnie tak, jakby tekst został opublikowany na Stack Exchange, w odpowiedzi (nie w komentarzu), z tym wyjątkiem, że bloki kodu nie są uważane za znaki specjalne . Zarówno typ czterech spacji, jak i backtick. Jeśli nie masz pewności, jak tekst powinien być renderowany, po prostu wrzuć go gdzieś jako pole odpowiedzi, są to zasady, których należy przestrzegać.

Przykłady:

Wejście:

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

Wynik:

35

Wejście:

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

Wynik:

0

Wejście:

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

Wynik:

18

Wejście:

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

Wynik:

23

Wejście:

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

Wynik:

11

Standardowe luki są zakazane.

rs , 107 bajtów

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

Prezentacje na żywo i przypadki testowe.

To całkiem szalone ... coś.

Najnowszy przypadek testowy jeszcze nie działa. WIP ...

Wyjaśnienie

\t/ 

Zamień tabulatory na spacje. Mają tę samą liczbę znaków, a tabulatory są później używane jako znaki specjalne.

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

Zamień Npogrubiony tekst na znaki Nnowej linii, a następnie tekst oryginalny.

\\(\*|_)/\t

Zastąp wszelkie wystąpienia ogranicznika bezpośrednio poprzedzone ukośnikiem tabulatorem. Ma to na celu upewnienie się, że wpisy takie jak liczba **a\***mają 2 zamiast 3.

[^\t\n]/

Usuń dowolny znak, który nie jest tabulatorem ani znakiem nowej linii.

\n/_

Zastąp wszystkie nowe wiersze podkreśleniami.

\t_?/

Usuń wszystkie tabulatory (które reprezentują separatory), a także wszelkie podkreślenia, które mogą po nich nastąpić. Jest to związane z powyższym problemem liczenia znaków z ogranicznikami zakończonymi znakami ucieczki.

(_*)/(^^\1)

Zamień sekwencję podkreślenia na jej długość. To jest liczba znaków.

Python: 133 znaki

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

Powinno to działać identycznie zarówno w Pythonie 2, jak i 3. Funkcja fzwraca liczbę pogrubionych znaków, które będą w ciągu, który zostanie przekazany, po sformatowaniu przez system przeceny stosu przepełnienia.

Myślę, że dobrze rozumiem większość przypadków narożnych (w tym wszystkie wspomniane do tej pory w komentarzach), ale wciąż nie jest ona do końca idealna. Nie rozumiem, dlaczego x***x**nie wyświetla się *xpogrubioną czcionką (tak jak ***x**robi), więc mój kod otrzyma co najmniej kilka nieprawidłowych danych wejściowych.

Kod składa się z czterech głównych kroków. Pierwszy polega na zamianie wyrażenia regularnego dowolnego ukośnika odwrotnego, po którym następuje dowolny znak ze znakiem „x”. Drugi krok zastępuje dowolną sekwencję czterech gwiazdek lub znaków podkreślenia czterema znakami „x”. Trzeci krok używa wyrażenia regularnego, findallaby znaleźć wszystkie bloki, które zostaną zapisane kursywą. Ostatnim krokiem jest wyrażenie generatora wewnątrz sumwywołania, które sumuje długości tych bloków, odejmując 4 znaki od każdego, ponieważ nie chcemy uwzględniać ograniczników w naszych obliczeniach.

Oto kilka wyników testu:

>>> 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 bajtów

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

Rozpatruje wszystkie ucieczki przed ręką, a następnie używa wyrażenia regularnego. Duży potencjał golfowy.

Wyjaśnienie

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