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 é o código-golf . 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

Mostrar snippet de código

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.

code-golf string parsing natural-language unicode OldBunny2800
fonte
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]}
Adão
fonte
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.

Leo
fonte
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);
}
Steadybox
fonte
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.

xnor
fonte
@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.
user202729
fonte
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

HyperNeutrino
fonte
96 bytes Experimente online!
WhatToDo
@ 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 .

Neil
fonte
1

Perl 5 , 101 + 1 ( -p) = 102 bytes

%k=qw/c ĉ g ĝ h ĥ j ĵ s ŝ u ŭ C Ĉ G Ĝ H Ĥ J Ĵ S Ŝ U Ŭ/;$"=join"|",keys%k;s/($")x/$k{$1}/g

Experimente online!

Xcali
fonte
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.

Shieru Asakoto
fonte
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!

Adão
fonte
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!

Galen Ivanov
fonte
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.

Brincadeira
fonte
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
duckmayr
fonte
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'
Adão
fonte
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!

Colera Su
fonte
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<>"̂"}]

M. Stern
fonte
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

DarkHeart
fonte
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
}
Esolanging Fruit
fonte
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
iBug
fonte
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ŭ.
TessellatingHeckler
fonte
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Ŭ")))))
Carcinigenicado
fonte
0

JavaScript (ES6), 91 bytes

(i,s='cĉgĝhĥjĵsŝuŭCĈGĜHĤJĴSŜUŬ')=>i.replace(/.x/g,m=>s[1+s.search(m[0])||s]||m)

Experimente online!

Patrick Stephansen
fonte
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
)
AmazingDreams
fonte
0

JavaScript, 35 caracteres, 36 bytes

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