𝗠𝗮𝘁𝗵 𝖲𝖺𝗇𝗌 𝗔𝗹𝘁𝗲𝗿𝗻𝗮𝘁𝗼𝗿


28

Introdução

Tente converter palavras em duas fontes unicode diferentes.

Desafio

Sua tarefa é transformar sua sequência de entrada nos caracteres unicode 𝖬𝖺𝗍𝗁 𝖲𝖺𝗇𝗌 e 𝗠𝗮𝘁𝗵 𝗦𝗮𝗻𝘀 𝗕𝗼𝗹𝗱.

Todas as palavras em maiúsculas devem se tornar em minúsculas 𝗠𝗮𝘁𝗵 𝗦𝗮𝗻𝘀 𝗕𝗼𝗹𝗱.

  • Por exemplo: WORD->𝘄𝗼𝗿𝗱

Todas as palavras em minúsculas devem se tornar palavras 𝖬𝖺𝗍𝗁 𝖲𝖺𝗇𝗌

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

Todas as palavras em maiúsculas e minúsculas devem permanecer inalteradas

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

Períodos e espaços devem permanecer inalterados.

As palavras são separadas por espaços ou pontos

  • Por exemplo (coisas destacadas são palavras):

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

  • Entradas: uma sequência contendo letras, espaços e pontos ( [A-Za-z .]+)
  • Saída: a sequência formatada

Como este é um desafio para o golfe, o menor número de bytes ganha

Exemplo de entrada e saída

Entrada:

Este é um exemplo STRING que pode ser INPUTADO. Pode conter várias frases.

Saída:

Este 𝗂𝗌 𝖺𝗇 𝖾𝗑𝖺𝗆𝗉𝗅𝖾 𝘀𝘁𝗿𝗶𝗻𝗴 𝗍𝗁𝖺𝗍 𝖼.𝗈.𝘂.𝗹.𝖽. 𝗶𝗻𝗽𝘂𝘁𝘁𝗲𝗱 𝗶𝗻𝗽𝘂𝘁𝘁𝗲𝗱. É isso.

Referência

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

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


3
Bem-vindo ao PPCG!
Laikoni

6
Apenas do ♫ Filosofia 𝗌𝖺𝗇𝗌 𝗆𝖺𝗍𝗁 rigor, sentido, e praticidade ... ♫
Esolanging Fruit

13
Uau! Você tem um título em negrito na barra lateral? O que? Eu ... não entendo .... a internet está quebrando? Já que você quebrou a internet?
precisa saber é o seguinte

26
i.stack.imgur.com/R4V3C.png Eu vim aqui pensando que este desafio foi sobre caixas de empilhamento, gráficos de barras ou algo assim ...
Matteo Italia

8
Isso não deveria ter sido martelado. Esse problema é significativamente mais difícil do que uma simples transliteração de caracteres. A resposta líder no desafio citado não pode facilmente nem competitivamente ser transferidos usando o mesmo método (AFAICT, minha retina não é grande)
Conor O'Brien

Respostas:


10

QuadR , 45 43 bytes

-2 graças a ngn.

\w+
UCS a+(2>≢b120153+84×⊃b←∪96>a←⎕UCSM

Como o TIO embaralha a saída Unicode do QuadR, eis uma captura de tela do uso do QuadR como uma biblioteca APL em uma sessão interativa: transcrição da sessão interativa


\w+ substitua as palavras pelo resultado da aplicação do seguinte código a elas:

⍵M a palavra encontrada
⎕UCS a L niversal C haracter S et pontos de código de que
a← loja que em a
96> 0 ou 1 para se 96 é maior do que cada um daqueles
 tomada apenas a única; [0]ou [1]ou [0,1]ou [1,0]
b← armazene que, ao b
 escolher o primeiro,
84× multiplique 84 pelo que
120153+ adicione 120153 ao que
( multiplique o seguinte por:
≢b o registro (comprimento) de b( 1se for um caso, 2se for um caso misto)
2> 0 ou 1 para se dois maior que isso ( 1se for um caso, 0se for um caso misto),
a+ os pontos de código originais adicionados a esse
⎕UCS converter os pontos de código resultantes em caracteres


9

APL (Dyalog Unicode) , 63 57 53 bytes

-6 graças a Erik, o Outgolfer. -4 graças a ngn.

Função de prefixo tácito anônimo.

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

Como o TIO embaralha a saída Unicode do Dyalog APL, aqui está uma captura de tela do código em ação:

código em ação


'\w+'⎕R PCRE R palavras EColoque com o resultado da aplicação da seguinte ...

{... } lambda anônima:

⍵.Match a palavra encontrada

⎕UCS a U niversal C haracter S pontos et código de que

a← guarde isso em a

96> 0 ou 1 para se 96 é maior que cada um deles

 pegue apenas o único; [0]ou [1]ou [0,1]ou[1,0]

b← guarde isso em b

 escolha o primeiro

84× multiplicar 84 com isso

120153+ adicione 120153 a isso

( Multiplique o seguinte por isso:

  ≢b o registro (comprimento) de b( 1se for um caso, 2se for um caso misto)

  2> 0 ou 1 para se dois são maiores que isso ( 1se for um caso, 0se for um caso misto)

a+ os pontos de código originais adicionados a isso

⎕UCS converter os pontos de código resultantes em caracteres


57 bytes:'\b([A-Z]+|[a-z]+)\b'⎕R{⎕UCS(⎕UCS+120153+84×∊∘⎕A)⍵.Match}
Erik the Outgolfer,

@EriktheOutgolfer Thanks. Por que não pensei em me tornar tácito?
Adám 20/02/19

Não sei, mas acontece comigo quando estou cansada. :)
Erik the Outgolfer

@EriktheOutgolfer Na verdade, acho que escrevi este em casa usando o computador da minha esposa sem o layout do teclado APL…
Adám

@ Adám que regex é muito longo; você é melhor fora de usar \w+e calcular o montante a adicionar aos codepoints no DFN:'\w+'⎕R{⎕UCS a+(2>≢b)×120153+84×⊃b←∪96>a←⎕UCS⍵.Match}
NGN

8

Limpo , 268 265 232 224 bytes

Como um bônus puro, isso funciona com strings contendo qualquer caractere. Incluindo 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]

Experimente online!

Define a função @, pegando UStringe retornando umUString


3
Também é um bônus limpo? : D
Conor O'Brien

6

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

Experimente online!

Desenrolado:

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

5

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

Eu tenho que usar um em StringBuffervez de um regular Stringpara usar .appendCodePoint, infelizmente ..

Explicação:

Experimente online.

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

4

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

Experimente online!

Bastante direto. O #operador pega o conjunto sde caracteres (maiúsculas ou minúsculas) na palavra we o conjunto matemática sem r. Retorna a palavra na fonte math sans se todos os caracteres da palavra estiverem na slista vazia ou caso contrário. A tfunção pega uma palavra e tenta todas as três possibilidades (todas superiores, todas inferiores ou mistas), retornando a primeira que não está vazia. A ffunção localiza a primeira palavra usando span, transformando-a te concatenando-a com o separador ( .espaço ou) ou recorrente no restante da cadeia. O caso alternativo é para se o span não conseguir encontrar um separador; nós apenas transformamos a string.

Edit: Obrigado a @Laikoni por descolar 2 bytes! Eu não estou acostumado com toda a coisa "operador que leva três argumentos"


1
(['A'..'Z']#w)['𝗮'..]pode ser ['A'..'Z']#w$['𝗮'..].
Laikoni


3

Retina , 84 bytes

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

Experimente online! Explicação: O Retina é um aplicativo .NET e, portanto, funciona internamente em UTF-16. Infelizmente, como os caracteres Math Sans não estão no BMP, não posso transliterá-los diretamente, porque o número de pontos de código é diferente. Pior, não posso usar substitutos não pareados. Em vez disso, mudo as palavras apropriadas para caracteres no intervalo 0xFF-0x7FFque, convenientemente, levam apenas dois bytes para codificar, além de prefixo-los com o 0x135caractere. Finalmente, mapeio esse intervalo para um intervalo que se sobrepõe aos substitutos não emparelhados, criando pares válidos de BMP.


3

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

Experimente online!

Divide nos limites das palavras ( re.split(r'\b(\w+)\b',s)), mapeia as palavras em minúsculas para 𝗅𝗈𝗐𝖾𝗋𝖼𝖺𝗌𝖾 𝗆𝖺𝗍𝗁 𝗌𝖺𝗇𝗌 ( +120153*t.islower()) e as maiúsculas em 𝗯𝗼𝗹𝗱 𝗺𝗮𝘁𝗵 𝘀𝗮𝗻𝘀 ( +120237*t.isupper()) e deixa as palavras em maiúsculas sozinhas e, em seguida, faz joino backup das palavras.

Ungolfed e 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

poderia haver menos bytes se você definisse uma variável como 120237 ou 120153, dependendo se era superior ou inferior? Parece que pode
pfg

1
@pfg De fato, pode facilmente remover 13 bytes (até 160 ).
ShreevatsaR

@pfg Na verdade, substituir o map-lambda por compreensões (mais fáceis de ler) reduz para 149 bytes .
precisa saber é o seguinte

5
122 :-) eu vou parar por aqui; muito orgulhoso de como o golfe facilitou a leitura. Somente em Python!
ShreevatsaR 26/01

2
-2 eliminando espaços antesfor
abccd 27/01

3

Japonês , 34 33 32 31 bytes

Inclui um não imprimível (código 153) após o último #.

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

Tente


Explicação

                        :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

Solução original de 32 bytes Japt v2

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

Tente

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

1
Se importa de adicionar um despejo XXD?
Stan Strum 27/01

Um hexdump reversível? Para os imprimíveis.
Stan Strum


1

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

(Obrigado ao @pfg por apontar uma falha importante na minha primeira solução.)

-1 bytes graças a @Neil.

Snippet:


Isso só funciona com o HTML por causa do & #, para fazê-lo com JS puro, você precisaria usar o String.fromCodePoint(120237)que aumentaria o tamanho
pfg

Ainda não grogue isso, mas voltarei mais tarde, obrigado.
21718 Rick Hitchcock

let a = s=>s.replace(/\b([A-Z]+|[a-z]+)\b/g,e=>e.replace(/./g,f=>String.fromCodePoint(f.charCodeAt(0)+120153+(f<'a')*84)))funciona pura JS, mas acrescenta muitos bytes extras
PFG

Ah, eu entendi! Daggum.
23918 Rick Hitchcock

3
Salve 1 byte usando charCodeAt()sem o 0.
Neil
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.