23

आइए मूल बातें वापस लें!

आपका कोड, एक पूरा कार्यक्रम या फ़ंक्शन, एक मुद्रण योग्य मूल लैटिन वर्ण के आधिकारिक यूनिकोड नाम को संबंधित वर्ण में बदलना चाहिए। उदाहरण के लिए, इनपुट के लिए LOW LINEआपका कोड आउटपुट होना चाहिए _।
आपको केवल एकल वर्ण नाम इनपुट के रूप में लेना होगा।
आप किसी भी पूर्ववर्ती फ़ंक्शन या लाइब्रेरी, अंतर्निहित या अन्यथा का उपयोग नहीं कर सकते हैं, जो विशेष रूप से यूनिकोड के चरित्र नामों (जैसे पायथन unicodedata, जावा 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

code-golf string kolmogorov-complexity

— ल्यूक
स्रोत

2

क्या कार्यक्रम को केवल एक चरित्र नाम को संभालने की आवश्यकता है? उदाहरण के लिए, COLON COLONआउटपुट ::या अपरिभाषित व्यवहार होना चाहिए ?

— केविन डब्ल्यू।

स्पष्ट करने के लिए संपादित किया गया।

— ल्यूक

क्यों String.fromCharCodeमना किया जाता है

— सुपरजेडि २२२४

व्हाट्स, मैं गलत समझा कि क्या कार्य करता है।

— ल्यूक

हमें अमान्य इनपुट को कैसे संभालना चाहिए, जैसे CLON?

— edc65

25

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

यह x89 से गुणा करता है, अगले बाइट (ASCII- कोड) को जोड़ता है, और एक शेष modulo 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, clobbered जा सकता है - तो बचाने के लिए और रजिस्टरों को बहाल करने की कोई जरूरत नहीं है
जब हैश तालिका डिकोडिंग, इसे इस्तेमाल करता है alऔर ahध्यान से, तो सही जगह पर है कि ah0 से कम हो जाती है, और पूरे eaxरजिस्टर एक lut सूचकांक के रूप में इस्तेमाल किया जा सकता

— anatolyg
स्रोत

18

जावास्क्रिप्ट ईएस 6, 228 236 247 257 267 274 287

नोट: 7 चरों ने thx @ ev3commander को बचाया

नोट 2: 7 प्रमुख संपादन के बाद JAPT से बेहतर ,

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>

स्निपेट का विस्तार करें

— edc65
स्रोत

5

बस कैसे? बहुत बढ़िया।

— SuperJedi224 19

दरअसल, वर्णमाला के अलावा, "ला" से शुरू होने वाला कोई

— चार्ट नहीं है

@ ev3commander हाँ, लेकिन यहाँ मैं LAT, RIG और LEF का प्रबंधन करता हूँ और 2 वर्ण बहुत कम लगते हैं, LEFT और LESS होने

— edc65

ओह। मैंने सिर्फ स्किम्ड किया और RIG / LEF भाग को नहीं देखा।

— ev3commander

@ ev3commander दूसरे पर सोचा कि आप एक बिंदु है! मैं LESS और LEFT को संभालने में मर्ज कर सकता हूं और 4 बाइट बचा सकता हूं। Thx

— edc65

10

जाप , 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

प्रत्येक ¿एक यूनीकोड यूनिकोड चार का प्रतिनिधित्व करता है। इसे ऑनलाइन आज़माएं!

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, और सही तर्क अन्यथा देता है। जाप में निहित आउटपुट भी होता है, इसलिए परिणाम कुछ भी हो, यह स्वचालित रूप से आउटपुट बॉक्स में भेजा जाता है।

प्रश्न, टिप्पणी और सुझाव का स्वागत है!

— ETHproductions
स्रोत

शानदार जवाब और शानदार व्याख्या। लेकिन आप स्पष्टीकरण में हैंडलिंग या MARK (?!) का उल्लेख करना भूल गए

— edc65

@ edc65 वूप्स, धन्यवाद! मैंने MARKवर्णों पर एक अनुभाग में जोड़ा है ।

— ETHproductions

7

spamapashyfusoreseticigrlove= इतनी रीसेट बर्फीली लड़की के प्यार के लिए एक पशम ... 1

— AdmBorkBork

नहीं, यह अभी भी बहुत गोल्फ है।

— ब्लैकलाइट शाइनिंग

3

पायथन 2, 237 बाइट्स

स्ट्रिंग का हैश प्राप्त करें और मोडुलो इसे 535 से विभाजित करें। इसके बाद इसे उस संख्या के साथ एक यूनिकोड वर्ण में परिवर्तित करें। यूनिकोड वर्णों की एक precompiled सूची में यूनिकोड वर्ण की स्थिति को बाद में एससीआई वर्ण में बदल दिया जाता है।

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

— विलेम
स्रोत

3

जावास्क्रिप्ट, 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), वैसे)

— SuperJedi224
स्रोत

यदि आपने प्रतिस्थापित _किया है +, तो आप सूची को Base64- संपीड़ित कर सकते हैं।

— ETHproductions

@ETHproductions base64 चीजों को लंबा बनाता है , कम नहीं।

— शाइनिंग

@ETHproductions क्या जावास्क्रिप्ट में Base64 है?

— SuperJedi224

@ SuperJedi224 यह करता है, लेकिन ब्लैकलाइट तब तक सही है जब तक कि आधार 64 एक संख्या की जगह नहीं ले रहा है जो कम बेस, विशेष रूप से बाइनरी में व्यक्त किया जा सकता है।

— वेडरस्ट्रॉम

आप btoa("abc")पाठ को 25% तक संपीड़ित करने के लिए उपयोग कर सकते हैं (जब तक कि यह मान्य आधार -64 पाठ है, जो कि इसके _साथ बदलने के बाद होगा -), तो atob("compressed stuff")आपके वास्तविक कोड में।

— ETHproductions

1

पॉवरशेल, 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 संपादित करें - स्विच स्टेटमेंट से कई तत्वों को लिया और इसके बजाय लुकअप के लिए एक हैशटेबल को आबाद किया।}

_{संपादित करें 2 - ओह, हाँ ... एक स्ट्रिंग में अनुक्रमण, यह जाने का तरीका है ...}

अनिवार्य रूप से इनपुट लेता है, इसे रिक्त स्थान पर विभाजित करता है, और switchनासमझ लोगों को छानने के लिए पहले शब्द पर एक वाइल्डकार्ड करता है। उसी का परिणाम तय करता है $b। यदि $bमौजूद नहीं है, तो $cपहले शब्द के पहले तीन अक्षरों पर स्ट्रिंग का मूल्यांकन किया जाता है और तुरंत निम्नलिखित चरित्र को आउटपुट करता है, अन्यथा हम आउटपुट करते हैं $b।

कुछ तरकीबों में शामिल है LATIN CAPITAL LETTER Rजो दूसरे शब्द के आधार पर एक सरणी में अनुक्रमित करता है CAPITAL, और इसी अपरकेस / लोअरकेस अक्षर को आउटपुट करता है। अन्य "ट्रिक" DIGITs के लिए है, हैशटेबल में इंडेक्स करके। ध्यान दें कि यहां समान इंडेक्स-इन-ए-स्ट्रिंग ट्रिक करने के लिए कम नहीं है (यह वास्तव में एक बाइट से अधिक है)।

— AdmBorkBork
स्रोत

मैं तुम्हें फिर से पीट रहा हूं।

— सुपरजेडिए २२२४

1

जावास्क्रिप्ट, 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 और प्रयोग ~~सबस्ट्रिंग~~ चरित्र सूचकांक खींच और चरित्र वापस जाने के लिए।

संपादित करें: रेगेक्स के आकार को कम करने के लिए अधिक वाइल्डकार्ड्स का उपयोग किया जाता है, जो कि चरित्र सूचकांकों के साथ प्रतिस्थापित होता है और एंटोहर बीस वर्णों से मुंडा होता है। नियम के स्टिकर ध्यान देंगे कि यह अंतिम अद्यतन चुनौती समाप्त होने के बाद पोस्ट किया गया है, हालांकि मुझे नहीं लगता कि इसने मेरी रैंकिंग को बदल दिया है। यह केवल एक नौसिखिए के लिए अभ्यास है।

— wedstrom
स्रोत

1

पायथन 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]))

आपकी देखने की सुविधा के लिए, मैंने दो गैर-मुद्रण योग्य बाइट्स को ऑक्टल एस्केप कोड \32और के साथ बदल दिया है \34; 148 बाइट फ़ंक्शन प्राप्त करने के लिए इसे पूर्ववत करें।

मैंने इस हैश फ़ंक्शन के कुछ हिस्सों को GPerf के साथ गणना की है ।

— एंडर्स कसीगोर
स्रोत

0

पर्ल 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'; # -

— ब्रैड गिल्बर्ट b2gills
स्रोत

बेसिक लैटिन कैरेक्टर का नाम कैरेक्टर

IA-32 मशीन कोड, 161 160 122 बाइट्स

जावास्क्रिप्ट ईएस 6, 228 236 247 257 267 274 287

जाप , 230 बाइट्स

0. पहले दो अक्षर लें

1. बड़े अक्षर

2. लोअरकेस अक्षर

3. अंक

4। SIGN

5। MARK

6। LEFT/RIGHT

7। CO

8. सब कुछ

9. अंतिम चरण

पायथन 2, 237 बाइट्स

जावास्क्रिप्ट, 501 499 469 465 451 430 बाइट्स

स्पष्टीकरण:

पॉवरशेल, 603 547 464 बाइट्स

जावास्क्रिप्ट, 416 411 389 बाइट्स

पायथन 3, 148 बाइट्स

पर्ल 6 , 348 242 बाइट्स

4। `SIGN`

5। `MARK`

6। `LEFT/RIGHT`

7। `CO`