Fortress war eine Sprache, die von der Sun Programming Language Research Group (RIP Fortress) entwickelt wurde und eine einzigartige Eigenschaft hatte. Es war möglich, Programme in verschiedenen Schriftstilen (z. B. fett, fett, kursiv) zu rendern ("Fortify"). römisch usw.). Ziel ist es, eine Fortress-Variable mit einem Zeichen im HTML-Markup darzustellen.

So funktionierte die Anreicherung von Ein-Zeichen-Variablen (vereinfacht / modifiziert aus der Dokumentation für Code-Golf-Zwecke):

• Wenn die Variable ein wiederholtes Großbuchstaben ist (dh ZZ), wird sie in Fettdruck ( 𝔸𝔹ℂ𝔻𝔼𝔽𝔾ℍ𝕀𝕁𝕂𝕃𝕄ℕ𝕆ℙℚℝ𝕊𝕋𝕌𝕍𝕎𝕏𝕐ℤ) formatiert.
• Wenn der Variablen ein Unterstrich vorangestellt ist, wird die Variable in römischer Schrift gerendert (in Ruhe gelassen).
• Wenn auf die Variable ein Unterstrich folgt, wird die Variable in Fettdruck ( <b>v </b>) gerendert.
• Wenn der Variablen weder ein Unterstrich vorangestellt noch gefolgt wird, wird die Variable in Kursivschrift ( <i>v </i>) gerendert.
• Die Codepunkte der Fettdrucke sind 𝔸:: 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. Diese zählen in Ihrem Programm jeweils als ein Byte (wenn die Sprache Ihrer Wahl diese Zeichen überhaupt verarbeiten kann)

Die Eingabe ist entweder ein wiederholtes ASCII-Großbuchstaben oder ein einzelner ASCII-Buchstabe ohne Unterstrich, einen führenden Unterstrich oder einen nachfolgenden Unterstrich (AKA _a_ist keine Eingabe). Dies ist Code-Golf, also gewinnt die niedrigste Byteanzahl!

Testfälle:

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

Links: Spezifikation , Direkter Download von Version 0.1 Alpha .

Referenzimplementierung (Dies wäre in Fortress, aber Fortress mag die meisten doppelt getroffenen Charaktere nicht, daher befindet sich diese Implementierung in 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>");
}

Gelee , 73 Bytes

_{Es stellt sich heraus, dass es ziemlich teuer ist, die BBB-Buchstaben im Code nicht verwenden zu können.}

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

Ein vollständiges Programm, das ein Argument verwendet und das Ergebnis druckt.

Probieren Sie es online aus! oder sehen Sie sich die Testsuite an .

Wie?

Der Haupteinstiegspunkt ist die letzte Codezeile ("Hauptlink").

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 dank @ Zacharý gespeichert

3 Bytes dank @ VаlueInk gespeichert

28 Bytes dank @Rod gespart

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]=='_']

Probieren Sie es online aus!

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

Funktioniert wahrscheinlich noch besser in der Netzhaut. Verwendet -pFlagge.

-1 Byte von Zacharý.

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

Probieren Sie es online aus!

JavaScript, 97 Zeichen

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

Warum hat eine Sprache Methoden wie String.prototype.italicsund String.prototype.bold?

Dank Neil sparen Sie 9 Bytes und verwenden [...s]statt s.match(/./u).