Wróćmy do podstaw!

• Twój kod, kompletny program lub funkcja, musi przekonwertować oficjalną nazwę Unicode drukowalnego podstawowego znaku łacińskiego na odpowiedni znak. Na przykład dla danych wejściowych LOW LINEkod musi zostać wygenerowany _.
• Musisz tylko wpisać jedną nazwę postaci jako dane wejściowe.
• Nie można korzystać z żadnej istniejącej funkcji lub biblioteki, wbudowanej lub innej, która oferuje logikę związaną konkretnie z nazwami znaków Unicode (np. Python unicodedata, Java Character.getNameitp.)
• W przypadku danych wejściowych innych niż jedna z tych nazw każde zachowanie jest dopuszczalne.

To jest kod golfowy: wygrywa najkrótszy kod w bajtach.

Aby uniknąć dwuznaczności, jest to pełny zestaw oficjalnych nazw postaci, których będziemy używać (zapożyczone z tego pytania ):

     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

Kod maszynowy IA-32, 161 160 122 bajtów

Hexdump kodu:

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

Ten kod używa haszowania. W wyniku wyszukiwania metodą brute-force odkryłem, że do bajtów ciągu wejściowego można zastosować następującą funkcję skrótu:

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

To mnoży xprzez 89, dodaje następny bajt (kod ASCII), a pozostałą zajmuje modulo 113. Czyni to na wszystkich bajtów ciągu wejściowego, z wyjątkiem ostatniej, więc np LATIN CAPITAL LETTER Ai LATIN CAPITAL LETTER Xpodać ten sam kod skrótu.

Ta funkcja skrótu nie powoduje kolizji, a dane wyjściowe mieszczą się w zakresie 0 ... 113 (na szczęście zakres jest jeszcze węższy: 3 ... 108).

Wartości skrótów wszystkich odpowiednich ciągów nie wypełniają tego miejsca całkowicie, więc postanowiłem użyć tego do skompresowania tabeli skrótów. Dodałem tabelę „pomiń” (112 bitów), która zawiera 0, jeśli odpowiednie miejsce w tablicy skrótów jest puste, i 1 w przeciwnym razie. Ta tabela przekształca wartość skrótu w „skompresowany” indeks, którego można użyć do rozwiązania gęstej LUT.

Ciągi znaków LATIN CAPITAL LETTERi LATIN SMALL LETTERdają kody skrótu 52 i 26; są obsługiwane osobno. Oto kod 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];
}

Odpowiedni kod języka asemblera (składnia wbudowana w 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;
    }
}

Kilka ważnych szczegółów implementacji:

• Używa CALLinstrukcji, aby uzyskać wskaźnik do kodu, w którym znajduje się tabela zakodowana na stałe. W trybie 64-bitowym ripzamiast tego mógłby użyć rejestru .
• Używa BTinstrukcji, aby uzyskać dostęp do tabeli pomijania
• To udaje się do pracy przy użyciu tylko 3 rejestrów eax, ecx, edx, który może być niszczona - więc nie ma potrzeby, aby zapisać i przywrócić rejestrów
• Podczas dekodowania tabeli skrótów używa ali ahostrożnie, aby w odpowiednim miejscu ahzmniejszyć do 0, a cały eaxrejestr można wykorzystać jako indeks LUT

JavaScript ES6, 228 236 247 257 267 274 287

Uwaga: zapisano 7 znaków przez thx @ ev3commander

Uwaga 2: lepszy niż JAPT po 7 głównych zmianach,

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

Uruchom fragment kodu, aby go przetestować

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 bajtów

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

Każda ¿reprezentuje niezadrukowany znak Unicode. Wypróbuj online!

Nie golfowany:

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

To było naprawdę fajne. Podzieliłem nazwy postaci na kilka dużych części:

0. Weź pierwsze dwie litery

V=Us0,2;ustawia zmienną Vna dwie pierwsze litery Uciągu wejściowego. Przyda się to później.

1. Wielkie litery

Jest to najłatwiejsze: wielkie litery są jedynymi, które mają znak na pozycji 21, a wszystkie są poprawnymi literami i dużymi literami. Zatem Ug21wystarczy.

2. Małe litery

Kolejny dość łatwy; jedyną inną nazwą, która ma znak na pozycji 19, jest RIGHT SQUARE BRACKETwięc, więc sprawdzamy, czy nazwa jest wcześniejsza Rz U<'R, a jeśli tak, to ( &&), bierzemy 19. znak z Ug19i rzucamy na małe litery v.

3. Cyfry

Wszystkie te nazwy zaczynają się od DI(i na szczęście nie ma innych), więc jeśli V=="DI"możemy, możemy zamienić je na cyfrę. Pierwsze litery niektórych nazw cyfr są takie same, ale pierwsze dwie litery są wystarczające. Łącząc je w jeden ciąg, otrzymujemy ZEONTWTHFOFISISEEINI. Teraz możemy po prostu wziąć indeks bpierwszych dwóch znaków w nazwie cyfry Us6,8)i podzielić przez dwa.

4 SIGN

Istnieje siedem nazw, które zawierają SIGN:

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

Najpierw sprawdzamy, czy nazwa zawiera słowo SIGN. Okazuje się, że GNwystarczy; Uf"GN"zwraca wszystkie wystąpienia GNw nazwie, czyli nulljeśli zawiera 0 wystąpień, a zatem zostaje pominięty.

Teraz, używając tej samej techniki, co cyfry, łączymy pierwsze dwie litery w ciąg LEGRPLEQDONUPE, a następnie bierzemy indeks i dzielimy przez dwie. Wynika z tego liczba, z 0-6której możemy użyć, aby pobrać odpowiedni znak z ciągu <>+=$#%.

5 MARK

Istnieją trzy znaki, które zawierają MARK:

!    EXCLAMATION MARK
"    QUOTATION MARK
?    QUESTION MARK

Tutaj używamy tej samej techniki, co z SIGN.  Mwystarczy odróżnić te trzy od pozostałych. Aby przetłumaczyć na symbol, tym razem wystarczy sprawdzić jedną literę: znak na pozycji 2 jest inny dla wszystkich trzech znaków. Oznacza to, że nie musimy dzielić przez dwa przy wyborze właściwej postaci.

6. LEFT/RIGHT

Grupa ta zawiera wsporniki i nawiasy []{}(). Byłoby naprawdę skomplikowane, aby uchwycić zarówno LEFTi RIGHT, na szczęście, wszystkie one zawierają ciąg T . Sprawdzamy to za pomocą tej samej techniki, co my SIGN. Aby przetłumaczyć na symbol, tak jak w przypadku MARK, wystarczy sprawdzić jedną literę; postać na pozycji 6 jest wyjątkowa dla wszystkich sześciu.

7 CO

Reszta znaków jest dość wyjątkowa, ale niewystarczająco wyjątkowa. Trzy z nich zaczynają się CO: COMMA, COLON, i COMMERCIAL AT. Używamy dokładnie taką samą technikę jak my ze wspornikami, wybór właściwego symbolu na podstawie znaku w pozycji 4 ( A, Nlub E).

8. Wszystko inne

Do tej pory pierwsze dwa znaki są różne dla każdego imienia. Łączymy je wszystkie w jeden duży ciąg SPAMAPASHYFUSORESETICIGRLOVEi mapujemy każdą parę na odpowiadający jej znak  &'*-./\;~^`_|.

9. Ostatnie kroki

Każda z części zwraca pusty ciąg lub nulljeśli nie jest poprawny, więc możemy połączyć je wszystkie od lewej do prawej ||. ||Operator zwraca lewy argument jeśli to truthy i właściwej argumentacji inaczej. Japt ma również niejawne dane wyjściowe, więc bez względu na wynik jest automatycznie wysyłany do pola wyjściowego.

Pytania, komentarze i sugestie mile widziane!

Python 2, 237 bajtów

Pobierz skrót łańcucha i podziel go modulo przez 535. Następnie przekonwertuj go na znak Unicode o tym numerze. Pozycja znaku Unicode na wstępnie skompilowanej liście znaków Unicode jest następnie konwertowana na znak 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 bajtów

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

Wyjaśnienie:

Ten długi ciąg jest skompresowaną listą. a.length.toString(36)+a[0]+a.slice(-3)określa, jak w ogóle łańcuch będzie reprezentowany na liście. Również specjalna logika dla liter. (przy okazji, a[0]jest wbudowanym skrótem a.charAt(0), nawiasem mówiąc,)

PowerShell, 603 547 464 bajtów

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

( LineFeedliczy ten sam bajt co ;, więc zostawię przerwy dla czytelności)

_{Edycja 1 - Wyjęto wiele elementów z instrukcji switch i zamiast tego wypełniłem tabelę skrótów dla odnośników.}

_{Edycja 2 - O tak ... indeksowanie w ciąg znaków, to jest droga ...}

Zasadniczo pobiera dane wejściowe, dzieli je na spacje i wykonuje znak wieloznaczny switchprzy pierwszym słowie, aby odfiltrować głupie. Ustawia wynik tego na $b. Jeśli $bnie istnieje, łańcuch $cjest oceniany na pierwszych trzech literach pierwszego słowa i wypisuje znak bezpośrednio po nim, w przeciwnym razie wypisujemy $b.

Niektóre sztuczki obejmują LATIN CAPITAL LETTER Rindeksowanie do tablicy w zależności od tego, czy drugim słowem jest CAPITAL, i generowanie odpowiednich wielkich / małych liter. Druga „sztuczka” dotyczy DIGITs, poprzez indeksowanie do tablicy mieszającej. Zauważ, że wykonanie tej samej sztuczki polegającej na indeksowaniu w ciąg znaków nie jest krótsze (w rzeczywistości jest dłuższe o jeden bajt).

JavaScript, 416 411 389 bajtów

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

To jest bardziej czytelny format (wyjaśnienie w dalszej części):

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

Minus 5 bajtów od połączenia ciągów klucza i wartości.

Objaśnienie: Wyrażenia regularne w pierwszym wierszu redukują dane wejściowe do unikalnych 4-znakowych klawiszy. Pamiętaj, że unikalność jest gwarantowana tylko dla określonego zestawu nazw określonych w wyzwaniu, a duplikaty byłyby bardzo powszechne w normalnym języku angielskim! Nawet w przypadku tego wyzwania musiałem usunąć typowe słowa, takie jak nawias kwadratowy i znak, aby uzyskać unikalny zestaw.

Aby zwrócić znak, sprawdzam, czy jest to znak łaciński, sprawdzając ciągi znaków „SER” i „cer”, i zwracam ostatni znak wejściowy małymi literami dla ser.

W pozostałym zakresie odnoszę się do ciągu zawierającego wszystkie 4-znakowe klucze, po których następuje poprawny znak. Następnie używam indexof i podciągów indeksów znaków, aby pobrać i zwrócić znak.

Edycja: Użyłem więcej symboli wieloznacznych, aby zmniejszyć rozmiar wyrażenia regularnego, zastąpiłem substrat indeksami znaków i ogoliłem jeszcze dwadzieścia znaków. Zwolennicy reguł zauważą, że ta ostatnia aktualizacja zostanie opublikowana po zakończeniu wyzwania, ale nie sądzę, żeby zmieniła mój ranking. To tylko praktyka dla początkującego.

Python 3, 148 bajtów

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

Dla wygody przeglądania zastąpiłem dwa bajty niedrukowalne ósemkowymi kodami ucieczki \32i \34; cofnij to, aby uzyskać funkcję 148 bajtów.

Obliczyłem części tej funkcji skrótu za pomocą GPerf .

Perl 6 ,  348   242 bajtów

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

stosowanie:

my &code = {...}

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

say code 'HYPHEN-MINUS'; # -