Introducción

Intente convertir palabras a dos fuentes Unicode diferentes.

Reto

Su tarea es transformar su cadena de entrada en los caracteres unicode 𝖬𝖺𝗍𝗁 𝖲𝖺𝗇𝗌 y 𝗠𝗮𝘁𝗵 𝗦𝗮𝗻𝘀 𝗕𝗼𝗹𝗱.

Todas las palabras en mayúscula deben convertirse en minúsculas 𝗠𝗮𝘁𝗵 𝗦𝗮𝗻𝘀 𝗕𝗼𝗹𝗱

• Por ejemplo: WORD->𝘄𝗼𝗿𝗱

Todas las palabras en minúsculas deberían convertirse en palabras 𝖬𝖺𝗍𝗁 𝖲𝖺𝗇𝗌

• Por ejemplo: other words->𝗈𝗍𝗁𝖾𝗋 𝗐𝗈𝗋𝖽𝗌

Todas las palabras con mayúsculas y minúsculas deben permanecer sin cambios.

• Por ejemplo: Mixed Case Words->Mixed Case Words

Los períodos y los espacios deben permanecer sin cambios.

Las palabras están separadas por espacios o puntos.

• Por ejemplo (las cosas resaltadas son palabras):

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

• Entradas: una cadena que contiene letras, espacios y puntos ( [A-Za-z .]+)
• Salida: la cadena formateada

Como se trata de un desafío de golf, gana el menor número de bytes

Ejemplo de entrada y salida

Entrada:

Este es un ejemplo de STRING que PODRÍA ENTRARSE. Puede contener múltiples oraciones.

Salida:

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

Referencia

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

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

QuadR , 45 43 bytes

-2 gracias a ngn.

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

Dado que TIO codifica la salida Unicode de QuadR, aquí hay una captura de pantalla del uso de QuadR como una biblioteca APL en una sesión interactiva:

\w+ reemplace las palabras con el resultado de aplicarles el siguiente código:

⍵M la palabra que se encuentra
⎕UCS la U NIVERSAL C r incón dele S et puntos de código de esa
a← tienda que en a
96> 0 o 1 para si 96 es mayor que cada uno de los
∪ tomar sólo el único; [0]o [1]o [0,1]o [1,0]
b← almacenar eso en b
⊃ elegir el primero de ese
84× multiplicar 84 con eso
120153+ sumar 120153 a eso
(... )× multiplicar lo siguiente con eso:
 ≢b el recuento (longitud) de b( 1si es un caso, 2si es un caso mixto)
 2> 0 o 1 para si dos es mayor que eso ( 1si es un caso simple, 0si es un caso mixto),
a+ el código original apunta a eso
⎕UCS convertir los puntos de código resultantes a caracteres

APL (Dyalog Unicode) , 63 57 53 bytes

-6 gracias a Erik the Outgolfer. -4 gracias a ngn.

Función de prefijo tácito anónimo.

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

Dado que TIO codifica la salida Unicode de Dyalog APL, aquí hay una captura de pantalla del código en acción:

'\w+'⎕R PCRE R palabras EColoque con el resultado de aplicar la siguiente ...

{... } lambda anónima:

 ⍵.Match la palabra encontrada

 ⎕UCS la U NIVERSAL C r incón dele S puntos et código de ese

 a← almacenar eso en a

 96> 0 o 1 para saber si 96 es mayor que cada uno de esos

 ∪ toma solo lo único; [0]o [1]o [0,1]o[1,0]

 b← almacenar eso en b

 ⊃ elige el primero de eso

 84× multiplicar 84 con eso

 120153+ agregue 120153 a eso

 (... )× multiplique lo siguiente con eso:

  ≢b el recuento (longitud) de b( 1si está en mayúsculas 2y minúsculas)

  2> 0 o 1 para saber si dos es mayor que eso ( 1si es un caso, 0si es un caso mixto)

 a+ los puntos de código originales añadidos a eso

 ⎕UCS convertir los puntos de código resultantes a caracteres

Limpio , 268 265 232 224 bytes

Como una buena ventaja, esto funciona con cadenas que contienen cualquier personaje. Incluidos nulos.

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]

Pruébalo en línea!

Define la función @, tomando a UStringy devolviendo unUString

C, 292 caracteres, 448 bytes (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);}

Pruébalo en línea!

Desenrollado:

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

Tengo que usar un en StringBufferlugar de un Stringuso regular .appendCodePoint, desafortunadamente ...

Explicación:

Pruébalo en línea.

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

Pruébalo en línea!

Bastante sencillo. El #operador toma el conjunto sde caracteres (mayúsculas o minúsculas) la palabra wy el conjunto matemático sin r. Devuelve la palabra en la fuente math sans si todos los caracteres de la palabra están en sla lista vacía o si no. La tfunción toma una palabra e intenta las tres posibilidades (todas superiores, todas inferiores o mixtas), devolviendo la primera que no está vacía. La ffunción encuentra la primera palabra mediante el uso span, transformándola ty concatenada con el separador ( .o espacio) y recurriendo en el resto de la cadena. El caso alternativo es para si span no puede encontrar un separador; solo transformamos la cadena.

Editar: ¡Gracias a @Laikoni por despegar 2 bytes! No estoy acostumbrado a toda la cosa del "operador que toma tres argumentos"

Jalea , 34 bytes

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

Pruébalo en línea!

Programa completo

Retina , 84 bytes

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

Pruébalo en línea! Explicación: Retina es una aplicación .NET y, por lo tanto, funciona internamente en UTF-16. Desafortunadamente, como los caracteres de Math Sans no están en el BMP, no puedo transcribirlos directamente porque la cantidad de puntos de código difiere. Peor aún, no puedo usar sustitutos no apareados en absoluto. En cambio, cambio las palabras apropiadas a caracteres en el rango 0xFF-0x7FFque convenientemente solo requieren dos bytes para codificar, además también los prefijo con el 0x135carácter. Finalmente, mapeo ese rango en el rango que se superpone a los sustitutos no emparejados, creando pares BMP válidos.

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

-2 bytes de abccd

Pruébalo en línea!

Se divide en los límites de las palabras ( re.split(r'\b(\w+)\b',s)), luego asigna las palabras en minúsculas a 𝗅𝗈𝗐𝖾𝗋𝖼𝖺𝗌𝖾 𝗆𝖺𝗍𝗁 𝗌𝖺𝗇𝗌 ( +120153*t.islower()), y las palabras en mayúsculas a 𝗯𝗼𝗹𝗱 𝗺𝗮𝘁𝗵 𝘀𝗮𝗻𝘀 ( +120237*t.isupper()), y deja solo las palabras en mayúsculas y minúsculas , luego joinlas palabras vuelven a aparecer.

Sin golf y sin 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 bytes

Incluye un no imprimible (charcode 153) después del último #.

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

Intentalo

Explicación

                        :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

Solución original de 32 bytes Japt v2

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

Intentalo

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

Pruébalo en línea!

JavaScript (ES6), 99 114 113 bytes

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

(Gracias a @pfg por señalar una falla importante en mi primera solución).

-1 bytes gracias a @Neil.

Retazo:

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