Analizza il mio esperanto!


21

La famosa lingua costruita Esperanto usa l'alfabeto latino (per lo più, vedi la pagina Wikipedia collegata per i dettagli). Tuttavia, ci sono alcuni personaggi con accenti: ĉ, ĝ, ĥ, ĵ, ŝ e ŭ . (C-circumflex, g-circumflex, h-circumflex, j-circumflex, s-circumflex e u- breve .) Naturalmente, questi caratteri sono molto difficili da scrivere. Anche per questa domanda, ho dovuto cercare i caratteri nel selettore Unicode. Per questo motivo, una convenzione che utilizza la lettera "x" è stata sviluppata per uso elettronico. Ad esempio, "cxu" è usato per "ĉu". (Nota: la lettera "x" non è usata normalmente nell'alfabeto esperanto. "

Tuttavia, sono un purista della lingua! Questa * citazione aerea * x assurdità mi sta uccidendo! Ho bisogno di un programma per risolvere questo problema, preferibilmente il più corto possibile in modo da poterlo digitare nel mio terminale il più velocemente possibile!

Sfida

La tua missione è quella di prendere una serie di esperanto usando x-convention e convertirlo in vero esperanto.

In effetti, devi mappare:

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

Tutti gli altri caratteri ASCII stampabili devono essere accettati e non modificati. Unicode sarebbe carino, ma non necessario.

L'input e l'output possono essere in qualsiasi formato ragionevole per la tua lingua. In bocca al lupo!

Casi test

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

punteggio

Questo è . Le risposte sono classificate in base al numero minimo di byte nella codifica predefinita della lingua.

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

Buona fortuna, divertiti e sentiti libero di suggerire miglioramenti!

chiarimenti:

  • Devi solo preoccuparti dei caratteri ASCII stampabili .

  • Devi solo generare un carattere che assomigli all'output corretto. Sì, questo significa che puoi mettere l'accento sul personaggio standard.


ASCII qui significa 20-7E caratteri stampabili, 00-7F o cosa?
user202729

Tutti quelli stampabili.
OldBunny2800,

Nota: ho aggiunto un chiarimento sul fatto che è possibile utilizzare la lettera e l'accento modificatore.
OldBunny2800,

5
La combinazione di circonflesso è a 0302 ̂e la combinazione breve è a 0306 ̆.
user202729

^ Ciascuno accetta 2 byte in UTF8 come conteggio TIO .
user202729

Risposte:


9

QuadR , 65 byte

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

Provalo online!

.x sostituire qualsiasi carattere seguito da "x" con

3::⍵M in caso di errore di indicizzazione, restituisci la corrispondenza non modificata
 ora prova:
'ĉĝĥĵŝŭĈĜĤĴŜŬ'[... ] indicizza in questa stringa con
  ⍵M l'  indice della
   prima lettera della corrispondenza  in questa stringa
  
  'cghjsuCGHJSU'

Ciò equivale alla funzione tacita Dyalog APL:

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

Bella risposta! +1
OldBunny2800,

Non sono sicuro di come vengano contati i byte qui. L'uso diretto di ⎕R non è più breve? ('cghjsuCGHJSU',¨'x')⎕r(,¨'ĉĝĥĵŝŭĈĜĤĴŜŬ')
ngn,

Lo è, ma la mia batteria si è esaurita prima che avessi la possibilità di pubblicarla.
Adám,

6

Retina , 27 byte

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

Provalo online!

Questo programma è composto da due traslitterazioni. A causa della combinazione di caratteri nel codice, ciò non viene riprodotto troppo bene, la prima riga dovrebbe in realtà assomigliare a iT`x`^`[cghjs]x, dove ^sta l'accento circonflesso che combina il carattere. Ciò che sta dicendo è che dovrebbe Triscattare ( icaso gnoring) tutte le xs nell'input in a ^, ogni volta che seguono una lettera in [cghjs].


Nota: TIO misura erroneamente questo codice come 25 byte. In realtà, questo programma Retina utilizza la codifica UTF-8 (altri programmi possono utilizzare UTF-32 o ISO 8859-1) e i due caratteri combinati presenti costano 2 byte ciascuno.


5

C,  173  154 byte

Grazie a @Colera Su per aver salvato 17 byte!

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

Provalo online!

Spiegazione:

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

Bello! Posso avere una spiegazione per favore?
OldBunny2800,

Probabilmente puoi usare il byte null letterale invece di \0?
user202729

(ma purtroppo non funziona su TIO)
user202729

È possibile utilizzare write(1,"..."+i*2,2)per salvare 17 byte. Provalo online!
Colera,

5

Python 3 , 81 byte

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

Provalo online!

Genera e valuta la stringa:

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 the Outgolfer ha salvato un byte.


@EriktheOutgolfer Bello, grazie!
xnor

3

/// , 75 byte

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

Nota: poiché la richiesta OP deve essere elaborata per tutti i caratteri stampabili, i miei "caratteri speciali" scelti non devono essere stampabili. Quindi ho scelto tab e newline invece di, che non cambia la mia funzione bytecount o code. Il codice sarebbe simile a:

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

Tuttavia ciò richiede che l'input non contenga tab o newline.

Provalo online!

Perché /// non è possibile accettare input, è necessario inserire l'input dopo il codice.

Abbastanza diretto. Immagino che non possa essere più breve perché/// necessita di una gestione speciale di ogni personaggio.

Spiegazione:

/,/\/\//       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 byte

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

Provalo online!

-10 byte grazie a WhatToDo
-1 byte grazie a Colera Su



@ user507295 oh idea intelligente. Grazie!
HyperNeutrino,

Usa e-o trucco per salvare un byte: provalo online!
Colera,

@ColeraSu oh fantastico, grazie. non so perché quel trucco sia svanito D:
HyperNeutrino il

@HyperNeutrino Perché non sapevo di quel trucco. Scusate!
Cosa fare il

2

Retina , 55 byte

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

Provalo online! Approccio non combinato. I byte potrebbero essere salvati se non per i xcasi di test autonomi .


1

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

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

Provalo online!


1

JavaScript (ES6), 92 byte

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

Provalo online!

È stato utilizzato il metodo split-join qui consigliato per ridurre il numero di byte poiché il new RegExp(/*blah*/)costruttore ha assorbito troppi byte.

Confronto:

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

Più breve, che combina l'accento accento (63 byte), ma con alcuni artefatti visibili.

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

Nota a piè di pagina: sto rivendicando la mia risposta di 92 byte perché la soluzione a 63 byte presenta artefatti che possono influire sull'output.


1

APL (Dyalog Unicode) , 57 byte

Funzione tacita anonima. usi:

  1. Funzione prefisso su stringa. Questo traduce la stringa.

  2. Funzione prefisso per l'elenco di stringhe. Questo traduce le stringhe.

  3. Aggiunge la funzione con il numero del file di input come argomento destro e il numero del file di output come argomento sinistro. Ciò popola il file di output con il contenuto traslitterato del file di input.

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

(... )⎕R(... ) PCRE R eplace

'cghjsuCGHJSU' queste lettere

,¨'x' ciascuno seguito da una x

 … con…

,¨'ĉĝĥĵŝŭĈĜĤĴŜŬ' ognuna di queste lettere come stringhe

Provalo online!


1

J , 64 63 byte

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

Come funziona:

Con _2]\Riorganizzo la stringa 'ĉĝĥĵŝŭĈĜĤĴŜŬ' in una colonna di 12 righe per adattarla alla forma dell'altra stringa.

,. aggiunge 'x' a ciascun carattere della stringa 'cghjsuCGHJSU' e crea un array di 12 righe per 2 colonne

;~"1' crea un elenco di coppie inscatolate di quanto sopra, "1 - rango 1 - si applica a ciascuna riga.

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

rplc usa questi oggetti in scatola per sostituire ogni occorrenza dell'articolo in scatola a sinistra da una coppia con quella a destra.

Provalo online!


1

Befunge , 2x48 +1 = 99 byte

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

Provalo (TIO è super strano in Befunge e non sono riuscito a far funzionare nessuna delle mie soluzioni)

Come funziona

>~:1+!@_

Ottiene l'input e controlla se è la fine. Termina il programma, se lo è.

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

Verifica se il personaggio è una "x". In caso contrario, conservare una copia del personaggio e stamparlo.

               >$ 11p0"cghjsuCGHJSU"1\

Memorizza l'ultimo carattere in (1,1). Mette tutti i personaggi da controllare in pila.

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

Confronta l'ultimo carattere con tutti i valori nella pila.

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

Moltiplicare il segno di spunta (0 o 1) per ʊ (valore unicode 650). Controlla se il personaggio era au (per il breve) e aggiunge 4 alla pila in tal caso. Infine, aggiungi anche il valore ascii di x (100). Il totale aggiunge l'accento corretto se necessario o solo una "x" in caso contrario.

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

Aggiungi tutti i valori nello stack insieme, stampalo e mantieni un duplicato. Torna indietro per il prossimo input.


1

R , 75 70 byte

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

Provalo online!

-5 byte grazie a Giuseppe

Spiegazione

  • gsub('(u)x','\\1\U306',s,T): sostituisce in sogni caso una "u" maiuscola o minuscola (usando ignore.case=TRUEtramite il quarto argomento T) seguita da una "x", la "u" seguita dall'unicode per un breve
  • gsub('([cghjs])x','\\1\U302',gsub('(u)x','\\1\U306',s,T),T): ne prende il risultato e sostituisce ogni occorrenza di lettere maiuscole o minuscole (usando ignore.case=TRUEtramite il quarto argomento T) "c", "g", "h", "j" o "s" seguito da una "x" con la lettera seguita dall'unicode per un circonflesso

l'utilizzo dell'ordine degli argomenti anziché la denominazione consente di risparmiare 3 byte e altri due eliminano lo zero iniziale \U0302e \U0306: Provalo online!
Giuseppe

@Giuseppe - ottima idea, grazie!
duckmayr,

1

QuadR , 25 byte

Combinazione dell'edizione dei segni diacritici.

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

i bandiera

Provalo online!

Sostituire…

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

maiuscole i nsensitively

Equivalente al seguente codice APL Dyalog:

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

Perché questo è 28 e non 24 byte?
Erik the Outgolfer,

@EriktheOutgolfer Il contatore SBCS di TIO mi ha confuso. Fisso. Grazie. Aspetta, vuol dire che vinco?
Adám,

Eh, ora sembra che siano 27 byte (copiati da TIO), ma 24 byte quando copiati da qui. Qual è la codifica di QuadR e quale è corretta?
Erik the Outgolfer,

@EriktheOutgolfer Entrambi i link riportano 24 sul mio FFQ / Win10. QuadR utilizza Dyalog Classic o qualsiasi Unicode.
Adám,

Quindi sono 24 byte o cosa?
Erik the Outgolfer,

1

C, 145 144 byte

Un altro approccio C. Ritorna sovrascrivendo l'input, usando il fatto che circumflex / breve sono 2 byte.

-1 byte grazie a 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;}

Provalo online!


1
Usando t^1&&memcpy(s-1,"ĉĝĥĵŝŭĈĜĤĴŜŬ"+t,2),t=1;invece di t^1?memcpy(s-1,"ĉĝĥĵŝŭĈĜĤĴŜŬ"+t,2),t=1:0;salva un byte. Provalo online!
Steadybox,

1

Mathematica, 81 byte o 57 byte

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

Applica una regola di sostituzione in cui la lettera senza il cappello insieme a una "x" è sostituita dalla lettera.

Ecco un'alternativa usando il carattere accenti aggiunto: StringReplace[{"ux"->"ŭ","Ux"->"Ŭ",c_~~"x":>c<>"̂"}]


1

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

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

Provalo online!

Salvato 10 byte grazie a Nahuel Fouilleul


potrebbe salvare 7 byte:s/[CGHJScghjs]\Kx/\x{0302}/g;s/[Uu]\Kx/\x{0306}/g
Nahuel Fouilleul,

sembra funzionare anche solo con -Ce senza -Cavviso ( Wide character in print)
Nahuel Fouilleul,

1
da 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

0

CJam , 51 byte

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

Provalo online!

Spiegazione:

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
}

Sono davvero 39 byte? Conto 39 caratteri e non credo che CJam abbia una codifica speciale.
user202729

@ user202729 Changed (TIO ha contato i byte come caratteri per qualche motivo)
Esolanging Fruit

Perché TIO crede che tutte le lingue del golf abbiano una speciale tabella codici e non si preoccupa di controllare se tutti i caratteri sono nella tabella codici corretta.
user202729

0

sed, 108 byte

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

È necessario formattare il codice come codice da `...`o <pre><code>...</code></pre>o 4 trattini.
user202729

@ user202729 Ovviamente lo sapevo. Stavo inviando dal mio telefono Android, quindi non l'ho formattato correttamente.
iBug,

2
Sembra che sia lungo 119 byte.
Erik the Outgolfer,

0

PowerShell, 58 byte

Ha 54 caratteri e salvandolo in PowerShell ISE lo rende UTF-8 + BOM per 58 byte. Non viene riprodotto correttamente in un browser:

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

regex sostituisce la x con la combinazione dei caratteri Unicode dal commento di @utente202729.

per esempio

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

0

Clojure, 126 115 byte

-11 byte modificando la mappa sostitutiva in una partizione di una stringa.

#(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Ŭ")) 

Una riduzione su una mappa di sostituzioni da cercare e con cosa sostituirle.

Sto ancora lavorando su un modo per comprimere la mappa di sostituzione.

(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 byte

Soluzione noiosa di regex:

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

Vecchia soluzione scala (116 byte)

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 caratteri, 36 byte

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

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.