Torniamo alle origini!

• Il codice, un programma o una funzione completi, deve convertire il nome Unicode ufficiale di un carattere latino di base stampabile nel carattere corrispondente. Ad esempio, per l'input LOW LINEdeve essere generato il codice _.
• Devi solo prendere un nome di singolo carattere come input.
• Non è possibile utilizzare alcuna funzione o libreria preesistente, incorporata o meno, che offre qualsiasi logica relativa in modo specifico ai nomi dei caratteri Unicode (ad esempio Python unicodedata, Java Character.getNamee così via).
• Per input diversi da uno di questi nomi, qualsiasi comportamento è accettabile.

Questo è il codice golf: vince il codice più corto in byte.

Per evitare qualsiasi ambiguità, questo è il set completo di nomi di personaggi ufficiali che useremo (preso in prestito da questa domanda ):

     SPACE
!    EXCLAMATION MARK
"    QUOTATION MARK
#    NUMBER SIGN
$    DOLLAR SIGN
%    PERCENT SIGN
&    AMPERSAND
'    APOSTROPHE
(    LEFT PARENTHESIS
)    RIGHT PARENTHESIS
*    ASTERISK
+    PLUS SIGN
,    COMMA
-    HYPHEN-MINUS
.    FULL STOP
/    SOLIDUS
0    DIGIT ZERO
1    DIGIT ONE
2    DIGIT TWO
3    DIGIT THREE
4    DIGIT FOUR
5    DIGIT FIVE
6    DIGIT SIX
7    DIGIT SEVEN
8    DIGIT EIGHT
9    DIGIT NINE
:    COLON
;    SEMICOLON
<    LESS-THAN SIGN
=    EQUALS SIGN
>    GREATER-THAN SIGN
?    QUESTION MARK
@    COMMERCIAL AT
A    LATIN CAPITAL LETTER A
B    LATIN CAPITAL LETTER B
C    LATIN CAPITAL LETTER C
D    LATIN CAPITAL LETTER D
E    LATIN CAPITAL LETTER E
F    LATIN CAPITAL LETTER F
G    LATIN CAPITAL LETTER G
H    LATIN CAPITAL LETTER H
I    LATIN CAPITAL LETTER I
J    LATIN CAPITAL LETTER J
K    LATIN CAPITAL LETTER K
L    LATIN CAPITAL LETTER L
M    LATIN CAPITAL LETTER M
N    LATIN CAPITAL LETTER N
O    LATIN CAPITAL LETTER O
P    LATIN CAPITAL LETTER P
Q    LATIN CAPITAL LETTER Q
R    LATIN CAPITAL LETTER R
S    LATIN CAPITAL LETTER S
T    LATIN CAPITAL LETTER T
U    LATIN CAPITAL LETTER U
V    LATIN CAPITAL LETTER V
W    LATIN CAPITAL LETTER W
X    LATIN CAPITAL LETTER X
Y    LATIN CAPITAL LETTER Y
Z    LATIN CAPITAL LETTER Z
[    LEFT SQUARE BRACKET
\    REVERSE SOLIDUS
]    RIGHT SQUARE BRACKET
^    CIRCUMFLEX ACCENT
_    LOW LINE
`    GRAVE ACCENT
a    LATIN SMALL LETTER A
b    LATIN SMALL LETTER B
c    LATIN SMALL LETTER C
d    LATIN SMALL LETTER D
e    LATIN SMALL LETTER E
f    LATIN SMALL LETTER F
g    LATIN SMALL LETTER G
h    LATIN SMALL LETTER H
i    LATIN SMALL LETTER I
j    LATIN SMALL LETTER J
k    LATIN SMALL LETTER K
l    LATIN SMALL LETTER L
m    LATIN SMALL LETTER M
n    LATIN SMALL LETTER N
o    LATIN SMALL LETTER O
p    LATIN SMALL LETTER P
q    LATIN SMALL LETTER Q
r    LATIN SMALL LETTER R
s    LATIN SMALL LETTER S
t    LATIN SMALL LETTER T
u    LATIN SMALL LETTER U
v    LATIN SMALL LETTER V
w    LATIN SMALL LETTER W
x    LATIN SMALL LETTER X
y    LATIN SMALL LETTER Y
z    LATIN SMALL LETTER Z
{    LEFT CURLY BRACKET
|    VERTICAL LINE
}    RIGHT CURLY BRACKET
~    TILDE

Codice macchina IA-32, 161 160 122 byte

Hexdump del codice:

33 c0 6b c0 59 0f b6 11 03 c2 b2 71 f6 f2 c1 e8
08 41 80 79 01 00 75 ea e8 39 00 00 00 08 2c 5e
4a bd a3 cd c5 90 09 46 04 06 14 40 3e 3d 5b 23
60 5e 3f 2d 31 32 29 25 2e 3c 7e 36 39 34 33 30
21 2f 26 7d 7c 2c 3b 7b 2a 37 5d 22 35 20 3a 28
5c 27 2b 38 5f 24 5a 3c 34 74 17 3c 1a 74 16 33
c9 86 c4 0f a3 0a 14 00 41 fe cc 75 f6 8a 44 02
0e c3 8a 01 c3 8a 01 04 20 c3

Questo codice utilizza alcuni hash. Con alcune ricerche di forza bruta, ho scoperto che la seguente funzione hash può essere applicata ai byte della stringa di input:

int x = 0;
while (s[1])
{
    x = (x * 89 + *s) % 113;
    ++s;
}

Si moltiplica xper 89, aggiunge il byte successivo (codice ASCII) e prende un resto del modulo 113. Lo fa su tutti i byte della stringa di input tranne l'ultimo, quindi ad esempio LATIN CAPITAL LETTER Ae LATIN CAPITAL LETTER Xfornisce lo stesso codice hash.

Questa funzione hash non ha collisioni e l'output è compreso nell'intervallo 0 ... 113 (in realtà, per fortuna, l'intervallo è ancora più ristretto: 3 ... 108).

I valori hash di tutte le stringhe rilevanti non riempiono completamente quello spazio, quindi ho deciso di usarlo per comprimere la tabella hash. Ho aggiunto una tabella "skip" (112 bit), che contiene 0 se il posto corrispondente nella tabella hash è vuoto, e 1 altrimenti. Questa tabella converte un valore di hash in un indice "compresso", che può essere utilizzato per indirizzare un LUT denso.

Le stringhe LATIN CAPITAL LETTERe LATIN SMALL LETTERdanno i codici hash 52 e 26; sono gestiti separatamente. Ecco un codice C per questo:

char find(const char* s)
{
    int hash = 0;
    while (s[1])
    {
        hash = (hash * 89 + *s) % 113;
        ++s;
    }

    if (hash == 52)
        return *s;
    if (hash == 26)
        return *s + 32;

    int result_idx = 0;
    int bit = 0;
    uint32_t skip[] = {0x4a5e2c08, 0xc5cda3bd, 0x04460990, 0x1406};
    do {
        if (skip[bit / 32] & (1 << bit % 32))
            ++result_idx;
        ++bit;
    } while (--hash);

    return "@>=[#`^?-12)%.<~69430!/&}|,;{*7]\"5 :(\\'+8_$"[result_idx];
}

Il codice lingua assembly corrispondente (sintassi dell'assembly inline di MS Visual Studio):

_declspec(naked) char _fastcall find(char* s)
{
    _asm {
        xor eax, eax;
    mycalc:
        imul eax, eax, 89;
        movzx edx, [ecx];
        add eax, edx;
        mov dl, 113;
        div dl;
        shr eax, 8;
        inc ecx;
        cmp byte ptr [ecx + 1], 0;
        jne mycalc;

        call mycont;
        // skip table
        _asm _emit 0x08 _asm _emit 0x2c _asm _emit 0x5e _asm _emit 0x4a;
        _asm _emit 0xbd _asm _emit 0xa3 _asm _emit 0xcd _asm _emit 0xc5;
        _asm _emit 0x90 _asm _emit 0x09 _asm _emit 0x46 _asm _emit 0x04;
        _asm _emit 0x06 _asm _emit 0x14;
        // char table
        _asm _emit '@' _asm _emit '>' _asm _emit '=' _asm _emit '[';
        _asm _emit '#' _asm _emit '`' _asm _emit '^' _asm _emit '?';
        _asm _emit '-' _asm _emit '1' _asm _emit '2' _asm _emit ')';
        _asm _emit '%' _asm _emit '.' _asm _emit '<' _asm _emit '~';
        _asm _emit '6' _asm _emit '9' _asm _emit '4' _asm _emit '3';
        _asm _emit '0' _asm _emit '!' _asm _emit '/' _asm _emit '&';
        _asm _emit '}' _asm _emit '|' _asm _emit ',' _asm _emit ';';
        _asm _emit '{' _asm _emit '*' _asm _emit '7' _asm _emit ']';
        _asm _emit '"' _asm _emit '5' _asm _emit ' ' _asm _emit ':';
        _asm _emit '(' _asm _emit '\\' _asm _emit '\'' _asm _emit '+';
        _asm _emit '8' _asm _emit '_' _asm _emit '$';

    mycont:
        pop edx;
        cmp al, 52;
        je capital_letter;
        cmp al, 26;
        je small_letter;

        xor ecx, ecx;
        xchg al, ah;
    decode_hash_table:
        bt [edx], ecx;
        adc al, 0;
        inc ecx;
        dec ah;
        jnz decode_hash_table;

        mov al, [edx + eax + 14];
        ret;

    capital_letter:
        mov al, [ecx];
        ret;

    small_letter:
        mov al, [ecx];
        add al, 32;
        ret;
    }
}

Alcuni dettagli di implementazione degni di nota:

• Utilizza CALLun'istruzione per ottenere un puntatore al codice, dove risiede la tabella hardcoded. In modalità 64 bit, potrebbe invece utilizzare il registro rip.
• Usa il BT istruzioni per accedere alla tabella di salto
• Riesce a fare il lavoro utilizzando solo 3 registri eax, ecx, edx, che può essere colpita - quindi non c'è alcuna necessità di salvare e ripristinare i registri
• Quando decodifica la tabella hash, la utilizza ale ahcon attenzione, in modo che al posto giusto ahvenga ridotta a 0 e l'intero eaxregistro possa essere utilizzato come indice LUT

JavaScript ES6, 228 236 247 257 267 274 287

Nota: 7 caratteri salvati thx @ ev3commander

Nota 2: meglio di JAPT dopo 7 modifiche principali,

n=>n<'L'?"XC!DO$MP&OS'SK*N--FU.ZE0TW2HR3OU4FI5IX6EI8NI9EM;LS=R->IA@MF^AV`MM,NE1EN7LO:".replace(/(..)./g,(c,s)=>~n.search(s)?n=c[2]:0)&&n:'~  / ;  |?"\\ ) }]_+ #% < ( {['[(n<'Q')*13+n.length-(n>'T')-4]||n[21]||n[19].toLowerCase()

Esegui lo snippet per testare

F=n=>
  n<'L'?"XC!DO$MP&OS'SK*N--FU.ZE0TW2HR3OU4FI5IX6EI8NI9EM;LS=R->IA@MF^AV`MM,NE1EN7LO:"
  .replace(/(..)./g,(c,s)=>~n.search(s)?n=c[2]:0)&&n:
  '~  / ;  |?"\\ ) }]_+ #% < ( {['[(n<'Q')*13+n.length-(n>'T')-4]
  ||n[21]||n[19].toLowerCase()

//TEST
console.log=x=>O.innerHTML+=x+'\n'
;[
['&','AMPERSAND'],
['\'','APOSTROPHE'],
['*','ASTERISK'],
['^','CIRCUMFLEX ACCENT'],
[':','COLON'],
[',','COMMA'],
['@','COMMERCIAL AT'],
['8','DIGIT EIGHT'],
['5','DIGIT FIVE'],
['4','DIGIT FOUR'],
['9','DIGIT NINE'],
['1','DIGIT ONE'],
['7','DIGIT SEVEN'],
['6','DIGIT SIX'],
['3','DIGIT THREE'],
['2','DIGIT TWO'],
['0','DIGIT ZERO'],
['$','DOLLAR SIGN'],
['=','EQUALS SIGN'],
['!','EXCLAMATION MARK'],
['.','FULL STOP'],
['`','GRAVE ACCENT'],
['>','GREATER-THAN SIGN'],
['-','HYPHEN-MINUS'],
['A','LATIN CAPITAL LETTER A'],
['B','LATIN CAPITAL LETTER B'],
['C','LATIN CAPITAL LETTER C'],
['D','LATIN CAPITAL LETTER D'],
['E','LATIN CAPITAL LETTER E'],
['F','LATIN CAPITAL LETTER F'],
['G','LATIN CAPITAL LETTER G'],
['H','LATIN CAPITAL LETTER H'],
['I','LATIN CAPITAL LETTER I'],
['J','LATIN CAPITAL LETTER J'],
['K','LATIN CAPITAL LETTER K'],
['L','LATIN CAPITAL LETTER L'],
['M','LATIN CAPITAL LETTER M'],
['N','LATIN CAPITAL LETTER N'],
['O','LATIN CAPITAL LETTER O'],
['P','LATIN CAPITAL LETTER P'],
['Q','LATIN CAPITAL LETTER Q'],
['R','LATIN CAPITAL LETTER R'],
['S','LATIN CAPITAL LETTER S'],
['T','LATIN CAPITAL LETTER T'],
['U','LATIN CAPITAL LETTER U'],
['V','LATIN CAPITAL LETTER V'],
['W','LATIN CAPITAL LETTER W'],
['X','LATIN CAPITAL LETTER X'],
['Y','LATIN CAPITAL LETTER Y'],
['Z','LATIN CAPITAL LETTER Z'],
['a','LATIN SMALL LETTER A'],
['b','LATIN SMALL LETTER B'],
['c','LATIN SMALL LETTER C'],
['d','LATIN SMALL LETTER D'],
['e','LATIN SMALL LETTER E'],
['f','LATIN SMALL LETTER F'],
['g','LATIN SMALL LETTER G'],
['h','LATIN SMALL LETTER H'],
['i','LATIN SMALL LETTER I'],
['j','LATIN SMALL LETTER J'],
['k','LATIN SMALL LETTER K'],
['l','LATIN SMALL LETTER L'],
['m','LATIN SMALL LETTER M'],
['n','LATIN SMALL LETTER N'],
['o','LATIN SMALL LETTER O'],
['p','LATIN SMALL LETTER P'],
['q','LATIN SMALL LETTER Q'],
['r','LATIN SMALL LETTER R'],
['s','LATIN SMALL LETTER S'],
['t','LATIN SMALL LETTER T'],
['u','LATIN SMALL LETTER U'],
['v','LATIN SMALL LETTER V'],
['w','LATIN SMALL LETTER W'],
['x','LATIN SMALL LETTER X'],
['y','LATIN SMALL LETTER Y'],
['z','LATIN SMALL LETTER Z'],
['{','LEFT CURLY BRACKET'],
['(','LEFT PARENTHESIS'],
['[','LEFT SQUARE BRACKET'],
['<','LESS-THAN SIGN'],
['_','LOW LINE'],
['#','NUMBER SIGN'],
['%','PERCENT SIGN'],
['+','PLUS SIGN'],
['?','QUESTION MARK'],
['"','QUOTATION MARK'],
['\\','REVERSE SOLIDUS'],
['}','RIGHT CURLY BRACKET'],
[')','RIGHT PARENTHESIS'],
[']','RIGHT SQUARE BRACKET'],
[';','SEMICOLON'],
['/','SOLIDUS'],
[' ','SPACE'],
['~','TILDE'],
['|','VERTICAL LINE'],
].forEach(t=>{
  var r=F(t[1]),ok=r==t[0]
  //if (!ok) // uncomment to see just errors
  console.log(r+' ('+t[0]+') '+t[1]+(ok?' OK':' ERROR'))
})
console.log('DONE')

<pre id=O></pre>

Japt , 230 byte

V=U¯2;Ug21 ªU<'R©Ug19 v ªV¥"DI"©`ze¿twâ¿¿¿¿e¿i`u bUs6,8)/2ªUf"GN" ©"<>+=$#%"g`¤grp¤qºnupe`u bV /2 ªUf"T " ©"[]\{}()"g"QSUCAP"bUg6) ªUf" M" ©"!\"?"g"COE"bUg2) ªV¥"CO"©",:@"g"ANE"bUg4) ª" &'*-./\\;~^`_|"g`spaµp¿豢¿Èögrlove`u bV /2

Ciascuno ¿rappresenta un carattere Unicode non stampabile. Provalo online!

Ungolfed:

V=Us0,2;Ug21 ||U<'R&&Ug19 v ||V=="DI"&&"zeontwthfofisiseeini"u bUs6,8)/2||Uf"GN" &&"<>+=$#%"g"legrpleqdonupe"u bV /2 ||Uf"T " &&"[]\{}()"g"QSUCAP"bUg6) ||Uf" M" &&"!\"?"g"COE"bUg2) ||V=="CO"&&",:@"g"ANE"bUg4) ||" &'*-./\\;~^`_|"g"spamapashyfusoreseticigrlove"u bV /2

È stato davvero divertente. Ho diviso i nomi dei personaggi in diversi grossi pezzi:

0. Prendi le prime due lettere

V=Us0,2;imposta variabile Valle prime due lettere diU stringa di input. Questo tornerà utile in seguito.

1. Lettere maiuscole

Questa è la più semplice: le lettere maiuscole sono le uniche che hanno un carattere nella posizione 21, che sono tutte la lettera e il caso corretti. Pertanto, Ug21è sufficiente.

2. Lettere minuscole

Un altro abbastanza facile; l'unico altro nome che ha un carattere in posizione 19 è RIGHT SQUARE BRACKET, quindi controlliamo se il nome viene prima Rcon U<'R, quindi se è ( &&), prendiamo il 19 ° carattere con Ug19e lo lanciamo in minuscolo con v.

3. Cifre

Tutti questi nomi iniziano con DI(e fortunatamente nessuno degli altri), quindi se V=="DI"possiamo trasformarlo in una cifra. Le prime lettere di alcuni nomi delle cifre sono uguali, ma le prime due lettere sono sufficienti. Combinando questi in una stringa, otteniamo ZEONTWTHFOFISISEEINI. Ora possiamo semplicemente prendere l'indice bdei primi due caratteri nel nome della cifra Us6,8)e dividerlo per due.

4. SIGN

Esistono sette nomi che contengono SIGN:

<    LESS-THAN SIGN
>    GREATER-THAN SIGN
+    PLUS SIGN
=    EQUALS SIGN
$    DOLLAR SIGN
#    NUMBER SIGN
%    PERCENT SIGN

Per prima cosa controlliamo che il nome contenga la parola SIGN. Si scopre che GNè sufficiente; Uf"GN"restituisce tutte le istanze di GNnel nome, ovvero nullse contiene 0 istanze e quindi viene saltato.

Ora, usando la stessa tecnica delle cifre, combiniamo le prime due lettere in una stringa LEGRPLEQDONUPE, quindi prendiamo l'indice e dividiamo per due. Ciò risulta da un numero 0-6, che possiamo usare per prendere il carattere corrispondente dalla stringa <>+=$#%.

5. MARK

Esistono tre caratteri che contengono MARK:

!    EXCLAMATION MARK
"    QUOTATION MARK
?    QUESTION MARK

Qui usiamo la stessa tecnica di SIGN.  Mè sufficiente differenziare questi tre dagli altri. Per tradurre in un simbolo, questa volta è sufficiente controllare una lettera: il carattere nella posizione 2 è diverso per tutti e tre i caratteri. Questo significa che non dobbiamo dividere per due quando si sceglie il personaggio corretto.

6. LEFT/RIGHT

Questo gruppo contiene le parentesi e le parentesi, []{}(). Sarebbe davvero complicato catturare entrambi LEFTe RIGHT, per fortuna, contengono tutti la stringa T . Lo controlliamo con la stessa tecnica che abbiamo fatto con SIGN. Per tradurre in un simbolo, come con MARK, è sufficiente controllare una lettera; il personaggio in posizione 6 è unico per tutti e sei.

7. CO

Il resto dei caratteri è piuttosto unico, ma non abbastanza unico. Tre di loro cominciano con CO: COMMA, COLON, e COMMERCIAL AT. Usiamo esattamente la stessa tecnica come abbiamo fatto con le staffe, scegliendo il simbolo corretto basato sul personaggio in posizione 4 ( A, N, o E).

8. Tutto il resto

Ormai, i primi due personaggi sono diversi per ogni nome. Li combiniamo tutti in una grande stringa SPAMAPASHYFUSORESETICIGRLOVEe mappiamo ogni coppia al suo carattere corrispondente  &'*-./\;~^`_|.

9. Passaggi finali

Ciascuna delle parti restituisce una stringa vuota o nullse non è quella corretta, quindi possiamo collegarli tutti da sinistra a destra ||. L' ||operatore restituisce l'argomento sinistro se è vero, e l'argomento giusto altrimenti. Japt ha anche un output implicito, quindi qualunque sia il risultato, viene automaticamente inviato alla casella di output.

Domande, commenti e suggerimenti benvenuti!

Python 2, 237 byte

Ottieni l'hash della stringa e il modulo lo divide per 535. Successivamente convertilo in un carattere unicode con quel numero. La posizione del carattere Unicode in un elenco precompilato di caratteri Unicode viene successivamente convertita nel carattere ASCII.

print chr(u"""ǶŀȎdȊÏöǖIhȏƜǓDZǠƣƚdžƩC+ĶÅĠěóƋŎªƱijůŰűŪūŬŭŶŷŸŹŲųŴŵžſƀƁźŻżŽƆƇƈŖÐŗǀǼǿǾǹǸǻǺȅȄȇȆȁȀȃȂǭǬǯǮǩǨǫǪǵǴǷNȌ~B""".index(unichr(hash(raw_input())%535))+32)

Javascript, 501 499 469 465 451 430 byte

a=prompt();c="5SACEgEARKeQARKbNIGNbDIGNcPIGN9AANDaAPHEgLSIShRSIS8AISK9PIGN5CMMAcHNUS9FTOP7SDUSaDERO9DONE9DTWObDREEaDOURaDIVE9DSIXbDVENbDGHTaDINE5CLON9SLONeLIGNbEIGNhGIGNdQARKdC ATjLKETfRDUSkRKEThCENT8LINEcGENTiLKETdVINEjRKET5TLDE".match(/.{5}/g).indexOf(a.length.toString(36)+a[0]+a.slice(-3));if(c>=33)c+=26;if(c>=65)c+=26;alert(a.length==20&&a[0]=="L"?a.slice(-1).toLowerCase():a.length>21?a.slice(-1):String.fromCharCode(32+c))

Spiegazione:

Quella stringa lunga è un elenco compresso. a.length.toString(36)+a[0]+a.slice(-3)determina come, se del caso, la stringa verrà rappresentata nell'elenco. Inoltre, logica speciale per le lettere. (con le stringhe, a[0]è una scorciatoia incorporata per a.charAt(0), a proposito)

PowerShell, 603 547 464 byte

$a=-split$args
$b=switch -W($a[0]){
"LEFT"{switch -w($a[1]){"C*"{"{"}"P*"{"("}"S*"{"["}}}
"RI*"{switch -w($a[1]){"C*"{"}"}"P*"{")"}"S*"{"]"}}}
"LA*"{("$($a[3])".ToLower(),$a[3])[$a[1]-like"C*"]}
"DI*"{@{ONE=1;TWO=2;THREE=3;FOUR=4;FIVE=5;SIX=6;SEVEN=7;EIGHT=8;NINE=9;ZERO="0"}[$a[1]]}
"COMME*"{"@"}
"APO*"{"'"}
}
$c='COM,LES<GRA`GRE>QUE?QUO"COL:REV\LOW_EXC!EQU=DOL$AMP&AST*PER%PLU+SEM;SOL/SPA CIR^HYP-FUL.NUM#TIL~VER|'
($b,$c[$c.IndexOf($a[0][0..2]-join'')+3])[!$b]

( LineFeedconta lo stesso byte di ;, quindi lascerò le pause per leggibilità)

_{Modifica 1: ha estratto molti elementi dall'istruzione switch e ha invece popolato una tabella hash per le ricerche.}

_{Modifica 2 - Oh sì ... indicizzazione in una stringa, questa è la strada da percorrere ...}

Prende essenzialmente l'input, lo divide in spazi e fa un jolly switchsulla prima parola per filtrare quelli sciocchi. Imposta il risultato su quello $b. Se $bnon esiste, la stringa $cviene valutata sulle prime tre lettere della prima parola e restituisce il carattere immediatamente successivo, altrimenti viene emesso $b.

Alcuni trucchi includono gli LATIN CAPITAL LETTER Rindici che si indicano in un array in base alla seconda parola CAPITALe restituiscono la corrispondente lettera maiuscola / minuscola. L'altro "trucco" è per la DIGITs, indicizzando in una tabella hash. Si noti che non è più breve fare lo stesso trucco index-in-a-string qui (in realtà è più lungo di un byte).

Javascript, 416 411 389 byte

l=(E)=>{return E=E.replace(/LA.*N|BR.*T|SIGN|MARK| |TION/g,"").replace(/(.).*(.{3})/,"$1$2"),E.match("CER")?E[3]:E.match("SER")?E[3].toLowerCase():(a="SACE EAMA!QOTA\"NBER#DLAR$PENT%AAND&APHE'AISK*PLUS+CMMA,HNUS-FTOP.SDUS/CLON:SLON;LHAN<EALS=GHAN>QUES?CLAT@RDUS\\CENT^LINE_GENT`VINE|LSIS(RSIS)LARE[RARE]LRLY{RRLY}TLDE~DERO0DONE1DTWO2DREE3DOUR4DIVE5DSIX6DVEN7DGHT8DINE9",a[a.indexOf(E)+4])}

Questo è un formato più leggibile (spiegazione che verrà dopo):

function l(k){
    k=k.replace(/LA.*N|BR.*T|SIGN|MARK| |TION/g,'').replace(/(.).*(.{3})/,'$1$2')
    if(k.match('CER')) return k[3];
    if(k.match('SER')) return k[3].toLowerCase();
    a="SACE EAMA!QOTA\"NBER#DLAR$PENT%AAND&APHE'AISK*PLUS+CMMA,HNUS-FTOP.SDUS/CLON:SLON;LHAN<EALS=GHAN>QUES?CLAT@RDUS\\CENT^LINE_GENT`VINE|LSIS(RSIS)LARE[RARE]LRLY{RRLY}TLDE~DERO0DONE1DTWO2DREE3DOUR4DIVE5DSIX6DVEN7DGHT8DINE9"
    return a[a.indexOf(k)+4];
}

Meno 5 byte dalla combinazione di stringhe chiave e valore.

Spiegazione: Le espressioni regolari sulla prima riga riducono gli input in chiavi a 4 caratteri univoche. Nota che l'unicità è garantita solo per l'insieme specifico di nomi specificato nella sfida e i duplicati sarebbero molto comuni per l'inglese normale! Anche per questa sfida, ho dovuto rimuovere parole comuni come parentesi e segno per ottenere un set unico.

Per restituire il personaggio, controllo se si tratta di un carattere latino controllando le stringhe "SER" e "cer" e restituendo l'ultimo carattere dell'input, in minuscolo per ser.

Per tutto il resto, mi riferisco a una stringa che contiene tutte e 4 le chiavi dei caratteri, seguite dal carattere corretto. Quindi uso indexof e indici dei caratteri sottostringa per estrarre e restituire il personaggio.

Modifica: ha usato più caratteri jolly per ridurre la dimensione del regex, ha sostituito il substrato con gli indici dei caratteri e si è rasato altri venti caratteri. Gli stickler delle regole noteranno che questo aggiornamento finale viene pubblicato dopo che la sfida è terminata, tuttavia non credo che abbia cambiato la mia classifica. Questa è solo una pratica per un principiante.

Python 3, 148 byte

lambda s:chr(83-b'gfhtg\32}urgx_}3qeo|e~cwu~S~q~I,vqG\34jc}d*9~~_L|p~~~~~JJy'[sum(b'  !" *1! "2;D$# ! # !!( '[ord(c)%25]-32for c in s[:-1])]+ord(s[-1]))

Per comodità di visualizzazione, ho sostituito due byte non stampabili con i codici di escape ottali \32e \34; annullare questa operazione per ottenere la funzione 148 byte.

Ho calcolato parti di questa funzione hash con GPerf .

Perl 6 ,  348   242 byte

{
  /NI/??9!!chr 32+
  '0A40W00SV0M20LR0O20IJ0LH0WH0YS0H20ID0A50P10IH0F70K10HF0I30LL0JX0JF0HX0LU0LE0JF0AJ0IX0RK0M40XF0QR0PD15Z16016116216316416516616716816916A16B16C16D16E16F16G16H16I16J16K16L16M16N16O1140V313F0XS0FU0N712A12B12C12D12E12F12G12H12I12J12K12L12M12N12O12P12Q12R12S12T12U12V12W12X12Y12Z0ZA0PU11L0AA'
  .comb(3).map({:36($_)}).first(:k,[+] .ords)
} # 348

{chr 32+"\x95ǐǠŬšƉĘŗȌȴĎĽ\x96ŖŁöģěĈśŊčĂĹŔĸ¤ĦƱŮȃƿƍʶʷʸʹʺʻʼʽʾʿˀˁ˂˃˄˅ˆˇˈˉˊʠʡʢʣʤɝǚʅǥâĿʇʈʉʊʋʌʍʎʏʐʑʒʓʔʕʖʗʘʙʚʛɱɲɳɴɵțųɃ\x9b".ords.first: :k,[+] .ords.map(*%43)}

{
  chr 32+
  "\x95ǐǠŬšƉĘŗȌȴĎĽ\x96ŖŁöģěĈśŊčĂĹŔĸ¤ĦƱŮȃƿƍʶʷʸʹʺʻʼʽʾʿˀˁ˂˃˄˅ˆˇˈˉˊʠʡʢʣʤɝǚʅǥâĿʇʈʉʊʋʌʍʎʏʐʑʒʓʔʕʖʗʘʙʚʛɱɲɳɴɵțųɃ\x9b"
  .ords.first: :k,[+] .ords.map(*%43)
}

utilizzo:

my &code = {...}

# testing
my $test = [~] (' '..'~')».uniname».&code;
my $comparison = [~] ' '..'~';
say $test eq $comparison; # True

say code 'HYPHEN-MINUS'; # -