introduction

Essayez de convertir des mots en deux polices Unicode différentes.

Défi

Votre tâche consiste à transformer votre chaîne d'entrée en caractères unicode 𝖬𝖺𝗍𝗁 𝖲𝖺𝗇𝗌 et 𝗠𝗮𝘁𝗵 𝗦𝗮𝗻𝘀 𝗕𝗼𝗹𝗱.

Tous les mots en majuscules doivent devenir des mots en minuscules 𝗠𝗮𝘁𝗵 𝗦𝗮𝗻𝘀 𝗕𝗼𝗹𝗱.

• Par exemple: WORD->𝘄𝗼𝗿𝗱

Tous les mots en minuscules doivent devenir 𝖬𝖺𝗍𝗁 𝖲𝖺𝗇𝗌 mots

• Par exemple: other words->𝗈𝗍𝗁𝖾𝗋 𝗐𝗈𝗋𝖽𝗌

Tous les mots en majuscule doivent rester inchangés

• Par exemple: Mixed Case Words->Mixed Case Words

Les périodes et les espaces devraient rester inchangés.

Les mots sont séparés par des espaces ou des points

• Par exemple (les choses en surbrillance sont des mots):

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

• Entrées: chaîne contenant des lettres, des espaces et des points ( [A-Za-z .]+)
• Sortie: la chaîne formatée

Comme c'est un défi de golf, le plus petit nombre d'octets gagne

Exemple d'entrée et de sortie

Contribution:

Il s'agit d'un exemple STRING qui doit être ENTRÉE. Il peut contenir plusieurs phrases.

Sortie:

Ce 𝗂𝗌 𝖺𝗇 𝖾𝗑𝖺𝗆𝗉𝗅𝖾 𝘀𝘁𝗿𝗶𝗻𝗴 𝗍𝗁𝖺𝗍 𝖼.𝗈.𝘂.𝗹.𝖽. 𝖻𝖾 𝗶𝗻𝗽𝘂𝘁𝘁𝗲𝗱. C'est 𝖼𝖺𝗇 𝗰𝗼𝗻𝘁𝗮𝗶𝗻 𝗆𝗎𝗅𝗍𝗂𝗉𝗅𝖾 𝗌𝖾𝗇𝗍𝖾𝗇𝖼𝖾𝗌.

Référence

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

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

QuadR , 45 43 octets

-2 grâce à ngn.

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

Puisque TIO brouille la sortie Unicode de QuadR, voici une capture d'écran de l'utilisation de QuadR comme bibliothèque APL dans une session interactive:

\w+ remplacer les mots par le résultat de leur appliquer le code suivant:

⍵M le mot trouvé
⎕UCS le U niversal C haracter S et les points de code de ce
a← magasin que a
96> 0 ou 1 , pour que 96 est plus grand que chacun d' entre eux
∪ il suffit de prendre l'unique, [0]ou [1]ou [0,1]ou [1,0]
b← stockez cela dans b
⊃ le premier de cette
84× multiplication 84 avec cela
120153+ ajoutez 120153 à cela
(... )× multipliez ce qui suit avec cela:
 ≢b le décompte (longueur) de b( 1si cas unique, 2si cas mixte)
 2> 0 ou 1 pour savoir si deux sont supérieur ( 1si cas unique, 0cas mixte)
a+ les points de code d'origine ajoutés à ce
⎕UCS convertir les points de code résultants en caractères

APL (Dyalog Unicode) , 63 57 53 octets

-6 merci à Erik l'Outgolfer. -4 grâce à ngn.

Fonction de préfixe tacite anonyme.

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

Puisque TIO brouille la sortie Unicode de Dyalog APL, voici une capture d'écran du code en action:

'\w+'⎕R PCRE R Les mots EPlacez avec le résultat de l' application ce qui suit ...

{... } lambda anonyme:

 ⍵.Match le mot trouvé

 ⎕UCS le U niversal C haracter S et les points de code de ce

 a← stocker cela dans a

 96> 0 ou 1 pour savoir si 96 est supérieur à chacun de ceux

 ∪ prenez juste l'unique; [0]ou [1]ou [0,1]ou[1,0]

 b← stocker cela dans b

 ⊃ choisissez le premier

 84× multiplier 84 par celui

 120153+ ajouter 120153 à cela

 (… )× Multipliez ce qui suit par cela:

  ≢b le décompte (longueur) de b( 1si cas unique, 2cas mixte)

  2> 0 ou 1 pour savoir si deux est supérieur à cela ( 1si cas unique, 0cas mixte)

 a+ les points de code d'origine ajoutés à cela

 ⎕UCS convertir les points de code résultants en caractères

Propre , 268 265 232 224 octets

En prime, cela fonctionne avec des chaînes contenant n'importe quel caractère. Y compris les null.

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]

Essayez-le en ligne!

Définit la fonction @, en prenant UStringet en retournant unUString

C, 292 caractères, 448 octets (en 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);}

Essayez-le en ligne!

Déroulé:

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 octets

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;}

Je dois utiliser un StringBufferau lieu d'un régulier Stringà utiliser .appendCodePoint, malheureusement ..

Explication:

Essayez-le en ligne.

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 octets

(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

Essayez-le en ligne!

Assez simple. L' #opérateur prend l'ensemble sdes caractères (majuscules ou minuscules), le mot wet l'ensemble mathématique sans r. Il renvoie le mot dans la police math sans si tous les caractères du mot sont dans sou sinon la liste vide. La tfonction prend un mot et essaie les trois possibilités (toutes supérieures, toutes inférieures ou mixtes), en retournant la première qui n'est pas vide. La ffonction trouve le premier mot en utilisant span, en le transformant tet en le concaténant avec le séparateur (soit .ou espace) et en répétant sur le reste de la chaîne. L'autre cas est pour si span ne peut pas trouver de séparateur; nous transformons simplement la chaîne.

Edit: Merci à @Laikoni d'avoir enlevé 2 octets! Je ne suis pas habitué à la chose "opérateur qui prend trois arguments"

Gelée , 34 octets

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

Essayez-le en ligne!

Programme complet.

Rétine , 84 octets

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

Essayez-le en ligne! Explication: Retina est une application .NET et fonctionne donc en UTF-16 en interne. Malheureusement, comme les caractères Math Sans ne sont pas dans le BMP, je ne peux pas les transliter directement car le nombre de points de code diffère. Pire, je ne peux pas du tout utiliser de substituts non appariés. Au lieu de cela, je décale les mots appropriés en caractères de la plage 0xFF-0x7FFqui ne prennent commodément que deux octets à coder, et je les préfixe également avec le 0x135caractère. Enfin, je mappe cette plage sur une plage qui chevauche les substituts non appariés, créant des paires BMP valides.

Python 3, 173 122 120 120 octets

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 octets de ShreevatsaR

-2 octets de abccd

Essayez-le en ligne!

Fractionne les limites des mots ( re.split(r'\b(\w+)\b',s)), puis mappe les mots en minuscules sur 𝗅𝗈𝗐𝖾𝗋𝖼𝖺𝗌𝖾 𝗆𝖺𝗍𝗁 𝗌𝖺𝗇𝗌 ( +120153*t.islower()) et les mots en majuscules sur 𝗯𝗼𝗹𝗱 𝗺𝗮𝘁𝗵 𝘀𝗮𝗻𝘀 ( +120237*t.isupper()), et laisse les mots en majuscules seuls, puis joinles mots sont sauvegardés.

Non golfé et non lambda:

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 octets

Comprend un non imprimable (charcode 153) après le dernier #.

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

Essayez-le

Explication

                        :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

Solution originale 32 octets Japt v2

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

Essayez-le

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 octets

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

Essayez-le en ligne!

JavaScript (ES6), 99 114 113 octets

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

(Merci à @pfg d'avoir signalé une faille importante dans ma première solution.)

-1 octets grâce à @Neil.

Fragment:

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