Давайте вернемся к основам!

• Ваш код, полная программа или функция, должен преобразовать официальное имя Unicode печатаемого символа Basic Latin в соответствующий символ. Например, для ввода LOW LINEваш код должен выводить _.
• Вам нужно только взять одно имя персонажа в качестве ввода.
• Вы не можете использовать никакую ранее существующую функцию или библиотеку, встроенную или иную, которая предлагает любую логику, относящуюся конкретно к именам символов Unicode (например, Python unicodedata, Java Character.getNameи т. Д.).
• Для ввода, отличного от одного из этих имен, любое поведение приемлемо.

Это код гольфа: выигрывает самый короткий код в байтах.

Чтобы избежать двусмысленности, мы будем использовать полный набор официальных имен персонажей (заимствовано из этого вопроса ):

     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

Машинный код IA-32, 161 160 122 байта

Hexdump кода:

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

Этот код использует хеширование. Путем некоторого перебора я обнаружил, что следующая байтовая функция может быть применена к байтам входной строки:

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

Он умножается xна 89, добавляет следующий байт (ASCII-код) и принимает остаток по модулю 113. Он делает это со всеми байтами входной строки, кроме последней, поэтому, например, LATIN CAPITAL LETTER Aи LATIN CAPITAL LETTER Xдает тот же хэш-код.

Эта хеш-функция не имеет коллизий, и выходной сигнал находится в диапазоне 0 ... 113 (на самом деле, к счастью, диапазон еще более узкий: 3 ... 108).

Хеш-значения всех соответствующих строк не заполняют это пространство полностью, поэтому я решил использовать это для сжатия хеш-таблицы. Я добавил таблицу пропуска (112 бит), которая содержит 0, если соответствующее место в хэш-таблице пусто, и 1 в противном случае. Эта таблица преобразует значение хеш-функции в «сжатый» индекс, который можно использовать для адресации плотного LUT.

Строки LATIN CAPITAL LETTERи LATIN SMALL LETTERдают хэш-коды 52 и 26; они обрабатываются отдельно. Вот код C для этого:

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

Соответствующий код на языке ассемблера (синтаксис встроенной сборки 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;
    }
}

Некоторые заслуживающие внимания детали реализации:

• Он использует CALLинструкцию для получения указателя на код, в котором находится жестко закодированная таблица. В 64-битном режиме он мог бы использовать регистр ripвместо этого.
• Он использует BTинструкцию для доступа к таблице пропуска
• Это удается сделать работу с использованием только 3 регистров eax, ecx, edx, которые могут быть затерты - поэтому нет никакой необходимости сохранять и восстанавливать регистры
• При декодировании хеш-таблицы она использует alи ahосторожно, так что в нужном месте ahуменьшается до 0, и весь eaxрегистр может использоваться как индекс LUT

JavaScript ES6, 228 236 247 257 267 274 287

Примечание: 7 символов сохранены thx @ ev3commander

Примечание 2: лучше, чем JAPT после 7 основных правок,

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

Запустите фрагмент, чтобы проверить

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 байт

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

Каждый ¿представляет непечатаемый символ Unicode. Попробуйте онлайн!

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

Это было действительно весело. Я разделил имена персонажей на несколько больших кусков:

0. Взять первые две буквы

V=Us0,2;устанавливает переменную Vв первые две буквы Uвходной строки. Это пригодится позже.

1. Прописные буквы

Это самое простое: только заглавные буквы имеют символ в позиции 21, и все они являются правильными буквой и регистром. Таким образом, Ug21достаточно.

2. Строчные буквы

Еще один довольно легкий; единственное другое имя, которое имеет символ в позиции 19, - это RIGHT SQUARE BRACKET, поэтому мы проверяем, предшествует ли имя Rс U<'R, затем, если оно ( &&), мы берем 19-й символ с Ug19и переводим его в нижний регистр с v.

3. Цифры

Все эти имена начинаются с DI(и, к счастью, с других), поэтому, если V=="DI"мы можем превратить его в цифру. Первые буквы имен некоторых цифр совпадают, но первых двух букв достаточно. Объединяя их в одну строку, мы получаем ZEONTWTHFOFISISEEINI. Теперь мы можем просто взять индекс bпервых двух символов в имени цифры Us6,8)и разделить на два.

4. SIGN

Есть семь имен, которые содержат SIGN:

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

Сначала мы проверяем, что это имя содержит слово SIGN. Оказывается, GNдостаточно; Uf"GN"возвращает все экземпляры GNв имени, nullесли оно содержит 0 экземпляров, и, таким образом, пропускается.

Теперь, используя ту же технику, что и с цифрами, мы объединяем первые две буквы в строку LEGRPLEQDONUPE , затем берем индекс и делим на два. В результате получается число, из 0-6которого мы можем взять соответствующий символ из строки <>+=$#%.

5. MARK

Есть три символа, которые содержат MARK:

!    EXCLAMATION MARK
"    QUOTATION MARK
?    QUESTION MARK

Здесь мы используем ту же технику, что и с SIGN. Mдостаточно, чтобы отличить эти три от других. Чтобы перевести на символ, на этот раз достаточно проверить одну букву: символ в позиции 2 различен для всех трех символов. Это означает, что нам не нужно делить на два при выборе правильного символа.

6. LEFT/RIGHT

Эта группа содержит скобки и скобки []{}(). Было бы очень сложно захватить как LEFTи RIGHT, но , к счастью, все они содержат строку T . Мы проверяем это той же техникой, что и мы SIGN. Перевести на символ, как сMARK , достаточно проверить одну букву; персонаж в позиции 6 уникален для всех шести.

7. CO

Остальные символы довольно уникальны, но недостаточно уникальны. Три из них начинаются с CO: COMMA, COLONи COMMERCIAL AT. Мы используем точно такую же технику , как мы это делали со скобками, выбирая правильный символ на основе символа в позиции 4 ( A, Nили E).

8. Все остальное

К настоящему времени первые два символа различны для каждого имени. Мы объединяем их все в одну большую строку SPAMAPASHYFUSORESETICIGRLOVEи отображаем каждую пару в соответствующий символ  &'*-./\;~^`_|.

9. Заключительные шаги

Каждая из частей возвращает пустую строку или, nullесли она неправильная, поэтому мы можем связать их все слева направо ||. ||Оператор возвращает левый аргумент , если это truthy и правильный аргумент в противном случае. Japt также имеет неявный вывод, поэтому независимо от результата он автоматически отправляется в поле вывода.

Вопросы, комментарии и предложения приветствуются!

Python 2, 237 байт

Получите хеш строки и по модулю разделите его на 535. Затем преобразуйте его в символ Юникода с этим номером. Позиция символа Юникод в предварительно скомпилированном списке символов Юникод впоследствии преобразуется в символ 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 байт

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

Объяснение:

Эта длинная строка представляет собой сжатый список. a.length.toString(36)+a[0]+a.slice(-3)определяет, как, если это вообще так, строка будет представлена ​​в списке. Также специальная логика для букв. (со строками, a[0]это встроенная стенография для a.charAt(0), кстати)

PowerShell, 603 547 464 байта

$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]

( LineFeedсчитает тот же один байт ;, что я оставлю разрывы для удобства чтения)

_{Редактировать 1 - взял много элементов из оператора switch и вместо этого заполнил хеш-таблицу для поиска.}

_{Редактировать 2 - О да ... индексирование в строку, это путь ...}

По сути, принимает входные данные, разделяет их на пробелы и делает подстановочный знак switchв первом слове, чтобы отфильтровать глупые слова. Устанавливает результат этого в $b. Если $bне существует, строка $cвычисляется по первым трем буквам первого слова и выводит сразу следующий символ, в противном случае мы выводим $b.

Некоторые приемы включают в себя LATIN CAPITAL LETTER Rиндексы which в массив, основанные на том, является ли второе слово CAPITAL, и выводят соответствующую заглавную / строчную букву. Другой «трюк» для DIGITs, путем индексации в хеш-таблицу. Обратите внимание, что здесь не короче тот же трюк «индекс в строку» (на самом деле он длиннее на один байт).

Javascript, 416 411 389 байт

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

Это более читаемый формат (пояснение будет позже):

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

Минус 5 байтов от объединения строк ключа и значения.

Объяснение: Регулярные выражения в первой строке сокращают ввод в уникальные 4-символьные клавиши. Обратите внимание, что уникальность гарантируется только для определенного набора имен, указанных в тесте, и дубликаты будут очень распространены для нормального английского языка! Даже для этой задачи мне пришлось удалить общие слова, такие как скобка и знак, чтобы получить уникальный набор.

Чтобы вернуть символ, я проверяю, является ли это латинским символом, проверяя строки «SER» и «cer», и возвращая последний символ ввода, в нижнем регистре для ser.

Для всего остального я ссылаюсь на строку, которая содержит все 4-символьные клавиши, за которыми следует правильный символ. Затем я использую индексы символов indexof и подстроки, чтобы вытащить и вернуть символ.

Изменить: Использовал больше подстановочных знаков, чтобы уменьшить размер регулярных выражений, заменил substr с индексами символов и сбрил еще двадцать символов. Сторонники правил заметят, что это окончательное обновление публикуется после того, как испытание закончилось, однако я не думаю, что оно изменило мой рейтинг. Это просто практика для новичка.

Python 3, 148 байт

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

Для удобства просмотра я заменил два непечатаемых байта восьмеричными escape-кодами \32и \34; отмените это, чтобы получить функцию 148 байт.

Я вычислил части этой хеш-функции с помощью GPerf .

Perl 6 ,  348   242 байта

{
  /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)
}

использование:

my &code = {...}

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

say code 'HYPHEN-MINUS'; # -