मेरे पास कितने अध्याय हैं?


18

बाइबल अब तक लिखी गई सबसे प्रभावशाली किताबों में से एक है, और आमतौर पर इसे अब तक की सबसे ज्यादा बिकने वाली किताब के रूप में जाना जाता है । यहवर्तमान स्वरूप में संकलित होने से पहले सैकड़ों वर्षों में लगभग 40 विभिन्न लेखकों द्वारा लिखा गया था। लेकिन बाइबल के बारे में दिलचस्प यह है कि यह किस तरह विभाजित है। इसे 2 अलग-अलग परीक्षकों में विभाजित किया गया है, जिन्हें 66 छोटी पुस्तकों में विभाजित किया गया है, जो प्रत्येक छोटे अध्यायों में विभाजित हैं, जो प्रत्येक अलग-अलग छंदों में विभाजित हैं।

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

आप किसी भी उचित प्रारूप में IO ले सकते हैं, उदाहरण के लिए STDIN / STDOUT या फ़ाइल लिखना, फ़ंक्शन तर्क / रिटर्न मान, उपयोगकर्ता को संकेत देना, आदि सभी की अनुमति है। इनपुट हमेशा बाइबिल की 66 पुस्तकों में से एक होगा, और केवल लोअरकेस। इसका मतलब यह है कि यदि आपको कोई अन्य इनपुट दिया जाता है, तो अपरिभाषित व्यवहार की अनुमति है। चूंकि केवल 66 संभावित इनपुट और आउटपुट हैं, वे सभी यहां दिए गए हैं, विकिपीडिया के पेज द किंग जेम्स में बाइबल के अध्यायों के अनुसार :

genesis         50
exodus          40
leviticus       27
numbers         36
deuteronomy     34
joshua          24
judges          21
ruth            4
1 samuel        31
2 samuel        24
1 kings         22
2 kings         25
1 chronicles    29
2 chronicles    36
ezra            10
nehemiah        13
esther          10
job             42
psalms          150
proverbs        31
ecclesiastes    12
song of solomon 8
isaiah          66
jeremiah        52
lamentations    5
ezekiel         48
daniel          12
hosea           14
joel            3
amos            9
obadiah         1
jonah           4
micah           7
nahum           3
habakkuk        3
zephaniah       3
haggai          2
zechariah       14
malachi         4
matthew         28
mark            16
luke            24
john            21
acts            28
romans          16
1 corinthians   16
2 corinthians   13
galatians       6
ephesians       6
philippians     4
colossians      4
1 thessalonians 5
2 thessalonians 3
1 timothy       6
2 timothy       4
titus           3
philemon        1
hebrews         13
james           5
1 peter         5
2 peter         3
1 john          5
2 john          1
3 john          1
jude            1
revelation      22

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

हमेशा की तरह, यह एक है चुनौती है, इसलिए जितना हो सके कम से कम संभव कार्यक्रम (बाइट्स में मापा गया) बनाने की कोशिश करें। मज़ा गोल्फ है!


3
आउटपुट तय नहीं है, तो यह कोल्मोगोरोव-जटिलता क्यों है ?
LyricLy

3
@LyricLy क्योंकि आउटपुट तय नहीं होने के बावजूद, यह डेटा के दो अलग-अलग सेट जनरेट करने का सबसे कुशल तरीका देखने के बारे में है: 1) किताबों के नाम (या इसे पहचानने के लिए लंबे समय से नाम का एक हिस्सा) और 2 ) अध्यायों की इसी संख्या।
DJMcMayhem

3
आप बस सभी को एक सामान्य राशि के साथ देखते हैं और फिर सिर्फ भजन जो कि HALF THE BIBLE की तरह है
HyperNeutrino

4
मैं चाहता हूँ enklactइस चुनौती से बाहर अपने रास्ते लेकिन मैं नहीं कर सकता ...
totallyhuman

3
@DJMcMayhem आप इस तथ्य को भूल गए हैं कि 66 अद्वितीय पत्र नहीं हैं। : पी
बिलकुल अमानवीय

जवाबों:


12

जेली , 127 बाइट्स

“£ÐgƁ÷ḅ*Wßßɦ*⁷ċṗṿỵ×Ɓṿ⁷ḢQ’b7+\;“BƝ‘
OḄ;407;270;“ọḷḊḲɦ‘%/i@“¡Ṙ×!⁸Ọ5`ỊV-ṙQȷṖÞ(sĿȮ^k³M"ɓmEf¤*0C[ạƇŻȥ#BṚñİmZẓeȦUƈ!ċ€@Ȧʋ)ƙḅyẉ’b158¤ị¢

इसे ऑनलाइन आज़माएं!

परीक्षण के मामलों

यह काम किस प्रकार करता है

अनिवार्य रूप से, यह वर्ण इनपुट के ords को बाइनरी मान में बदलने की कोशिश करता है, उदाहरण के लिए "joel"-> [106, 111, 101, 108]->>2^3*106 + 2^2*111 + 2^1*101 + 2^0*108

फिर, यह मान 407 लिया जाता है, फिर मॉड 270, फिर [कुछ और मॉड], फिर मॉड 160। यह उपयोगी है क्योंकि यह 0 और 158 के बीच पूर्णांक के लिए सभी 66 स्ट्रिंग इनपुट को मैप करता है (अंतिम मॉड पर भाग्यशाली)।

पूर्णांक सूची “ọḷḊḲɦ...ƙḅyẉ’b158¤के मान से पूर्णांक को अनुक्रमित किया जाता nहै ताकि इनपुट के nकम से कम संख्या में इस तरह के मान का पता लगाया जा सके । जोएल होता है कि अध्याय की संख्या 7-न्यूनतम है।

इस मूल्य को nऔर अधिक “£ÐgƁ÷ḅ*Wßßɦ*⁷ċṗṿỵ×Ɓṿ⁷ḢQ’b7+\;“BƝ‘सटीक अध्याय खोजने के लिए सूची में शामिल किया गया है ।

संभावित सुधार: एक ही संख्या में अध्याय के साथ इनपुट mods (0% टक्कर आवश्यक नहीं है) से समान मूल्य के लिए हैश कर सकते हैं, लेकिन मैंने mods के अनुक्रम को निर्धारित करने के लिए अपने कार्यक्रम में इसका हिसाब नहीं दिया।



@( %/i@“...’b158¤ị¢-> %/“...’b158¤iị¢) से बचने के लिए एक बाइट सहेजें । प्रारंभ ( OḄ;407;270;“ọḷḊḲɦ‘-> OḄ;“ẋn=:!ס‘+160¤) में एक ही कोड-पेज इंडेक्स सूची में 160 की ऑफसेट का उपयोग करके एक और बाइट बचाएं ।
जोनाथन एलन

10

एक्सेल, 373 बाइट्स

गणितज्ञ के उत्तर से @ मिशा के दृष्टिकोण का पुन: उपयोग ( 6a+b+8c+5d+3e modulo 151):

=CHOOSE(MOD(6*CODE(LEFT(A1,1))+CODE(MID(A1,2,1))+8*CODE(MID(A1,3,1))+5*CODE(MID(A1&A1,4,1))+3*CODE(MID(A1&A1,5,1)),151)+1,30,,,,27,,,,3,12,,,9,,149,,,28,,,13,,,35,3,,35,7,,8,,20,,49,23,13,4,,,4,,,,,,,2,,,39,,,15,3,,3,9,,12,27,,,,,,51,15,,,,70,,65,,21,11,,,4,,24,,,6,,2,1,,,,,,2,,,30,,,,,,23,,,33,,20,,,15,,,4,,4,,,12,2,,2,47,23,,2,,,,,41,,,3,,,5,,,,,11,,21,5,,,,5,2,3,26)+1

लुकअप चेप्टर लौटाता है -1, और फिर एक जोड़ देता है। यह बदलता है 10में 9दो बार, और ,1,में ,,4 बार।

पुराने दृष्टिकोण के लिए अद्यतन। एक्सेल, 460 401 बाइट्स

CSV के रूप में सहेजें, पहली पंक्ति के अंत में दर्ज पुस्तक का नाम ( C1), परिणाम C2:

1c,16,revelation
1co,29,"=VLOOKUP(LEFT(C1,1)&MID(C1,3,1)&MID(C1,6,1),A:B,2)"
1j,5
1k,22
1p,5
1s,31
1t,6
1ts,5
2c,13
2co,36
2j,1
2k,25
2p,3
2s,24
2t,4
2ts,3
3j,1
a,9
at,28
c,4
d,12
du,34
e,12
ee,48
eh,6
eo,40
er,10
g,6
gn,50
h,3
hbw,13
hg,2
hs,14
i,66
j,42
jd,1
jds,21
je,3
jh,21
jm,5
jn,4
jr,52
js,24
lm,5
lv,27
m,7
ml,4
mr,16
mt,28
n,3
nhi,13
nm,36
o,1
p,150
pi,1
pip,4
po,31
r,16
rt,4
rv,22
s,8
t,3
zc,14
zp,3

लुकअप टेबल के लिए, हम बाहर जा सकते हैं et 10और l 24क्योंकि ये मैच क्रमशः er 10और js 24क्रमशः।


हम बहुत बार एक्सेल फॉर्मूला के उत्तर नहीं देखते हैं, जिसमें लुकअप टेबल की आवश्यकता होती है। नवीनता और निष्पादन के लिए प्रेरित करें। आप एक्सेल में स्कोरिंग के बारे में कुछ मेटा प्रश्नों को खोजना / पोस्ट करना चाहते हैं। विशेष रूप से, मुझे लगता है कि आप ए कॉलम के लेआउट के लिए कुछ और बाइट दे सकते हैं। इसके अलावा, आप शायद ए को सी और बी: सी से ए: बी में ले जाना चाहते हैं, इसलिए आपको मेरे सिर के ऊपर से ए में सभी खाली कोशिकाओं के लिए "चार्ज" नहीं मिलता है, मुझे लगता है कि टीएसवी / के आकार संपूर्ण पत्रक के लिए CSV पाठ फ़ाइल सही स्कोर हो सकती है?
स्पर्स

आम तौर पर, मुझे लगता है कि .csv फ़ाइल में वर्णों का बायटेकाउंट (इस मामले में सम्मिलित इनपुट मान का बायटेकाउंट), इन प्रकार के एक्सेल उत्तर का स्कोर होना चाहिए - जो कि मेरी गिनती से ऊपर के स्कोर पर निकलता है 401 बाइट्स
टेलर स्कॉट

@TaylorScott, मेरे पास नई पंक्ति के पात्रों के रूप में CR-LF था। 401 v। 464 मान लें क्योंकि यह है?
वेर्निस्क ऑक्ट

@Wernisch, संक्षेप में, हाँ - आप मान सकते हैं कि लाइनफीड को ASCII वर्ण शाब्दिक चारकोड 10 के साथ संग्रहीत किया गया है, जिसका अर्थ है कि वे 1 बाइट के रूप में गिने जाते हैं
टेलर स्कॉट

9

जावास्क्रिप्ट (ईएस 6), 251 197 बाइट्स

s=>`-  cE1$ " +%&  %  &!!· $!#&!!)!'=6 &!6".!  -!!Q$"/  779@@= % & $'1 U( I>!!  K * "S< :  9$!C %  . $. 9E1/ %!!'" + $ % `.split`!`.join`   `.charCodeAt(parseInt(s[2]+s[0]+s[5],36)%913%168%147)-33

परीक्षा

प्रारूपित और टिप्पणी की गई

s =>                                 // s = book name
  `-  cE1$ " +%&  %  &!!· (...)`     // data string (truncated)
  .split`!`.join`   `                // inflate padding characters '!' -> 3 spaces
  .charCodeAt(                       // read the ASCII code at the position found by
    parseInt(s[2] + s[0] + s[5], 36) // parsing 3 characters of the input in this exact
    % 913 % 168 % 147                // order as base 36 and applying three consecutive
  ) - 33                             // modulo operations, then subtract 33

2
आप आधिकारिक तौर पर जेएस में सबसे कुशल हैशिंग विधि खोजने के मास्टर हैं ... या क्या आपके पास कोई प्रोग्राम है जो आपके लिए तरीके खोजता है? ;)
ETHproductions

@ETHproductions मैंने कुछ बिंदु पर एक सामान्य नोड कार्यक्रम लिखा था, लेकिन यह विशेष रूप से तेज़ नहीं है इसलिए मैं ज्यादातर समय कस्टम कोड लिखना समाप्त करता हूं ... O_o
Arnauld

9

गणितज्ञ: 323 294 बाइट्स

Uncompress["1:eJxTTMoPSpvOwMBQzAIkfDKLSzJlgAwCBEhtJi8qwQUnpqESsqgEHyqhAjePBc7lgBOccEIUThiBCAm4AayECUZUghmV0EAlBFAdxILqN17CgWMCNwUn4QQnxEAEDyqBcLgkKsGO6gUmLAROX8rjJSRQCSU4IYpKILzAiDfEebG4wADVDmZchBYqgRYVbLgIRPiJ4VXHDDdKGuZ9AAP6TUg="][[Mod[ToCharacterCode@StringTake[#<>#,5].{6,1,8,5,3},151,1]]]&

यह काम किस प्रकार करता है

एक पुस्तक चरित्र कोड के साथ शुरुआत के लिए a, b, c, d, ecomputes (चारों ओर, यदि आवश्यक हो लपेटकर) 6a+b+8c+5d+3eसापेक्ष 151, जो अद्वितीय होता है, और फिर सूची रहे हैं में लंबाई 151 (अप्रयुक्त प्रविष्टियों की एक संकुचित सूची में अध्यायों की संख्या को देखता है पिछली प्रविष्टि के डुप्लिकेट से भरा है। यह रन-लेंथ एन्कोडिंग को प्रोत्साहित करता है, हो सकता है? वैसे भी, यह मदद करता है।)

सूची संपीड़न विचार के लिए @numbermaniac के लिए धन्यवाद, जिस पर संख्या डालना मुश्किल है, लेकिन यहां सुधार का एक बड़ा हिस्सा है।

पुराना संस्करण: गणितज्ञ, 548 435 407 बाइट्स

Join["111112333333344444455555666789"~(p=StringPartition)~1,"1010121213131314141616162121222224242425272828293131343636404248505266"~p~2,{"150"}][[Max@StringPosition["2jn3jnjduoaapimhgi2pe2tshbkjeonhntttzpn2toclsjnjmlhpiprtu1jn1pe1tsjmjlmt1toehiglimcmsnoaometrerzdnlecs2cihbwnhihshzcr1cimrarmsjhojds1kgrva2sujsalku2kglviatcmte1co1supordur2conmreosjbbeeegnijriiahpas",""<>#&@Characters[#<>#][[{1,3,6}]]]/3]]&

यह काम किस प्रकार करता है

हम प्रत्येक नाम nameको वर्ण, 1, 3 और 6 namename(जैसे leviticusबन जाता है lvi, jobबन जाता है jbb) से पहले देखते हैं।

हम जिन चीजों को देखते हैं, वे सूची में 1-अंक और 2-अंकीय अध्याय संख्याओं को एक साथ रखकर थोड़ा संकुचित होता है।

गणित: 40 बाइट्स, गैर-प्रतिस्पर्धात्मक

WolframAlpha["# chapters "<>#,"Result"]&

हाँ।


यदि आप Compressसूची का उपयोग करते हैं, तो आपको एक स्ट्रिंग मिलती है जिसे Uncompressआपके कार्यक्रम में वापस सूची में बदल दिया जा सकता है ; पूरे समारोह 430 बाइट्स तक बाहर आता है आप बचत 5 :),
numbermaniac

धन्यवाद! कार्यक्रम के उस संस्करण में सूची को छोटा करने के बेहतर तरीके थे, लेकिन मैंने जो नया तरीका पाया उसके लिए बहुत अच्छी तरह से काम किया :) :)
मीशा लावरोव

4
मैं वास्तव में एक दूसरे गणितज्ञ के उत्तर की आशा करता था जिसमें एक बाइबल में निर्मित होगा
SztupY

कोई अंतर्निहित नहीं है; वहाँ है WolframAlpha["number of chapters of "<>#,"Result"]&, लेकिन किसी भी तरह एक ही बात की तरह महसूस नहीं करता है।
मिशा लावरोव

1
यह वुल्फराम अल्फा पर उत्तर को देखता है, जिसे मानक खामियों और स्पष्ट रूप से प्रश्न में दोनों को धोखा देने के रूप में कहा जाता है। (हालांकि मुझे लगता है कि अगर मैंने बाइट काउंट में वोल्फ्राम अल्फा के सोर्स कोड और डेटाबेस को शामिल किया, तो यह फिर से ठीक हो जाएगा।)
मीशा लावरोव


4

जेली ,  117 115  114 बाइट्स

OP%⁽µW%⁽£İ%237
“ĿḊƘ⁹ƙƬṂ;ɓṭ6-ạʋ⁵%$Ẋf,¥ÆÑƈø¬ȦṘd⁾“ʂụṿⱮẆƊ¦ẠLjƒ~Ḅr©“Ẏw|!¡¢o“ŻɗṢ“3ɠ‘Zċ€ÇTḢị“£ẆJQ+k⁽’ḃ6¤+\;“£¬®µıñø"BƝ¤‘¤

इसे ऑनलाइन आज़माएं! या देखें परीक्षण-सूट देखें

कैसे?

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

जब एक हैश फंक्शन मिल रहा है, तो मैंने केवल उन लोगों पर विचार किया जिनके परिणामस्वरूप कोड-पेज अनुक्रमण की अनुमति देने के लिए 255 से अधिक परिणामों के साथ सबसे अधिक एक बाल्टी मिली और फिर उन लोगों को चुना जिन्होंने "अपमानजनक" बाल्टी को हटाने के लिए या (यदि हटाने के बाद) मानों की कुल संख्या को कम कर दिया कोई भी सबसे लंबी बाल्टी मौजूद नहीं है)। 66 में तीन मॉडुलोस के साथ मैंने 59 ( %731%381%258) एक 58 ( %731%399%239) तब 56 प्रविष्टियों ( %1241%865%251) [117 बाइट्स के लिए बना] के साथ एक पाया ... मैंने तब 58 को केवल दो अवशेष ( %1987%251) [115 बाइट्स के लिए बना] का उपयोग कर पाया
। । तब मैंने तीन अवशेषों का उपयोग करके 55 पाया, जब दो डमी प्रविष्टियां जोड़ी जाती हैं, तो लुकअप सूची के आगे संपीड़न की अनुमति मिलती है ...

कोड:

1।

“ĿḊƘ⁹ƙƬṂ;ɓṭ6-ạʋ⁵%$Ẋf,¥ÆÑƈø¬ȦṘd⁾“ʂụṿⱮẆƊ¦ẠLjƒ~Ḅr©“Ẏw|!¡¢o“ŻɗṢ“3ɠ‘

कोड-पृष्ठ सूचकांकों की पांच सूचियों की एक सूची है ( “...“...“...“...“...“...‘):

[[199,193,148,137,161,152,179,59,155,224,54,45,211,169,133,37,36,208,102,44,4,13,16,156,29,7,190,204,100,142],[167,225,226,149,207,145,5,171,76,106,158,126,172,114,6],[209,119,124,33,0,1,111],[210,157,183],[51,159]]

यह Zबाल्टी प्राप्त करने के लिए परमाणु का उपयोग करके स्थानांतरित किया जाता है ; इस B को कॉल करें:

[[199,167,209,210,51],[193,225,119,157,159],[148,226,124,183],[137,149,33],[161,207,0],[152,145,1],[179,5,111],[59,171],[155,76],[224,106],[54,158],[45,126],[211,172],[169,114],[133,6],37,36,208,102,44,4,13,16,156,29,7,190,204,100,142]

( 0और 1डमी कुंजी हैं, अनुमति देता है[179,5,111] आगे दाईं ओर दो होने की - संक्रमण को बाईं ओर होने के लिए लंबी प्रविष्टियों की आवश्यकता होती है)

2।

“£ẆJQ+k⁽’ḃ6¤+\;“£¬®µıñø"BƝ¤‘¤

इस C को बुलाओ (अध्याय गिना जाता है) - यह पूर्णांकों की सूची है:

[1,4,5,6,10,12,13,14,16,21,22,24,28,31,36,40,42,48,50,52,2,7,8,9,25,27,29,34,66,150,3]

और निम्नानुसार निर्माण किया जाता है (ऊपर दो डमी कुंजी इसलिए 10,12,13आरोही क्रम में रहने की अनुमति दें ):

“£ẆJQ+k⁽’ḃ6¤+\;“£¬®µıñø"BƝ¤‘¤
                            ¤ - nilad followed by link(s) as a nilad:
           ¤                  -   nilad followed by link(s) as a nilad:
“£ẆJQ+k⁽’                     -     base 250 number = 935841127777142
         ḃ6                   -     converted to bijective base 6 = [1,3,1,1,4,2,1,1,2,5,1,2,4,3,5,4,2,6,2,2]
            +\                -     cumulative reduce with addition = [1,4,5,6,10,12,13,14,16,21,22,24,28,31,36,40,42,48,50,52]
               “£¬®µıñø"BƝ¤‘  -   code-page indices = [2,7,8,9,25,27,29,34,66,150,3]
              ;               -   concatenate = [1,4,5,6,10,12,13,14,16,21,22,24,28,31,36,40,42,48,50,52,2,7,8,9,25,27,29,34,66,150,3]

अब कोड का सरलीकृत संस्करण है:

OP%⁽µW%⁽£İ%237 - Link 1, hash function: list of characters   e.g. "genesis"
O              - cast to ordinals             [103,101,110,101,115,105,115]
 P             - product                                    160493569871250
   ⁽µW         - base 250 literal                                      3338
  %            - modulo                                                1050
       ⁽£İ     - base 250 literal                                      1699
      %        - modulo                                                1050
           237 - literal                                                237
          %    - modulo                                                 102

Bċ€ÇTḢịC - Main link: list of characters                     e.g. "genesis"
B        - the list of buckets, B, described  in (1) above
   Ç     - call the last link as a monad (get the hashed value)         102
 ċ€      - count for €ach - yields 29 zeros and a one or 30 zeros       [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0]
    T    - truthy indexes - yields a list of length one or zero         [19]
     Ḣ   - head - extracts that value or zero if it was empty            19  ----------------------------------------------v
       C - the list of chapter lengths, C, described in (2) above       [1,4,5,6,10,12,13,14,16,21,22,24,28,31,36,40,42,48,50,52,2,7,8,9,25,27,29,34,66,150,3]
      ị  - index (the head value) into (the chapter list, c)             50
         -       - 1-indexed and modular so 0 yields 3 (the rightmost)

3

पायथन 2 , 438 429 416 411 409 बाइट्स

lambda s:[c for x,c in zip('A|m|C|h|2|th|2 Co|D|y|E|Ep|Ec|x|ze|G|Ge|H|gg|He|Ho|I|Jo|oe|oh|na|sh|Ju|dg|Ja|Je| J|1 J|K|2 K|L|Le|Lu|M|ch|rk|tt|N|Ne|Nu|O|P|Pr|Ph|pp|Pe|2 P|R|Ro|Ru|S|Sa|2 S|T| T|2 T| Ti|2 Ti|Z|Zep'.split('|'),(28,9,4,29,36,16,13,12,34,10,6,12,40,48,6,50,3,2,13,14,66,42,3,21,4,24,1,21,5,52,1,5,22,25,5,27,24,7,4,16,28,3,13,36,1,150,31,1,4,5,3,22,16,4,8,31,24,3,5,3,6,4,14,3))if x in s.title()][-1]

इसे ऑनलाइन आज़माएं!

टाइटल केस में इनपुट को बदलकर काम करता है, और सूची में अंतिम मिलान विकल्प ढूंढता है।

[('A', 28), ('m', 9), ('C', 4), ('h', 29), ('2', 36), ('th', 16), ('2 Co', 13), ...

उदाहरण के लिए। '1 samuel' -> '1 Samuel'जो मेल खाता है ('m', 9), ('2', 36), ('S', 8), ('Sa', 31), ('2 S', 24)। आखिरी मैच है ('2 S', 24), तो जवाब है24


3

6502 मशीन कोड (C64), 204 बाइट्स

00 C0 20 FD AE 20 9E AD 85 FD 20 A3 B6 A9 1E 85 FB A9 00 85 FC A8 B1 22 18 69
4A 65 FC 45 FB 85 FC E6 FB C8 C4 FD D0 EE A5 FC 4A 4A 4A 4A A8 A5 FC 29 0F 19
BA C0 A8 BE 3D C0 A9 00 4C CD BD 16 34 42 0D 01 00 04 03 04 1C 0A 00 06 15 07
00 16 00 22 03 02 0E 00 24 00 00 01 00 08 03 00 1C 03 01 00 00 00 00 00 03 03
00 00 00 24 10 1F 18 0E 10 00 00 00 32 30 1F 2A 00 0D 00 05 00 1B 00 0A 00 01
28 00 00 0C 96 00 10 00 00 00 18 00 00 03 00 00 00 00 00 00 15 09 00 05 00 04
00 00 04 00 00 04 00 00 18 00 1D 05 00 00 19 00 0D 00 00 06 06 0C 00 00 00 00
05 00 01 00 05 00 04 30 10 20 10 40 70 00 00 20 50 00 10 60 30 20

व्याख्या :

यहां कुंजी एक विशेष हैशिंग फ़ंक्शन का उपयोग करना है, जो कि मूल्यों के 0लिए टकराव के बिना मैप करता है125 *) करता है। अध्याय संख्याओं को तब 126 बाइट्स तालिका में रखा जाता है। हैशिंग पूरे 8 बिट्स में किया जाता है, अंतिम मूल्य को उच्च निबल्स को एक और तालिका में देखते हुए समायोजित किया जाता है, इस तरह से विभिन्न उच्च नीबल्स को मिलाकर जहां कम नीबल्स टकराते नहीं हैं।

यहाँ कोड भाग की एक असंतुष्ट सूची की टिप्पणी दी गई है:

.C:c000  20 FD AE    JSR $AEFD          ; consume comma
.C:c003  20 9E AD    JSR $AD9E          ; evaluate argument
.C:c006  85 FD       STA $FD            ; remember string length
.C:c008  20 A3 B6    JSR $B6A3          ; free string ....
.C:c00b  A9 1E       LDA #$1E           ; initial xor key for hash
.C:c00d  85 FB       STA $FB
.C:c00f  A9 00       LDA #$00           ; initial hash value
.C:c011  85 FC       STA $FC
.C:c013  A8          TAY
.C:c014   .hashloop:
.C:c014  B1 22       LDA ($22),Y        ; load next string character
.C:c016  18          CLC                ; clear carry for additions
.C:c017  69 4A       ADC #$4A           ; add fixed offset
.C:c019  65 FC       ADC $FC            ; add previous hash value
.C:c01b  45 FB       EOR $FB            ; xor with key
.C:c01d  85 FC       STA $FC            ; store hash value
.C:c01f  E6 FB       INC $FB            ; increment xor key
.C:c021  C8          INY                ; next character
.C:c022  C4 FD       CPY $FD            ; check for string length
.C:c024  D0 EE       BNE .hashloop      ; end of string not reached -> repeat
.C:c026   .hashadjust:
.C:c026  A5 FC       LDA $FC            ; load hash
.C:c028  4A          LSR A              ; shift left four times
.C:c029  4A          LSR A
.C:c02a  4A          LSR A
.C:c02b  4A          LSR A
.C:c02c  A8          TAY                ; and copy to y index register
.C:c02d  A5 FC       LDA $FC            ; load hash again
.C:c02f  29 0F       AND #$0F           ; mask low nibble
.C:c031  19 BA C0    ORA $C0BA,Y        ; and add high nibble from table
.C:c034  A8          TAY                ; copy to y index register
.C:c035  BE 3D C0    LDX .chapters,Y    ; load chapter number from table
.C:c038  A9 00       LDA #$00           ; accu must be 0 for OS function:
.C:c03a  4C CD BD    JMP $BDCD          ; print 16bit value in A/X

उसके बाद अध्याय संख्याओं की एक तालिका और अंत में हैश मान के लिए उच्च nibbles की एक तालिका।

ऑनलाइन डेमो

उपयोग: sys49152,"name" उदाहरण के लिए sys49152,"genesis"(आउटपुट 50)।

महत्वपूर्ण: यदि प्रोग्राम डिस्क से लोड किया गया था (जैसे ऑनलाइन डेमो में), तो newपहले एक कमांड जारी करें ! यह आवश्यक है क्योंकि मशीन प्रोग्राम लोड करने पर कुछ C64 बुनियादी बिंदुओं को चकरा देता है।

आवरण के बारे में संकेत: C64 के डिफ़ॉल्ट मोड में, इनपुट ऊपरी मामले के रूप में दिखाई देगा। यह है इस तथ्य छोटे अक्षरों में है, लेकिन C64 के दो स्वरूप हैं और डिफ़ॉल्ट ऊपरी में / ग्राफिक्स मोड, लोअरकेस वर्णों के रूप में अपरकेस और अपरकेस वर्णों ग्राफिक्स प्रतीक के रूप में दिखाई देते हैं दिखाई देते हैं।


*) बेशक, यह उतना घना नहीं है जितना यह हो सकता है ... ओह ठीक है, शायद मुझे बाद में और भी बेहतर समाधान मिल जाए;)


1

जावा 8, 623 597 590 बाइट्स

s->{int i=s.chars().map(c->c*c*c).sum()/13595;return s.contains("tt")?28:i<258?42:i<355?1:i<357?3:i<362?16:i<366?28:i<369?21:i<375?9:i<377?24:i<380?5:i<382?1:i<386?10:i<402?7:i<436?4:i<438?5:i<439?14:i<461?3:i<463?2:i<477?22:i<478?25:i<490?5:i<491?3:i<493?12:i<500?66:i<545?3:i<546?1:i<548?21:i<562?4:i<568?24:i<570?10:i<572?31:i<573?24:i<582?16:i<583?150:i<607?40:i<629?48:i<639?50:i<663?13:i<675?3:i<677?36:i<679?52:i<734?1:i<735?6:i<736?4:i<775?14:i<785?6:i<796?3:i<800?31:i<812?6:i<876?27:i<910?29:i<911?36:i<940?22:i<1018?4:i<1035?16:i<1036?13:i<1066?12:i<1092?34:i<1229?5:i<1230?3:8;}

-7 बाइट्स @Nevay को धन्यवाद को एक स्ट्रीम के लिए लूप को बदलकर ।

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

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

  1. इनपुट स्ट्रिंग में प्रत्येक वर्ण के 3 (ASCII मान के रूप में) की शक्ति लेता है
  2. का योग लेता है
  3. द्वारा परिणाम विभाजित करता है 13595 को पूर्णांक विभाजन के रूप में (जावा में यह स्वचालित रूप से परिणाम को छोटा / फर्श कर देता है)।
  4. यह 65 अद्वितीय मान छोड़ता है (केवल habakkukऔर matthewदोनों का मान है 674)
  5. और फिर एक विशाल टर्नरी-अगर सही परिणाम वापस करने के लिए (कुछ मूल्यों के साथ एक ही टर्नरी-बयान में संयोजन करना जहां संभव हो ( 381और 382दोनों 1; 425और 436दोनों 4; 649और 663दोनों 13; 952और 1018दोनों 4; 1122और 1229दोनों 5)।

1
आप उपयोग कर सकते हैं int i=s.chars().map(c->c*c*c).sum()/13595;के बजाय int i=0;for(int c:s.getBytes())i+=c*c*c;i/=13595;
नेवय
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.