Grundlegender lateinischer Zeichenname zum Zeichen

23

Kommen wir zurück zu den Grundlagen!

  • Ihr Code, ein vollständiges Programm oder eine Funktion, muss den offiziellen Unicode-Namen eines druckbaren lateinischen Basiszeichens in das entsprechende Zeichen konvertieren. Zum Beispiel LOW LINEmuss Ihr Code für die Eingabe ausgegeben werden _.
  • Sie müssen nur einen einzelnen Zeichennamen als Eingabe verwenden.
  • Sie können keine vordefinierten oder anderweitig vorhandenen Funktionen oder Bibliotheken verwenden, die eine Logik speziell für Unicode-Zeichennamen bieten (z. B. Pythons unicodedata, Javas Character.getNameusw.).
  • Für andere Eingaben als einen dieser Namen ist jedes Verhalten akzeptabel.

Dies ist Code Golf: Der kürzeste Code in Bytes gewinnt.

Um Unklarheiten zu vermeiden, ist dies der vollständige Satz der offiziellen Charakternamen, die wir verwenden werden (aus dieser Frage entlehnt ):

     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
code-golf  string  kolmogorov-complexity 
— Luke
quelle
2
Muss das Programm nur einen Zeichennamen verarbeiten? Soll zum Beispiel COLON COLONausgegeben ::werden oder undefiniertes Verhalten?
— Kevin W.
Zur Verdeutlichung bearbeitet.
— Luke
Warum ist String.fromCharCodeverboten?
— SuperJedi224
Hoppla, ich habe falsch verstanden, was diese Funktion bewirkt.
— Luke
Wie müssen wir mit ungültigen Eingaben umgehen CLON?
— edc65

Antworten:

25

IA-32 Maschinencode, 161 160 122 Bytes

Hexdump des Codes:

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

Dieser Code verwendet etwas Hashing. Durch eine Brute-Force-Suche habe ich festgestellt, dass die folgende Hash-Funktion auf die Bytes der Eingabezeichenfolge angewendet werden kann:

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

Es multipliziert xmit 89, addiert das nächste Byte (ASCII-Code) und nimmt ein Restmodulo 113 an. Dies geschieht für alle Bytes der Eingabezeichenfolge mit Ausnahme der letzten, also z. B. LATIN CAPITAL LETTER Aund LATIN CAPITAL LETTER Xgeben Sie denselben Hash-Code an.

Diese Hash-Funktion hat keine Kollisionen und die Ausgabe liegt im Bereich von 0 bis 113 (zum Glück ist der Bereich sogar noch enger: 3 bis 108).

Die Hash-Werte aller relevanten Zeichenfolgen füllen diesen Bereich nicht vollständig aus, daher habe ich mich entschieden, diese zu verwenden, um die Hash-Tabelle zu komprimieren. Ich habe eine "Überspringen" -Tabelle (112 Bits) hinzugefügt, die 0 enthält, wenn die entsprechende Stelle in der Hash-Tabelle leer ist, und 1, wenn dies nicht der Fall ist. Diese Tabelle konvertiert einen Hash-Wert in einen "komprimierten" Index, der zum Adressieren einer dichten LUT verwendet werden kann.

Die Zeichenfolgen LATIN CAPITAL LETTERund LATIN SMALL LETTERgeben die Hash-Codes 52 und 26 an. Sie werden separat behandelt. Hier ist ein C-Code dafür:

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

Der entsprechende Assembler-Code (MS Visual Studio Inline-Assembler-Syntax):

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

Einige bemerkenswerte Implementierungsdetails:

  • Es verwendet eine CALLAnweisung, um einen Zeiger auf den Code abzurufen, in dem sich die fest codierte Tabelle befindet. Im 64-Bit-Modus könnte ripstattdessen das Register verwendet werden.
  • Es verwendet die BTAnweisung, um auf die Sprungtabelle zuzugreifen
  • Er verwaltet die Arbeit mit nur drei Register zu tun eax, ecx, edx, die verprügelt werden kann - so gibt es keine Notwendigkeit Register zu speichern und wiederherzustellen
  • Beim Dekodieren der Hash-Tabelle wird alund ahsorgfältig darauf geachtet, dass an der richtigen Stelle ahauf 0 abgenommen wird und das gesamte eaxRegister als LUT-Index verwendet werden kann
— anatolyg
quelle
18

JavaScript ES6, 228 236 247 257 267 274 287

Hinweis: 7 Zeichen sind dank @ ev3commander gespeichert

Anmerkung 2: Besser als JAPT nach 7 Hauptbearbeitungen .

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ühren Sie das Snippet zum Testen aus

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>
Erweitern Sie das Snippet

— edc65
quelle
5
Nur wie? Gut gemacht.
— SuperJedi224
Tatsächlich gibt es außer dem Alphabet keinen Buchstaben, der mit "LA"
— beginnt
@ ev3commander ja, aber hier schaffe ich LAT, RIG und LEF und 2 Zeichen scheinen zu wenig, mit LEFT und LESS
— edc65
Ohh Ich habe nur überflogen und den RIG / LEF-Teil nicht gesehen.
— ev3commander
@ ev3commander beim zweiten gedanken hast du einen punkt! Ich kann die Behandlung WENIGER und LINKS zusammenführen und 4 Bytes sparen. Thx
— edc65
10

Japt , 230 Bytes

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

Jedes ¿stellt ein nicht druckbares Unicode-Zeichen dar. Probieren Sie es 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

Das hat wirklich Spaß gemacht. Ich habe die Charakternamen in mehrere große Teile aufgeteilt:

0. Nimm die ersten beiden Buchstaben

V=Us0,2;Setzt die Variable Vauf die ersten beiden Buchstaben vonU der Eingabezeichenfolge. Dies wird später nützlich sein.

1. Großbuchstaben

Dies ist am einfachsten: Die Großbuchstaben sind die einzigen, die an Position 21 ein Zeichen haben, was allesamt der richtige Buchstabe und die richtige Groß- und Kleinschreibung sind. Somit Ug21ist ausreichend.

2. Kleinbuchstaben

Ein anderes ziemlich einfaches; der einzige andere Name, der ein Zeichen auf Position 19 hat, ist RIGHT SQUARE BRACKET, also prüfen wir, ob der Name vor Rmit kommt U<'R, und wenn es ( &&) ist, nehmen wir das 19. Zeichen mit Ug19und setzen es in Kleinbuchstaben mit v.

3. Ziffern

Diese Namen beginnen alle mit DI(und glücklicherweise mit keinem der anderen). Wenn also V=="DI", können wir daraus eine Ziffer machen. Die ersten Buchstaben einiger Ziffernnamen sind identisch, die ersten beiden Buchstaben sind jedoch ausreichend. Wenn wir diese zu einer Zeichenfolge kombinieren, erhalten wir ZEONTWTHFOFISISEEINI. Jetzt können wir nur den Index bder ersten beiden Zeichen im Namen der Ziffer mit nehmen Us6,8)und durch zwei teilen.

4. SIGN

Es gibt sieben Namen, die enthalten SIGN:

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

Zuerst prüfen wir, ob der Name das Wort enthält SIGN. Es stellt sich heraus, GNist ausreichend; Uf"GN"Gibt alle Instanzen von GNim Namen zurück, dh nullwenn es 0 Instanzen enthält, und wird daher übersprungen.

Nun kombinieren wir mit der gleichen Technik wie bei den Ziffern die ersten beiden Buchstaben zu einer Zeichenkette LEGRPLEQDONUPE, nehmen dann den Index und dividieren durch zwei. Dies ergibt eine Zahl, aus 0-6der wir das entsprechende Zeichen aus der Zeichenkette entnehmen können <>+=$#%.

5. MARK

Es gibt drei Zeichen, die Folgendes enthalten MARK:

!    EXCLAMATION MARK
"    QUOTATION MARK
?    QUESTION MARK

Hier verwenden wir die gleiche Technik wie bei SIGN.  Mreicht aus, um diese drei von den anderen zu unterscheiden. Um in ein Symbol zu übersetzen, reicht es aus, diesmal einen Buchstaben zu markieren: Das Zeichen an Position 2 ist für alle drei Zeichen unterschiedlich. Dies bedeutet, dass wir bei der Auswahl des richtigen Zeichens nicht durch zwei teilen müssen.

6. LEFT/RIGHT

Diese Gruppe enthält die Klammern und Klammern []{}(). Es wäre wirklich kompliziert sowohl zu erfassen LEFTund RIGHT, aber zum Glück, sie alle enthalten die Zeichenfolge T . Wir überprüfen dies mit der gleichen Technik wie wir SIGN. Um wie mit in ein Symbol zu übersetzen MARK, reicht es aus, einen Buchstaben zu markieren. Der Charakter auf Position 6 ist für alle sechs einzigartig.

7. CO

Der Rest der Zeichen ist ziemlich einzigartig, aber nicht einzigartig genug. Drei von ihnen beginnen mit CO: COMMA, COLON, und COMMERCIAL AT. Wir verwenden exakt die gleiche Technik wie wir mit den Klammern haben, das richtige Symbol Auswahl auf der Grundlage der Zeichen an Position 4 ( A, Noder E).

8. Alles andere

Inzwischen unterscheiden sich die ersten beiden Zeichen für jeden Namen. Wir kombinieren sie alle zu einer großen Zeichenfolge SPAMAPASHYFUSORESETICIGRLOVEund ordnen jedem Paar die entsprechenden Zeichen zu  &'*-./\;~^`_|.

9. Letzte Schritte

Jeder der Teile gibt eine leere Zeichenfolge zurück oder nullwenn es nicht die richtige ist, können wir sie alle von links nach rechts mit verknüpfen ||. Der ||Operator gibt das linke Argument zurück, wenn es wahr ist, und das rechte Argument, wenn es falsch ist. Japt hat auch eine implizite Ausgabe, was auch immer das Ergebnis ist, es wird automatisch an das Ausgabefeld gesendet.

Fragen, Kommentare und Vorschläge sind willkommen!

— ETHproductions
quelle
Tolle Antwort und tolle Erklärung. Aber Sie haben vergessen, das Handling oder MARK (!? ") In der Erklärung zu
— erwähnen
@ edc65 Ups, danke! Ich habe in einem Abschnitt über MARKZeichen hinzugefügt .
— ETHproductions
7
spamapashyfusoreseticigrlove= Spam ein Pashy für so zurückgesetzt eisige Mädchen Liebe ... +1
— AdmBorkBork
Nein, das ist noch sehr viel Golf.
— Blacklight Shining
3

Python 2, 237 Bytes

Holen Sie sich den Hash des Strings und dividieren Sie ihn durch 535. Konvertieren Sie ihn anschließend in ein Unicode-Zeichen mit dieser Nummer. Die Position des Unicode-Zeichens in einer vorkompilierten Liste von Unicode-Zeichen wird anschließend in das ASCII-Zeichen konvertiert.

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

Javascript, 501 499 469 465 451 430 Bytes

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

Erläuterung:

Diese lange Zeichenfolge ist eine komprimierte Liste. a.length.toString(36)+a[0]+a.slice(-3)Legt fest, wie die Zeichenfolge in der Liste dargestellt wird, wenn überhaupt. Auch spezielle Logik für Briefe. (mit Streichern, a[0]ist übrigens eine eingebaute Abkürzung für a.charAt(0))

— SuperJedi224
quelle
Wenn Sie durch ersetzt haben , können Sie die Liste _mit +Base64 komprimieren.
— ETHproductions
@ETHproductions base64 macht die Dinge länger und nicht kürzer.
— Blacklight Shining
@ETHproductions Does Javascript haben Base64?
— SuperJedi224
@ SuperJedi224 Ja, aber Schwarzlicht ist korrekt, es sei denn, die Basis 64 ersetzt eine Zahl, die in einer niedrigeren Basis hätte ausgedrückt werden können, insbesondere binär.
— Mittwoch,
Mit können Sie btoa("abc")Text um 25% komprimieren (sofern es sich um gültigen Basis-64-Text handelt, den Sie nach dem Ersetzen _durch verwenden würden -), dann atob("compressed stuff")in Ihrem tatsächlichen Code.
— ETHproductions
1

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]

( LineFeedZählt dasselbe Byte wie ;, daher lasse ich die Pausen zur besseren Lesbarkeit ein.)

Bearbeiten 1 - Entfernt viele Elemente aus der switch-Anweisung und füllt stattdessen eine Hash-Tabelle für Lookups.

Edit 2 - Oh ja ... Indizieren in einen String, das ist der richtige Weg ...

Nimmt im Wesentlichen die Eingabe, teilt sie in Leerzeichen auf und setzt switchbeim ersten Wort einen Platzhalter , um die doofen herauszufiltern. Setzt das Ergebnis auf $b. Falls $bnicht vorhanden, wird der String $cmit den ersten drei Buchstaben des ersten Wortes ausgewertet und gibt das unmittelbar folgende Zeichen aus, ansonsten geben wir aus $b.

Einige Tricks beinhalten das, LATIN CAPITAL LETTER Rwas in ein Array indiziert, basierend darauf, ob das zweite Wort ist CAPITAL, und das Ausgeben des entsprechenden Groß- / Kleinbuchstabens. Der andere "Trick" ist für die DIGITs, indem in eine Hash-Tabelle indiziert wird. Beachten Sie, dass es nicht kürzer ist, hier denselben Index-in-eine-Zeichenfolge-Trick auszuführen (tatsächlich ist er um ein Byte länger).

— AdmBorkBork
quelle
Ich schlug dich wieder.
— SuperJedi224
1

Javascript, 416 411 389 Bytes

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

Dies ist ein besser lesbares Format (Erklärung folgt später):

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

Mindestens 5 Byte aus der Kombination von Schlüssel- und Wertzeichenfolgen.

Erläuterung: Die regulären Ausdrücke in der ersten Zeile reduzieren die Eingaben in eindeutige Schlüssel mit 4 Zeichen. Beachten Sie, dass die Eindeutigkeit nur für die in der Challenge angegebenen Namen garantiert ist und dass Duplikate für normales Englisch sehr häufig sind! Selbst für diese Herausforderung musste ich gebräuchliche Wörter wie Klammer und Zeichen entfernen, um ein einzigartiges Set zu erhalten.

Um das Zeichen zurückzugeben, überprüfe ich, ob es ein lateinisches Zeichen ist, indem ich die Zeichenfolgen "SER" und "cer" überprüfe und das letzte Zeichen der Eingabe in Kleinbuchstaben für ser zurückgebe.

Für alles andere beziehe ich mich auf eine Zeichenfolge, die alle 4 Zeichenschlüssel enthält, gefolgt vom richtigen Zeichen. Ich benutze dann IndexOf und Teilzeichenzeichen Indizes zu ziehen und den Charakter zurück.

Bearbeiten: Verwenden Sie mehr Platzhalter, um die Regex-Größe zu reduzieren, ersetzen Sie substr durch Zeichenindizes und entfernen Sie weitere 20 Zeichen. Regelverfasser werden bemerken, dass dieses letzte Update nach dem Ende der Herausforderung veröffentlicht wird, aber ich denke nicht, dass es mein Ranking verändert hat. Dies ist nur eine Übung für einen Anfänger.

— Wedstrom
quelle
1

Python 3, 148 Bytes

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

Zur Vereinfachung der Anzeige habe ich zwei nicht druckbare Bytes durch die oktalen Escape-Codes ersetzt \32 und ersetzt \34. Machen Sie dies rückgängig, um die 148-Byte-Funktion zu erhalten.

Ich habe Teile dieser Hash-Funktion mit GPerf berechnet .

— Anders Kaseorg
quelle
0

Perl 6 ,  348   242 Bytes

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

Verwendung:

my &code = {...}

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

say code 'HYPHEN-MINUS'; # -
— Brad Gilbert b2gills
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.