Fortress fue un lenguaje desarrollado por Sun Programming Language Research Group (RIP Fortress) que tenía una propiedad única, era posible representar ("Fortificar") programas en diferentes estilos de fuente (es decir, pizarra en negrita, negrita, cursiva, romana, etc.). El objetivo es representar una variable Fortaleza de un carácter en el marcado HTML.

Así es como funcionó la fortificación de las variables de un carácter (simplificado / modificado de la documentación para propósitos de código de golf)

• Si la variable es una mayúscula repetida (es decir ZZ), se formatea en negrita ( 𝔸𝔹ℂ𝔻𝔼𝔽𝔾ℍ𝕀𝕁𝕂𝕃𝕄ℕ𝕆ℙℚℝ𝕊𝕋𝕌𝕍𝕎𝕏𝕐ℤ)
• Si la variable está precedida por un guión bajo, la variable se representa en fuente romana (solo se deja)
• Si la variable es seguida por un guión bajo, la variable se representa en negrita ( <b>v </b>)
• Si la variable no está precedida ni seguida de un guión bajo, la variable se representa en letra cursiva ( <i>v </i>)
• Los puntos de código de las letras en negrita son:: 𝔸1D538,: 1D539 𝔹,: ℂ2102 𝔻,: 1D53B,: 1D53C,: 1D53D 𝔼,: 𝔽1D53E 𝔾,: ℍ210D 𝕀,: 𝕁1D540 𝕂,: 𝕃1D541 𝕄,: 1D542,: 1D543,: 1D544,: ℕ2115, 𝕆: 1D546,: ℙ2119 ,: ℚ211A ℝ,: 𝕊211D 𝕋,: 𝕌1D54A 𝕍,: 𝕎1D54B 𝕏,: 𝕐1D54C,: 1D54D,: 1D54E,: 1D54F,: 1D550,: ℤ2124. Estos cuentan como un byte cada uno en su programa (si su idioma de elección puede manejar estos caracteres)

La entrada será una letra ASCII repetida o una sola letra ASCII sin guión bajo, guión bajo o guión bajo (AKA _a_no será una entrada). Este es el código de golf, por lo que gana el conteo de bytes más bajo

Casos de prueba:

a => <i>a</i>
BB => 𝔹
c_ => <b>c</b>
_d => d
E => <i>E</i>
G_ => <b>G</b>
_H => H
ZZ => ℤ

Enlaces: Especificación , Descarga directa de la versión 0.1 alfa .

Implementación de referencia (Esto sería en Fortress, pero a Fortress no le gustan la mayoría de los personajes dobles, por lo que esta implementación está en D):

dstring fortify(string arg) {
    import std.string, std.conv;

    alias D = to!dstring; //Convert to a string that accepts the unicode needed
    dstring BB = "𝔸𝔹ℂ𝔻𝔼𝔽𝔾ℍ𝕀𝕁𝕂𝕃𝕄ℕ𝕆ℙℚℝ𝕊𝕋𝕌𝕍𝕎𝕏𝕐ℤ"d; //blackboard bold capitals
    string UC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; //normal ASCII capitals

    if(arg.length == 1)
        return D("<i>" ~ arg ~ "</i>");
    if(arg[0] == a[1])
        return D(BB[UC.indexOf(arg[0])]);
    if(arg[0] == '_')
        return D(arg[1]);
    return D("<b>" ~ arg[0] ~ "</b>");
}

Jalea , 73 bytes

_{Resulta que no poder usar las letras BBB en el código es bastante costoso.}

5ŀ”i
“Ðñṡ’Dẋ@€“¡ḞḄ’ż“¿¿Æ€¢¬µ‘+⁽ø³F⁸ṪO¤+ị¥Ọ
Ṫ
Ḣ5ŀ”b
;j“<>/”ṃ@“¢ʠf’
i”_+LµĿ

Un programa completo que toma un argumento e imprime el resultado.

Pruébalo en línea! o ver el conjunto de pruebas .

¿Cómo?

El punto de entrada principal es la última línea de código ("Enlace principal").

5ŀ”i - Link 1: list of characters, s (length 1 & no underscore)
  ”i - literal character 'i'
5ŀ   - call link 5 as a dyad with s on the left and 'i' on the right

“Ðñṡ’Dẋ@€“¡ḞḄ’ż“¿¿Æ€¢¬µ‘+⁽ø³F⁸ṪO¤+ị¥Ọ - Link 2: list of characters, s (length 2 & no underscore)
“Ðñṡ’                                 - base 250 literal              1007245
     D                                - to decimal list               [1,0,0,7,2,4,5]
         “¡ḞḄ’                        - base 250 literal              111673
      ẋ@€                             - repeat with reversed @rguments for €ach -> [[111673],[],[],[111673,111673,111673,111673,111673,111673,111673],[111673,111673],[111673,111673,111673,111673],[111673,111673,111673,111673,111673]]
               “¿¿Æ€¢¬µ‘              - code page index list          [11,11,13,12,1,7,9]
              ż                       - zip together                  [[111673,11],[11],[13],[[111673,111673,111673,111673,111673,111673,111673],12],[[111673,111673],1],[[111673,111673,111673,111673],7],[[111673,111673,111673,111673,111673],9]]
                         ⁽ø³          - base 250 literal              8382
                        +             - addition (vectorises)         [[120055,8393],[8393],[8395],[[120055,120055,120055,120055,120055,120055,120055],8394],[[120055,120055],8383],[[120055,120055,120055,120055],8389],[[120055,120055,120055,120055,120055],8391]]
                            F         - flatten                       [120055,8393,8393,8395,120055,120055,120055,120055,120055,120055,120055,8394,120055,120055,8383,120055,120055,120055,120055,8389,120055,120055,120055,120055,120055,8391]
                                ¤     - nilad followed by link(s) as a nilad:                                                                                    ^
                             ⁸        -   chain's left argument, s  e.g.    "CC"                                                                                 |
                              Ṫ       -   tail (last character)             'C'                                                                                  |
                               O      -   cast to ordinal                   67                                                                                   |
                                   ¥  - last two links as a dyad:                                                                                                |
                                  ị   -   index into (1-indexed & modular)  8383 (this is at index 67%26=15 -----------------------------------------------------+ )
                                 +    -   add the ordinal                   8450
                                    Ọ - convert from ordinal to character   'ℂ'

Ṫ - Link 3: list of characters, s (length 2 & underscore at index 1)
Ṫ - tail (get the first character

Ḣ5ŀ”b - Link 4: list of characters, s (length 2 & underscore at index 2)
Ḣ     - head s (the non-_ character)
   ”b - literal character 'b'
 5ŀ   - call link 5 as a dyad with the non-_ character on the left and 'b' on the right

;j“<>/”ṃ@“¢ʠf’ - Link 5, wrap in a tag: element, tagName      e.g. 'a', 'i'
;              - concatenate the element with the tagName          "ai"
  “<>/”        - literal list of characters                        "<>/"
 j             - join                                              "a<>/i"
         “¢ʠf’ - base 250 literal                                  166603
       ṃ@      - base decompression with reversed @rguments
               -   "a<>/i" is 5 long, so 166603 is converted to
               -   base 5 [2,0,3,1,2,4,0,3] with digits "a<>/i"    "<i>a</i>"

i”_+LµĿ - Main link: list of characters, s (as specified only):
 ”_     - literal '_'
i       - index of '_' in s (1-indexed; 0 if not found)
    L   - length of s
   +    - addition
     µĿ - call link with that number as a monad with argument s
        - implicit print

Python 3.6, 159 131 128 bytes

1 byte guardado gracias a @ Zacharý

3 bytes guardados gracias a @ VаlueInk

28 bytes guardados gracias a @Rod

lambda s:len(s)<2and f"<i>{s}</i>"or s[0]==s[1]and"𝔸𝔹ℂ𝔻𝔼𝔽𝔾ℍ𝕀𝕁𝕂𝕃𝕄ℕ𝕆ℙℚℝ𝕊𝕋𝕌𝕍𝕎𝕏𝕐ℤ"[ord(s[0])-65]or[f"<b>{s[0]}</b>",s[1]][s[0]=='_']

Pruébalo en línea!

Rubí , 104 106 105 + 1 = 105 107 106 "bytes"

Probablemente funciona aún mejor en Retina. Utiliza -pbandera.

-1 byte de Zacharý.

gsub /^.$/,'<i>\0</i>'
gsub(/(.)\1/){$1.tr"A-Z","𝔸𝔹ℂ𝔻-𝔾ℍ𝕀-𝕄ℕ𝕆ℙℚℝ𝕊-𝕐ℤ"}
gsub /(.)_/,'<b>\1</b>'
gsub ?_,''

Pruébalo en línea!

JavaScript, 97 caracteres

([a,b])=>a==b?[...'𝔸𝔹ℂ𝔻𝔼𝔽𝔾ℍ𝕀𝕁𝕂𝕃𝕄ℕ𝕆ℙℚℝ𝕊𝕋𝕌𝕍𝕎𝕏𝕐ℤ'][a.charCodeAt()-65]:b?b=='_'?a.bold():b:a.italics()

¿Por qué un lenguaje tiene métodos como String.prototype.italicsy String.prototype.bold?

Gracias a Neil, guarde 9 bytes, use en [...s]lugar de s.match(/./u).