Fortress était un langage développé par le Sun Programming Language Research Group (RIP Fortress) qui avait une propriété unique, il était possible de rendre ("Fortify") des programmes dans différents styles de police (c.-à-d. Tableau noir gras, gras, italique, romain, etc.). L'objectif est de représenter une variable Fortress d'un caractère dans le balisage HTML.

Voici comment la fortification des variables à un caractère a fonctionné (simplifiée / modifiée à partir de la documentation à des fins de golf de code):

• Si la variable est une majuscule répétée (c.-à-d. ZZ), Elle devient formatée en gras noir ( 𝔸𝔹ℂ𝔻𝔼𝔽𝔾ℍ𝕀𝕁𝕂𝕃𝕄ℕ𝕆ℙℚℝ𝕊𝕋𝕌𝕍𝕎𝕏𝕐ℤ)
• Si la variable est précédée d'un trait de soulignement, la variable est rendue en police romaine (laissée seule)
• Si la variable est suivie d'un trait de soulignement, la variable est rendue en gras ( <b>v </b>)
• Si la variable n'est ni précédée ni suivie d'un trait de soulignement, la variable est rendue en italique ( <i>v </i>)
• Les points de code des caractères gras du tableau noir sont:: 𝔸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. Ceux-ci comptent pour un octet chacun dans votre programme (si la langue de votre choix peut gérer ces caractères)

L'entrée sera soit une majuscule ASCII répétée, soit une seule lettre ASCII sans aucun trait de soulignement, un trait de soulignement de début ou un trait de soulignement de fin (AKA _a_ne sera pas une entrée). C'est le code-golf donc le nombre d'octets le plus bas gagne!

Cas de test:

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

Liens: Spécification , Téléchargement direct de la version 0.1 alpha .

Implémentation de référence (ce serait dans Fortress, mais Fortress n'aime pas la plupart des caractères doublestruck, donc cette implémentation 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>");
}

Gelée , 73 octets

_{Il s'avère que ne pas pouvoir utiliser les lettres BBB dans le code coûte assez cher.}

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

Un programme complet prenant un argument et imprimant le résultat.

Essayez-le en ligne! ou consultez la suite de tests .

Comment?

Le point d'entrée principal est la dernière ligne de code ("Lien 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 octets

1 octet enregistré grâce à @ Zacharý

3 octets enregistrés grâce à @ VаlueInk

28 octets économisés grâce à @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]=='_']

Essayez-le en ligne!

Ruby , 104 106 105 + 1 = 105 107 106 "octets"

Fonctionne probablement encore mieux dans la rétine. Utilise le -pdrapeau.

-1 octet de Zacharý.

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

Essayez-le en ligne!

JavaScript, 97 caractères

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

Pourquoi une langue a des méthodes comme String.prototype.italicset String.prototype.bold?

Grâce à Neil, économisez 9 octets, utilisez [...s]au lieu de s.match(/./u).