L'obiettivo è davvero semplice. Ricevendo una stringa come input, analizza tutte le entità HTML che corrispondono ai seguenti caratteri (incluse le loro varianti maiuscole):

áàãâäéèêëíìîïóòõôöúùûüýÿ

Regole di analisi:

• Ogni entità inizia con &e termina con;
• Il primo carattere dopo il &sarà il carattere modificato (il maiuscolo è importante!)
• I caratteri rimanenti si riferiscono al nome l'accento da utilizzare ( acute, grave, circ, tildee uml). Il nome dell'accento DEVE essere in minuscolo! *
• Qualsiasi entità HTML che produce un carattere che non è su quella lista, o che non è valido, deve essere lasciato intatto (Ad esempio: &, &etilde;, &a;)
• Le entità numeriche dovrebbero essere ignorate, poiché non rientrano nelle regole sopra

_{Questa modifica è stata introdotta dal 18-02-2016. Sono valide tutte le risposte esistenti che accettano entità HTML con nomi di accento maiuscoli. Ogni risposta futura deve seguire questa regola.}

Esempi:

á //á
Téhèh //Téhèh
an & //an &

Produzione:

L'output può essere in ISO-8859- X (1-15), windows-1252 o UTF-8/16/32.
Puoi scegliere una e solo una delle codifiche valide e usarla per qualsiasi output. Puoi tranquillamente supporre che l'ingresso sarà in ASCII.

Uno dei seguenti è un output valido per á:

• á(ISO-8859-1 / 15 o windows-1252, equivalente a \xE1)
• á(UTF-8, equivalente a \xC3\xA1o \u00E1)
• aÌ(UTF-8, equivalente a a\xCC\x81o a\u0301)
• Qualsiasi combinazione di segni diacritici, senza usare entità HTML.

L'output deve essere visivamente simile, quando visualizzato / visualizzato, ai caratteri nell'elenco.

Ricorda che non sono consentite tutte le scappatoie standard e gli incorporati * . Poiché si tratta di code-golf , vince la risposta più breve.

_{* Questa modifica è stata apportata a causa della grande disapprovazione di bonus e penalità e, al momento della redazione, non invalida alcuna risposta}

Japt, 81 75 byte

Ur`&([%vYy](ac©e|uml)|%v(g?ve|circ)|[AaOo]Èìe);`@Yg +'Ì+"?????"g"gutca"bYgJ

Le sei ?s rappresentano caratteri non stampabili. Provalo online!

Nota: questo genera la terza opzione di codifica; cioè, la lettera seguita dalla codifica UTF-8 grezza del corrispondente segno diacritico di combinazione.

Come funziona

Ur"&(    );"       // Replace each ampersand and semicolon that have one of these between them:
([%vYy](acute|uml) //  A vowel or Yy followed by "acute" or "uml",
|%v(grave|circ)    //  or a vowel followed by "grave" or "circ",
|[AaOo]tilde       //  or "a" or "o" followed by "tilde";
@                  // replace each match X and its middle Y with this function:
""g"gutca"bYgJ     //  Take the unprintable at index (index of the second char in Y in "gutca") in this string.
Yg +'Ì+            //  Concatenate the first char in Y and "Ì" to the beginning.
                   // Implicit output

Hexdump del codice:

00000000: 55 72 60 26 28 5b 25 76 59 79 5d 28 61 63 a9 65  Ur`&([%vYy](ac©e
00000010: 7c 75 6d 6c 29 7c 25 76 28 67 9f 76 65 7c 63 69  |uml)|%v(g.ve|ci
00000020: 72 63 29 7c 5b 41 61 4f 6f 5d c8 ec 65 29 3b 60  rc)|[AaOo]Èìe);`
00000030: 40 59 67 20 2b 27 cc 2b 22 80 81 82 83 88 22 67  @Yg +'Ì+"....."g
00000040: 22 67 75 74 63 61 22 62 59 67 4a                 "gutca"bYgJ

JavaScript (ES6), 141 122 134 byte

a=>a.replace(/&([aeiouyAEIOUY](acute|uml)|[aeiouAEIOU](grave|circ)|[aoAO]tilde);/g,b=>b[1]+{g:"̀",a:"́",c:"̂",t:"̃",u:"̈"}[b[2]])

Ho seguito l'esempio di Daavko usando segni diacritici e mi sento un idiota per non aver pensato di usarlo prima. In realtà diventa sorprendentemente breve per JavaScript.

EDIT: Neil ha riscontrato alcuni casi negativi di non definito, che ora sono stati risolti.

Retina , 115 byte

Sono nuovo di code-golf, ma penso che potrebbe funzionare.
Questa versione è stata creata prima dell'introduzione della regola, che non consente la sostituzione di entità html maiuscole (ad esempio Á).

i`&([aeiouy])acute;
$1́
i`&([aeiou])grave;
$1̀
i`&([ao])tilde;
$1̃
i`&([aeiou])circ;
$1̂
i`&([aeiouy])uml;
$1̈

Ricerca e sostituzione abbastanza semplici. Utilizza UTF-8.

Utilizza l'approccio [lettera] \ xCC \ x [codice esadecimale del segno diacritico]. Il segno diacritico viene aggiunto dopo ogni lettera pertinente.

Per qualche motivo, il carattere predefinito Droid Sans Mono nell'interprete non può rendere correttamente le lettere "circ" e "uml". Se lo cambi tramite strumenti di sviluppo in qualcosa come DejaVu Sans, si vede bene. Penso che questa sia una limitazione del carattere, non del programma. Ma se è colpa del programma, proverò a risolverlo.

Ecco una versione da 129 byte, che non sostituisce le entità HTML maiuscole (ad esempio Á)

&([aeiouyAEIOUY])acute;
$1́
&([aeiouAEIOU])grave;
$1̀
&([aoAO])tilde;
$1̃
&([aeiouAEIOU])circ;
$1̂
&([aeiouyAEIOUY])uml;
$1̈

Provalo online!
Provalo online! Versione a 129 byte

JavaScript (ES6), 288 byte

a=>(z=(b,c=1,d=2,e=3,f=0,g=4)=>({b:b+191,grave:c,acute:d,circ:e,tilde:f,uml:g}),y={a:z(0,1,2,3,4,5),e:z(8),i:z(12),o:z(18,1,2,3,4,5),u:z(25),y:z(28,0,2,0)},a.replace(/&\w+;/gi,b=>(x=y[b[1].toLowerCase()])&&(w=x[b.slice(2,-1)])?String.fromCharCode(x.b+w+32*(b[1]>'_')+153*/Yu/.test(b)):b))

Crea un oggetto mappa caratteri (con il codice numerico di base per ciascun carattere) e utilizza gli offset (o 0 se inesistente) per determinare se un'entità deve essere convertita e qual è il suo codice carattere. La simmetria nei casi significa l'aggiunta di 32 se minuscole, ad eccezione di Ÿ, dove utilizza un offset diverso per UTF8.