Analise meu esperanto!


21

O famoso idioma construído Esperanto usa o alfabeto latino (principalmente, consulte a página da wikipedia vinculada para obter detalhes). No entanto, existem alguns caracteres com acentos: ĉ, ĝ, ĥ, ĵ, ŝ e ŭ . (C-circunflexo, g-circunflexo, h-circunflexo, j-circunflexo, s-circunflexo e u- breve .) Naturalmente, esses caracteres são muito difíceis de digitar. Mesmo para essa pergunta, tive que procurar no seletor Unicode os caracteres. Devido a isso, uma convenção usando a letra "x" foi desenvolvida para uso eletrônico. Por exemplo, "cxu" é usado para "ĉu". (Nota: a letra "x" não é usada normalmente no alfabeto esperanto. "

No entanto, sou um purista da linguagem! Essa * citação no ar * x absurdo está me matando! Eu preciso de um programa para corrigir isso, de preferência o mais curto possível, para que eu possa digitá-lo no meu terminal o mais rápido possível!

Desafio

Sua missão é pegar uma série de esperanto usando a convenção x e convertê-la em esperanto real.

Na verdade, você precisa mapear:

cx: ĉ
gx: ĝ
hx: ĥ
jx: ĵ
sx: ŝ
ux: ŭ
Cx: Ĉ
Gx: Ĝ
Hx: Ĥ
Jx: Ĵ
Sx: Ŝ
Ux: Ŭ

Todos os outros caracteres ASCII imprimíveis devem ser aceitos e não alterados. Unicode seria bom, mas não necessário.

A entrada e a saída podem estar em qualquer formato razoável ao seu idioma. Boa sorte!

Casos de teste

"input" : "output"
_____________
"gxi estas varma" : "ĝi estas varma"
"Cxu sxi sxatas katojn aux hundojn?" : "Ĉu ŝi ŝatas katojn aŭ hundojn?"
"Uxcxsxabcd(hxSx)efg{};" : "Ŭĉŝabcd(ĥŜ)efg{};"
"qwertyuiop" : "qwertyuiop"
" " : " "
"" : ""
"x" : "x"
"xc" : "xc"
"xcx" : "xĉ"
"cxx" : "ĉx"

Pontuação

Este é . As respostas são pontuadas pelo menor número de bytes na codificação padrão do idioma.

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se você quiser incluir vários números em seu cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou deseja listar as penalidades de sinalizador de intérprete separadamente), verifique se a pontuação real é o último número no cabeçalho:

# Perl, 43 + 2 (-p flag) = 45 bytes

Você também pode transformar o nome do idioma em um link que será exibido no snippet da tabela de classificação:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Boa sorte, divirta-se e fique à vontade para sugerir melhorias!

Esclarecimentos:

  • Você só precisa se preocupar com caracteres ASCII imprimíveis .

  • Você só precisa produzir um caractere que se pareça com a saída correta. Sim, isso significa que você pode colocar o sotaque no caractere padrão.


ASCII aqui significa 20-7E caracteres imprimíveis, 00-7F, ou o quê?
— user202729

Todos os imprimíveis.
— OldBunny2800

Nota: adicionei um esclarecimento de que você pode usar a letra e o sotaque do modificador.
— OldBunny2800

5
A combinação de circunflexo está em 0302 ̂e a combinação de breve está em 0306 ̆.
— user202729

^ Cada um recebe 2 bytes em UTF8 como contagem de TIO .
— user202729

Respostas:


9

QuadR , 65 bytes

.x
3::⍵M⋄'ĉĝĥĵŝŭĈĜĤĴŜŬ'['cghjsuCGHJSU'⍳⊃⍵M]

Experimente online!

.x substitua qualquer caractere seguido de "x" por

3::⍵M em caso de erro de indexação, retorne a correspondência sem modificação
⋄ agora tente:
 'ĉĝĥĵŝŭĈĜĤĴŜŬ'[… ] indexe nesta sequência com
  ⍵M o  índice da
  ⊃ primeira letra da correspondência  nessa sequência
  ⍳
  'cghjsuCGHJSU'

Isso é equivalente à função tácita Dyalog APL:

'.x'⎕R{3::⍵.Match⋄'ĉĝĥĵŝŭĈĜĤĴŜŬ'['cghjsuCGHJSU'⍳⊃⍵.Match]}

Boa resposta! +1
— OldBunny2800

Não sei como os bytes são contados aqui. O uso direto de ⎕R não é mais curto? ('cghjsuCGHJSU',¨'x')⎕r(,¨'ĉĝĥĵŝŭĈĜĤĴŜŬ')
— NGN

@ngn É, mas minha bateria acabou antes que eu tivesse a chance de publicá-la.
— Adám 28/11/17

6

Retina , 27 bytes

iT`x`̂`[cghjs]x
iT`x`̆`ux

Experimente online!

Este programa é composto por duas transliterações. Devido à combinação de caracteres no código, isso não renderiza muito bem, a primeira linha deve parecer semelhante a iT`x`^`[cghjs]x, onde ^significa o caractere de combinação de acento circunflexo. O que isto está dizendo é que ele deve Ttraduzir novamente ( icaso de gnoring) todos os xs da entrada em a ^, sempre que eles estiverem seguindo qualquer letra [cghjs].


Nota: O TIO mede incorretamente esse código como 25 bytes. Na verdade, esse programa Retina usa codificação UTF-8 (outros programas podem usar UTF-32 ou ISO 8859-1) e os dois caracteres combinados presentes custam 2 bytes cada.


5

C,  173  154 bytes

Agradecemos a @Colera Su por salvar 17 bytes!

p,c,i;f(char*s){for(char*l="cghjsuCGHJSU";p=*s;~c&&putchar(p))for(c=*++s,i=0;c=='x'&&l[i];++i)l[i]-p||write(1,"ĉĝĥĵŝŭĈĜĤĴŜŬ"+i*2,2,c=-1,++s);}

Experimente online!

Explicação:

p,c,i;
f(char*s)
{
    // The outer loop and an array of characters that are modified by a trailing 'x'.
    // The array/string is used for getting the index for the accented character later.
    for (char*l="cghjsuCGHJSU";

                                // Store the current character of the input string in 'p'.
                                // If it is '\0', the loop terminates.
                                p=*s;

                                      // The last statement in the loop.
                                      // If 'c==-1', it outputs the char stored in 'p'. 
                                      ~c&&putchar(p))

        // Store the character following 'p' in 'c' and increment the string pointer.
        for(c=*++s, i=0;

                        // If 'c' is not the letter 'x', the inner loop terminates
                        // immediately. Otherwise it loops through the characters of
                        // string 'l'.
                        c=='x'&&l[i]; ++i)

            // If the character stored in 'p' is found inside the string 'l'...
            l[i]-p ||

                      // ...then print the accented character corresponding to 'p'.
                      // 'i' is the index of 'p' in 'l', and, because the characters
                      // with accents are two bytes each, the index is multiplied by 2.
                      write(1,"ĉĝĥĵŝŭĈĜĤĴŜŬ"+i*2,2,

                      // Finally set 'c' to -1 so that the non-accented character doesn't
                      // get printed too, and increment the string pointer so that the
                      // letter 'x' doesn't get printed either.
                                                    c=-1, ++s);
}

Agradável! Posso ter uma explicação, por favor?
— OldBunny2800

Provavelmente você pode usar literalmente byte nulo em vez de \0?
— user202729

(mas que, infelizmente, não funciona em TIO)
— user202729

Você pode usar write(1,"..."+i*2,2)para salvar 17 bytes. Experimente online!
— Colera Su

5

Python 3 , 81 bytes

lambda s,T="cĉgĝhĥjĵsŝuŭ":eval("s"+".replace('%sx',%r)"*12%(*T+T.upper(),))

Experimente online!

Gera e avalia a sequência:

s.replace('cx','ĉ').replace('gx','ĝ').replace('hx','ĥ').replace('jx','ĵ').replace('sx','ŝ').replace('ux','ŭ').replace('Cx','Ĉ').replace('Gx','Ĝ').replace('Hx','Ĥ').replace('Jx','Ĵ').replace('Sx','Ŝ').replace('Ux','Ŭ')

Erik, o Outgolfer, salvou um byte.


@EriktheOutgolfer Nice one, thanks!
— Xnor

3

/// , 75 bytes

/,/\/\///>/x\,/c>ĉ,g>ĝ,h>ĥ,j>ĵ,s>ŝ,u>ŭ,C>Ĉ,G>Ĝ,H>Ĥ,J>Ĵ,S>Ŝ,U>Ŭ/

Nota: Como o pedido de OP todos os caracteres imprimíveis devem ser processados, meus "caracteres especiais" escolhidos não devem ser imprimíveis. Então, escolhi a guia e a nova linha em vez de, o que não altera minha funcionalidade de bytecount ou código. O código ficaria assim:

/
/\/\/// /x\
/c  ĉ
g   ĝ
h   ĥ
j   ĵ
s   ŝ
u   ŭ
C   Ĉ
G   Ĝ
H   Ĥ
J   Ĵ
S   Ŝ
U   Ŭ/

No entanto, isso requer que a entrada não deva conter tab ou novas linhas.

Experimente online!

Como ///não pode receber entrada, você deve colocar a entrada após o código.

Bem direto. Eu acho que não pode ser mais curto porque ///precisa de tratamento especial de cada personagem.

Explicação:

/,/\/\//       Replace all `,` in the code by `//`
               (two slashes are represented as two backslash-ed slashes)
/>/x\,         (in original code) becomes
/>/x\//        (because `,` is replaced by `//`) - replace all occurence of 
               `>` by `x/`.
/cx/ĉ//gx/ĝ//hx/ĥ//jx/ĵ//sx/ŝ//ux/ŭ//Cx/Ĉ//Gx/Ĝ//Hx/Ĥ//Jx/Ĵ//Sx/Ŝ//Ux/Ŭ/
               ^ The remaining part of the code should look like this.
               Straightforward replacement.

3

Python 3 , 95 bytes

f=lambda x,v="cĉgĝhĥjĵsŝuŭCĈGĜHĤJĴSŜUŬ":v and f(x.replace(v[0]+"x",v[1]),v[2:])or x

Experimente online!

-10 bytes graças a WhatToDo
-1 byte graças a Colera Su



@ user507295 oh ideia inteligente. obrigado!
— HyperNeutrino

Use e-ou truque para economizar um byte: Experimente online!
— Colera Su

@ColeraSu oh legal, obrigado. Não sei por que esse truque desapareceu D:
— HyperNeutrino 28/11

@HyperNeutrino Porque eu não sabia sobre esse truque. Desculpe!
— WhatToDo

2

Retina , 55 bytes

iT`CG\HJSUcg\hjsux`ĈĜĤĴŜŬĉĝĥĵŝŭ_`[cghjsux]x

Experimente online! Abordagem não combinada. Os bytes podem ser salvos se não for para os xcasos de teste independentes .



1

JavaScript (ES6), 92 bytes

s=>[..."cghjsuCGHJSU"].reduce((a,v,i)=>a.split(v+"x").join("ĉĝĥĵŝŭĈĜĤĴŜŬ"[i]),s)

Experimente online!

Utilizou o método de junção dividida recomendado aqui para reduzir a contagem de bytes, porque o new RegExp(/*blah*/)construtor ocupou muitos bytes.

Comparação:

Original: a.replace(new RegExp(v+"x", "g"), "ĉĝĥĵŝŭĈĜĤĴŜŬ"[i])
New     : a.split(v+"x").join("ĉĝĥĵŝŭĈĜĤĴŜŬ"[i])

Menor, combinando abordagem de acentuação (63 bytes), mas com alguns artefatos visíveis.

s=>s.replace(/([cghjs])x/gi," ̂$1").replace(/(u)x/gi," ̌$1");

Nota de rodapé: estou reivindicando minha resposta 92 bytes porque a solução de 63 bytes possui artefatos que podem afetar a saída.


1

APL (Dyalog Unicode) , 57 bytes

Função tácita anônima. Usos:

  1. Função de prefixo para string. Isso translitera a string.

  2. Função de prefixo para lista de strings. Isso translitera as strings.

  3. Função Infix com número de ligação do arquivo de entrada como argumento à direita e número de ligação do arquivo de saída como argumento à esquerda. Isso preenche o arquivo de saída com o conteúdo transliterado do arquivo de entrada.

('cghjsuCGHJSU',¨'x')⎕R(,¨'ĉĝĥĵŝŭĈĜĤĴŜŬ')

(... )⎕R(... ) PCRE R moran Jr.

'cghjsuCGHJSU' Estas cartas

,¨'x' cada um seguido por um x

 ... com ...

,¨'ĉĝĥĵŝŭĈĜĤĴŜŬ' cada uma dessas letras como cadeias

Experimente online!


1

J , 64 63 bytes

rplc((_2]\'ĉĝĥĵŝŭĈĜĤĴŜŬ');~"1'cghjsuCGHJSU',.'x')"0

Como funciona:

Com _2]\ eu reorganizo a string 'ĉĝĥĵŝŭĈĜĤĴŜŬ' em uma coluna de 12 linhas para ajustar o formato da outra string.

,. adiciona 'x' a cada caractere da sequência 'cghjsuCGHJSU' e cria uma matriz de 12 linhas por 2 colunas

;~"1' faz uma lista dos pares em caixas dos itens acima ", 1 - classificação 1 - aplica-se a cada linha.

┌──┬──┐
│cx│ĉ │
├──┼──┤
│gx│ĝ │
├──┼──┤
│hx│ĥ │
├──┼──┤
│jx│ĵ │
├──┼──┤
│sx│ŝ │
├──┼──┤
│ux│ŭ │
├──┼──┤
│Cx│Ĉ │
├──┼──┤
│Gx│Ĝ │
├──┼──┤
│Hx│Ĥ │
├──┼──┤
│Jx│Ĵ │
├──┼──┤
│Sx│Ŝ │
├──┼──┤
│Ux│Ŭ │
└──┴──┘

rplc usa esses itens em caixas para substituir cada ocorrência do item em caixas à esquerda de um par pelo da direita.

Experimente online!


1

Befunge , 2x48 1 = 99 bytes

>~:1+!#@_:"x"-v>$ 11p0"cghjsuCGHJSU"1\ >\31p11g-v
^ # #, : ++$\ _^#1"x"0*4!-"u"g11*"ʊ"!\_^#!:\*g13<

Experimente (o TIO é super estranho no Befunge e eu não consegui nenhuma das minhas soluções para trabalhar nele)

Como funciona

>~:1+!@_

Obtém entrada e verifica se é o fim. Finalize o programa, se estiver.

          "x"-v>
^ # #, : ++$\ _^

Verifica se o personagem é um "x". Caso contrário, mantenha uma cópia do caractere e imprima-o.

               >$ 11p0"cghjsuCGHJSU"1\

Armazene o último caractere em (1,1). Coloca todos os caracteres para fazer check-in na pilha.

                                       >\31p11g-v
                                      _^#!:\*g13<

Compare o último caractere com todos os valores na pilha.

                 1"x"0*4!-"u"g11*"ʊ"!\

Multiplique a verificação (0 ou 1) por ʊ (valor unicode 650). Verifique se o personagem era au (para o breve) e adiciona 4 à pilha, se for o caso. Por fim, adicione o valor ascii de x (100) também. O total adiciona o acento correto, se necessário, ou apenas um "x", se não.

>~:1+!#@_  
^ # #, : ++$\ _^#

Adicione todos os valores na pilha, imprima e mantenha uma duplicata. Volte para a próxima entrada.


1

R , 75 70 bytes

function(s)gsub('([cghjs])x','\\1\U302',gsub('(u)x','\\1\U306',s,T),T)

Experimente online!

-5 bytes graças a Giuseppe

Explicação

  • gsub('(u)x','\\1\U306',s,T): substitua em stodas as ocorrências de um "u" maiúsculo ou minúsculo (usando ignore.case=TRUEo quarto argumento T) seguido de um "x" o "u" seguido do unicode por um breve
  • gsub('([cghjs])x','\\1\U302',gsub('(u)x','\\1\U306',s,T),T): pegue o resultado disso e substitua todas as ocorrências de maiúsculas ou minúsculas (usando ignore.case=TRUEo quarto argumento T) "c", "g", "h", "j" ou "s" seguido de um "x" por a letra seguida pelo unicode para um circunflexo

usar ordem de argumento em vez de nomear economiza 3 bytes, e outros dois se livram do zero inicial \U0302e \U0306: Experimente online!
— Giuseppe

@Giuseppe - ótima idéia, obrigado!
— duckmayr

1

QuadR , 25 bytes

Combinando edição diacrítica.

ux
([cghjs])x
 ̆&
 ̂\1

i bandeira

Experimente online!

Substituir…

(u)x         u followed by x and
([cghjs])x   any of these letters followed by x …
 ̆\1          by a breve followed by the first group (the u) and
 ̂\1          a circumflex followed by the first group (the letter)

caso eu nsensitively

Equivalente ao seguinte código Dyalog APL:

'(u)x' '([cghjs])x'⎕R' ̆\1' ' ̂\1'

Por que isso é 28 e não 24 bytes?
— Erik the Outgolfer

@EriktheOutgolfer O contador SBCS da TIO me confundiu. Fixo. Obrigado. Espere, isso significa que eu ganho?
— Adám 28/11/17

Agora, parece que são 27 bytes (copiados do TIO), mas 24 bytes quando copiados daqui. O que é a codificação do QuadR e qual está correto?
— Erik the Outgolfer

@EriktheOutgolfer Ambos os links reportam 24 no meu FFQ / Win10. O QuadR usa o Dyalog Classic ou qualquer Unicode.
— Adám

Então são 24 bytes ou o quê?
— Erik the Outgolfer

1

C, 145 144 bytes

Outra abordagem C. Retorne substituindo a entrada, usando o fato de circumflex / breve são 2 bytes.

-1 bytes graças ao Steadybox .

i,t;f(char*s){for(t=1;*s;s++)if(*s^'x')for(i=12,t=1;i--;)t="cghjsuCGHJSU"[i]-*s?t:i*2;else t^1&&memcpy(s-1,"ĉĝĥĵŝŭĈĜĤĴŜŬ"+t,2),t=1;}

Experimente online!


1
Usar em t^1&&memcpy(s-1,"ĉĝĥĵŝŭĈĜĤĴŜŬ"+t,2),t=1;vez de t^1?memcpy(s-1,"ĉĝĥĵŝŭĈĜĤĴŜŬ"+t,2),t=1:0;salva um byte. Experimente online!
— Steadybox #

1

Mathematica, 81 bytes ou 57 bytes

StringReplace[RemoveDiacritics@#<>"x"->#&/@Characters@"ĉĝĥĵŝŭĈĜĤĴŜŬ"]

Aplica uma regra de substituição em que a letra sem o chapéu junto com um "x" é substituída pela letra.

Aqui está uma alternativa usando o caractere de acentos adicionados: StringReplace[{"ux"->"ŭ","Ux"->"Ŭ",c_~~"x":>c<>"̂"}]


1

Perl 5 , 49 + 2 ( -p -C) = 61 51 bytes

s/[CGHJScghjs]\Kx/\x{0302}/g;s/[Uu]\Kx/\x{0306}/g

Experimente online!

Guardado 10 bytes graças a Nahuel Fouilleul


poderia salvar 7 bytes:s/[CGHJScghjs]\Kx/\x{0302}/g;s/[Uu]\Kx/\x{0306}/g
— Nahuel Fouilleul 28/11

parece que também trabalha apenas com -Ce sem -Ccom advertência ( Wide character in print)
— Nahuel FOUILLEUL

1
de perlrun-C on its own (not followed by any number or option list), or the empty string "" for the PERL_UNICODE environment variable, has the same effect as -CSDL.
— Nahuel Fouilleul 28/11

0

CJam , 51 bytes

q"ĉĝĥĵŝŭĈĜĤĴŜŬ""cghjsuCGHJSU".{'x+@\/*}

Experimente online!

Explicação:

q                   Read input
"ĉĝĥĵŝŭĈĜĤĴŜŬ"      String literal
"cghjsuCGHJSU"      Another string literal
.{                  Iterate over the strings in parallel
  'x+                 Add an 'x to the normal character
  @                   Rotate to bring the input to the top of stack
  \                   Swap to bring the "cx" to the top
  /                   Split the input on instances of "cx"
  *                   Join the input on instances of the accented character
}

São realmente 39 bytes? Conto 39 caracteres e não acho que o CJam tenha uma codificação especial.
— user202729

@ user202729 Alterado (o TIO contou bytes como caracteres por algum motivo)
— Esolanging Fruit

Porque o TIO acredita que todos os idiomas de golfe têm uma página de códigos de caracteres especial e não se preocupa em verificar se todos os caracteres estão na página de códigos correta.
— user202729

0

sed, 108 bytes

s/cx/ĉ/g
s/gx/ĝ/g
s/hx/ĥ/g
s/jx/ĵ/g
s/sx/ŝ/g
s/ux/ŭ/g
s/Cx/Ĉ/g
s/Gx/Ĝ/g
s/Hx/Ĥ/g
s/Jx/Ĵ/g
s/Sx/Ŝ/g
s/Ux/Ŭ/g

Você deve formatar o código como código por `...`ou <pre><code>...</code></pre>ou 4 travessões.
— user202729

@ user202729 Eu obviamente sabia disso. Eu estava enviando do meu telefone Android para não formatá-lo corretamente.
— iBug

2
Parece que tem 119 bytes.
— Erik the Outgolfer

0

PowerShell, 58 bytes

Tem 54 caracteres e salvá-lo no PowerShell ISE o torna UTF-8 + BOM por 58 bytes. Não é tão bem renderizado em um navegador:

$args-replace'(?<=u)x','̆'-replace'(?<=[cghjs])x','̂'

regex substitui x pelos caracteres Unicode combinados do comentário de @ user202729.

por exemplo

PS C:\> .\eo.ps1 "Cxu vi sxatas la cxapelliterojn? Mi ankaux."
Ĉu vi ŝatas la ĉapelliterojn? Mi ankaŭ.

0

Clojure, 126 115 bytes

-11 bytes, alterando o mapa de substituição para uma partição de uma sequência.

#(reduce(fn[a[f r]](clojure.string/replace a(str f\x)(str r)))%(partition 2"cĉgĝhĥjĵsŝuŭCĈGĜHĤJĴSŜUŬ")) 

Uma redução em relação ao mapa de substituições a procurar e com o que substituí-las.

Ainda trabalhando em uma maneira de compactar o mapa de substituição.

(defn translate [^String esperanto]
  (reduce (fn [acc [f r]] (clojure.string/replace
                            acc ; Replace the translation so far by
                            (str f \x) ; adding a x after each character, search for it in the string,
                            (str r))) ; and replace it with a stringified accented char

          esperanto ; Before the reduction happens, the accumulator is the original string

          ; A list of [char-to-find what-to-replace-with] pairs
          (partition 2"cĉgĝhĥjĵsŝuŭCĈGĜHĤJĴSŜUŬ")))))


0

Scala , 110 bytes

Solução regex chata:

def?(s:String)="(.)x".r.replaceAllIn(s,m=>m.group(0)(0)+(if(m.group(0)(0).toUpper=='U')"\u0306"else"\u0302"))

Solução Scala antiga (116 bytes)

def?(s:String)=s.foldLeft("")((r,c)=>if(c=='x')r.init+r.last+(if(r.last.toUpper=='U')"\u0306"else"\u0302")else r+c)

Ungolfed

def?(s:String)=
  s.foldLeft("")((r,c)=>  // 'Fold' string with empty string as first result
    if(c=='x')            // If current character is x
      r.init+             // Take the every character from result but the last
        r.last+           // The last character from result and add
          (if(r.last.toUpper=='U')
            "\u0306"      // combining breve if 'u' or 'U'
          else"\u0302")   // combining circumflex in any other case
 else r+c                 // Otherwise return result + character
)

0

JavaScript, 35 caracteres, 36 bytes

s=>s.replace(/([cghjsu])x/gi,"$1̂")

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.