Einführung

Versuchen Sie, Wörter in zwei verschiedene Unicode-Schriftarten zu konvertieren.

Herausforderung

Ihre Aufgabe ist es, Ihre Eingabezeichenfolge in die Unicode-Zeichen 𝖬𝖺𝗍𝗁 𝖬𝖺𝗍𝗁 und 𝗠𝗮𝘁𝗵 𝗦𝗮𝗻𝘀 𝗦𝗮𝗻𝘀 umzuwandeln.

Alle Wörter in Großbuchstaben sollten zu 𝗠𝗮𝘁𝗵 𝗠𝗮𝘁𝗵 𝗦𝗮𝗻𝘀 Wörtern in Kleinbuchstaben werden.

• Zum Beispiel: WORD->𝘄𝗼𝗿𝗱

Alle Kleinbuchstaben sollten zu 𝖬𝖺𝗍𝗁 𝖬𝖺𝗍𝗁 Wörtern werden

• Zum Beispiel: other words->𝗈𝗍𝗁𝖾𝗋 𝗐𝗈𝗋𝖽𝗌

Alle Wörter in Groß- und Kleinschreibung sollten unverändert bleiben

• Zum Beispiel: Mixed Case Words->Mixed Case Words

Punkte und Leerzeichen sollten unverändert bleiben.

Wörter werden durch Leerzeichen oder Punkte getrennt

• Zum Beispiel (hervorgehobene Dinge sind Wörter):

Hello. This is a word. S. O.are these

• Eingaben: Eine Zeichenfolge mit Buchstaben, Leerzeichen und Punkten ( [A-Za-z .]+)
• Ausgabe: Die formatierte Zeichenfolge

Da dies eine Golfherausforderung ist, gewinnt die niedrigste Anzahl von Bytes

Beispiel für Ein- und Ausgabe

Eingang:

Dies ist eine Beispielzeichenfolge, die möglicherweise EINGEBEN wird. Es kann mehrere Sätze enthalten.

Ausgabe:

Dies 𝗂𝗌 𝗂𝗌 𝖺𝗇 𝖾𝗑𝖺𝗆𝗉𝗅𝖾 𝘀𝘁𝗿𝗶𝗻𝗴 𝗍𝗁𝖺𝗍.𝖼.𝗈.𝘂.𝗹. 𝖻𝖾 𝖻𝖾. Es 𝖼𝖺𝗇 𝖼𝖺𝗇 𝗰𝗼𝗻𝘁𝗮𝗶𝗻 𝗌𝖾𝗇𝗍𝖾𝗇𝖼𝖾𝗌.

Referenz

Math Sans Bold: 𝗮𝗯𝗰𝗱𝗲𝗳𝗴𝗵𝗶𝗷𝗸𝗹𝗺𝗻𝗼𝗽𝗾𝗿𝘀𝘁𝘂𝘃𝘄𝘅𝘆𝘇 (Zeichen 120302 bis 120327)

Math Sans: 𝖺𝖻𝖼𝖽𝖾𝖿𝗀𝗁𝗂𝗃𝗄𝗅𝗆𝗇𝗈𝗉𝗊𝗋𝗌𝗍𝗎𝗏𝗐𝗑𝗒𝗓 (Zeichen 120250 bis 120275)

QuadR , 45 43 Bytes

-2 danke an ngn.

\w+
⎕UCS a+(2>≢b)×120153+84×⊃b←∪96>a←⎕UCS⍵M

Da TIO die Unicode-Ausgabe von QuadR verschlüsselt, sehen Sie hier einen Screenshot der Verwendung von QuadR als APL-Bibliothek in einer interaktiven Sitzung:

\w+ Ersetzen Sie Wörter durch das Ergebnis der Anwendung des folgenden Codes:

⍵M das gefundene Wort
⎕UCS der U niversal C HARACTER S et Codepunkte dieses
a← speichern , die in a
96> 0 oder 1 für 96 , ob größer als jedes dieser
∪ braucht nur die einzigartige; [0]oder [1]oder [0,1]oder [1,0]
b← speichere das in b
⊃ wähle das erste aus dem
84× multipliziere 84 mit dem
120153+ addiere 120153 zu dem
(... )× multipliziere das folgende mit dem:
 ≢b Die Summe (Länge) von b( 1wenn Einzelfall, 2wenn Mischfall )
 2> 0 oder 1 für ob zwei ist Größer als dieser 1Wert (im Einzelfall, 0im gemischten Fall) werden
a+ die ursprünglichen Codepunkte hinzugefügt
⎕UCS konvertieren Sie die resultierenden Codepunkte zurück in Zeichen

APL (Dyalog Unicode) , 63 57 53 Bytes

-6 danke an Erik den Outgolfer. -4 danke an ngn.

Anonyme implizite Präfixfunktion.

'\w+'⎕R{⎕UCS a+(2>≢b)×120153+84×⊃b←∪96>a←⎕UCS⍵.Match}

Da TIO die Unicode-Ausgabe von Dyalog APL verschlüsselt, ist hier ein Screenshot des Codes in Aktion:

'\w+'⎕R PCRE R eplace Worte mit dem Ergebnis der folgenden Anwendung ...

{... } anonymes Lambda:

 ⍵.Match das gefundene Wort

 ⎕UCS die U niversal C HARACTER S et Codepunkte , dass

 a← Speichern Sie das in a

 96> 0 oder 1 für, ob 96 größer ist als diese

 ∪ nimm nur das Einzigartige; [0]oder [1]oder [0,1]oder[1,0]

 b← Speichern Sie das in b

 ⊃ wähle den ersten davon aus

 84× multiplizieren Sie 84 damit

 120153+ addiere 120153 dazu

 (… )× Multipliziere folgendes damit:

  ≢b die Anzahl (Länge) von b(im 1Einzelfall, 2im gemischten Fall)

  2> 0 oder 1, ob zwei größer sind als das (im 1Einzelfall, 0im gemischten Fall)

 a+ Die ursprünglichen Codepunkte wurden hinzugefügt

 ⎕UCS konvertieren Sie die resultierenden Codepunkte zurück in Zeichen

Sauber , 268 265 232 224 Bytes

Als ordentlicher Bonus funktioniert dies mit Zeichenfolgen, die beliebige Zeichen enthalten. Einschließlich Nullen.

import StdLib,StdInt,StdBool,Text.Unicode,Text.Unicode.UChar
u=isUpper
l=isAlpha
$c|l c=fromInt(toInt c+120153+if(u c)84 0)=c
?[h,s:t]=[if(u h<>isLower s)($c)c\\c<-[h,s:t]]
?[h]=[$h]
@s=[y\\x<-groupBy(\a b=l a&&l b)s,y<- ?x]

Probieren Sie es online!

Definiert die Funktion @, wobei a genommen UStringund a zurückgegeben wirdUString

C, 292 Zeichen, 448 Bytes (in UTF-8)

char*t;s,i,k;p(l){for(l=s=*t/96,i=k=strlen(t);i--;)t[i]/96-s&&++l;for(l=l-s&&write(1,t,k);!l&++i<k;)write(1,s?"𝖺𝖻𝖼𝖽𝖾𝖿𝗀𝗁𝗂𝗃𝗄𝗅𝗆𝗇𝗈𝗉𝗊𝗋𝗌𝗍𝗎𝗏𝗐𝗑𝗒𝗓"+t[i]*4-388:"𝗮𝗯𝗰𝗱𝗲𝗳𝗴𝗵𝗶𝗷𝗸𝗹𝗺𝗻𝗼𝗽𝗾𝗿𝘀𝘁𝘂𝘃𝘄𝘅𝘆𝘇"+t[i]*4-260,4);}f(char*s){char b[strlen(s)];for(t=b;*s;++s)*s<47?(*t=0),p(t=b),putchar(*s):(*t++=*s);*t=0;p(t=b);}

Probieren Sie es online!

Abgerollt:

char*t;
s,i,k;

p(l)
{
    for (l=s=*t/96, i=k=strlen(t); i--;)
        t[i]/96-s && ++l;

    for (l=l-s&&write(1, t, k); !l&++i<k;)
        write(1, s ? "𝖺𝖻𝖼𝖽𝖾𝖿𝗀𝗁𝗂𝗃𝗄𝗅𝗆𝗇𝗈𝗉𝗊𝗋𝗌𝗍𝗎𝗏𝗐𝗑𝗒𝗓"+t[i]*4-388
                   : "𝗮𝗯𝗰𝗱𝗲𝗳𝗴𝗵𝗶𝗷𝗸𝗹𝗺𝗻𝗼𝗽𝗾𝗿𝘀𝘁𝘂𝘃𝘄𝘅𝘆𝘇"+t[i]*4-260, 4);
}

f(char*s)
{
    char b[strlen(s)];

    for (t=b; *s; ++s)
        *s<47 ? (*t=0), p(t=b), putchar(*s) : (*t++=*s);

    *t = 0;
    p(t=b);
}

Java 8, 221 219 203 201 Bytes

s->{StringBuffer r=new StringBuffer();for(String x:s.split("(?<=[\\. ])|(?=[\\. ])"))x.codePoints().forEach(c->r.appendCodePoint(c+(x.matches("[A-Z]+")?120237:x.matches("[a-z]+")?120153:0)));return r;}

Ich muss leider eine StringBufferanstelle einer regulären Stringverwenden .appendCodePoint..

Erläuterung:

Probieren Sie es online aus.

s->{                           // Method with String parameter and StringBuffer return-type
  StringBuffer r=new StringBuffer();
                               //  Resulting StringBuffer
  for(String x:s.split("(?<=[\\. ])|(?=[\\. ])"))
                               //  Split by space or dot, and keep them as separate items,
                               //  and loop over all those substrings
   x.codePoints().forEach(c->  //   Inner loop over the codepoints of that substring
      r.appendCodePoint(       //    Convert int to char, and append it to the result:
        c                      //     The next codepoint of the substring
        +(x.matches("[A-Z]+")? //     If the word is fully uppercase:
           120237              //      Add 120237 to convert it to Math Sans Bold
          :x.matches("[a-z]+")?//     Else-if the word is fully lowercase:
           120153              //      Add 120153 to convert it to Math Sans
          :                    //     Else (mixed case, or a dot/space)
           0)));               //      Leave the codepoint (and thus the character) as is
  return r;}                   //  Return the resulting StringBuffer

Haskell , 172-170 Bytes

(s#w)r=[x|all(`elem`s)w,c<-w,(x,k)<-zip r s,c==k]
t[]=[]
t w=filter(>[])[['A'..'Z']#w$['𝗮'..],['a'..'z']#w$['𝖺'..],w]!!0
f s|(a,b:c)<-span(>'.')s=t a++b:f c|1>0=t s

Probieren Sie es online!

Ziemliech direkt. Der #Operator übernimmt die Menge sder Zeichen (Groß- oder Kleinschreibung) des Wortes wund die Menge der mathematischen Zeichen r. Es wird das Wort in der Schriftart math sans zurückgegeben, wenn sich alle Zeichen des Wortes in sder leeren Liste befinden. Die tFunktion nimmt ein Wort und versucht alle drei Möglichkeiten (alle oberen, alle unteren oder gemischten), wobei die erste zurückgegeben wird, die nicht leer ist. Die fFunktion findet das erste Wort, indem spansie tes mit dem Trennzeichen (entweder .oder Leerzeichen) verwendet , transformiert und verkettet und den Rest der Zeichenfolge wiederholt. Der alternative Fall ist für den Fall, dass span kein Trennzeichen finden kann. Wir transformieren nur die Zeichenfolge.

Edit: Danke an @Laikoni für das Abheben von 2 Bytes! Ich bin nicht an den ganzen "Operator mit drei Argumenten" gewöhnt

Jelly , 34 Bytes

e€ØBŒg
ṁǵŒl,Œuiị“¡ẓƬ“¡ẓġ“’×Ç+OỌµ€

Probieren Sie es online!

Volles Programm.

Retina , 84 Bytes

/\b[A-Z]+\b/_(`.
ĵ$&
)T`L`ۮ-܇
/\b[a-z]+\b/_(`.
ĵ$&
)T`l`ں-ۓ
T`ÿ-߿`퟿-

Probieren Sie es online! Erläuterung: Retina ist eine .NET-Anwendung und arbeitet daher intern in UTF-16. Da die Math Sans-Zeichen nicht im BMP enthalten sind, kann ich sie leider nicht direkt transliterieren, da die Anzahl der Codepunkte unterschiedlich ist. Schlimmer noch, ich kann überhaupt keine ungepaarten Ersatzzeichen verwenden. Stattdessen verschiebe ich die entsprechenden Wörter in Zeichen im Bereich, für 0xFF-0x7FFderen Codierung zweckmäßigerweise nur zwei Bytes erforderlich sind, und stelle ihnen auch das 0x135Zeichen voran. Schließlich ordne ich diesen Bereich einem Bereich zu, der die ungepaarten Ersatzzeichen überlappt, wodurch gültige BMP-Paare erstellt werden.

Python 3, 173 122 120 Bytes

lambda s:''.join(chr(ord(c)+120153*t.islower()+120237*t.isupper())for t in re.split(r'\b(\w+)\b',s)for c in t)
import re

-51 Bytes von ShreevatsaR

-2 Bytes von abccd

Probieren Sie es online!

Teilt sich an Wortgrenzen ( re.split(r'\b(\w+)\b',s)), ordnet Kleinbuchstaben zu to 𝗅𝗈𝗐𝖾𝗋𝖼𝖺𝗌𝖾 𝗆𝖺𝗍𝗁 ( +120153*t.islower()) und Großbuchstaben zu 𝗯𝗼𝗹𝗱 𝗯𝗼𝗹𝗱 𝗺𝗮𝘁𝗵 ( +120237*t.isupper()) zu und lässt Wörter mit gemischten Großbuchstaben in Ruhe, bevor die Wörter gesichert joinwerden.

Ungolfed und un-lambda-ed:

def f(s):
    words = re.split(r'\b(\w+)\b', s)
    ret = ''
    for word in words:
        for char in word:
            if word.isupper():
                ret += chr(ord(c) + 120237)
            elif word.islower():
                ret += chr(ord(c) + 120153)
            else:
                ret += c
    return ret

Japt , 34 33 32 31 Bytes

Enthält einen nicht druckbaren (Charcode 153) nach dem letzten #.

rV="%b%A+%b"Èc+#x#í
rVv Èc+#x#

Versuch es

Erläuterung

                        :Implicit input of string U
r                       :Replace
   "%b%A+%b"            :/\b[A-Z]+\b/g
 V=                     :Assign ^that to variable V
            È           :Run each match through a function
             c          :Map over the codepoints of the current match
              +#x#í     :  Add 120237
\n                      :Assign the result of that replacement to variable U
rVv                     :Another replacement, this time with V lowercased to give us the RegEx /\b[a-z]+\b/g
    Èc+#x#              :And, again, map over the codepoints of each match, this time adding 120153 to each

Original 32 Byte Japt v2 Lösung

r/\b(\A+|\a+)\b/Èc_+#x#+#T*(X¶u

Versuch es

r                                     :Replace
 /\b(\A+|\a+)\b/                      :...all matches of this RegEx (\A=[A-Z], \a=[a-z])
                È                     :Pass each match through a function, with X being the current match
                 c_                   :Pass the codepoints of X through a function
                   +                  :Add to the current codepoint
                    #x#               :120153 (there's an unprintable after the second #)
                        +#T           :Plus 84
                           *          :  Multiplied by
                            (X¶u      :  Is X equal to its uppercase self

05AB1E , 33 Bytes

€aγ€g£εÐ.u•1Ù„•*s.l•1Ùm•*+sÇ+çJ}J

Probieren Sie es online!

JavaScript (ES6), 99 114 113 Byte

s=>s.replace(/\b([A-Z]+|[a-z]+)\b/g,e=>e.replace(/./g,f=>String.fromCodePoint(f.charCodeAt()+120153+(f<'a')*84)))

(Vielen Dank an @pfg für den Hinweis auf einen wichtigen Fehler in meiner ersten Lösung.)

-1 Bytes dank @Neil.

Snippet:

let f = 

s=>s.replace(/\b([A-Z]+|[a-z]+)\b/g,e=>e.replace(/./g,f=>String.fromCodePoint(f.charCodeAt()+120153+(f<'a')*84)))

d.innerHTML=f('This is an example STRING that c.o.U.L.d. be INPUTTED. It can CONTAIN multiple sentences.');

<p id="d">