तत्वों की आवर्त सारणी - कोड गोल्फ

Question

प्रैक्टिकल गोल्फ पर आधारित - यूएस स्टेट्स

आपका कार्य तत्व नाम दिया गया तत्व का संक्षिप्त नाम (प्रतीक) ढूंढना है, जो यूनोक्टियम (118) को शामिल और शामिल करता है। विकिपीडिया पर आवर्त सारणी का प्रयोग करें ।

Ossifrage के लिए धन्यवाद, आप तत्वों की पूरी सूची http://pastebin.com/DNZMWmuf पर देख सकते हैं ।

आप किसी भी बाहरी संसाधनों का उपयोग नहीं कर सकते हैं। इसके अलावा, आप विशेष रूप से आवर्त सारणी के तत्वों के बारे में किसी भी अंतर्निहित डेटा का उपयोग नहीं कर सकते हैं। मानक खामियां लागू होती हैं।

इनपुट

इनपुट स्टडिन, फ़ाइल prompt, inputआदि से हो सकता है ।

इनपुट प्रारूप:

निम्नलिखित सभी मान्य इनपुट हैं:

Carbon
carbon
CARBON
cArBOn

अनिवार्य रूप से, तत्व नाम - केस असंवेदनशील।

आपको गलत वर्तनी या किसी भी अमान्य तत्व नाम को संभालने की आवश्यकता नहीं है। अमान्य इनपुट अपरिभाषित व्यवहार है।

आउटपुट :

तत्व के लिए प्रतीक। पहले वर्ण को बड़ा किया जाना चाहिए और बाकी को छोटा किया जाना चाहिए।

उदाहरण आउटपुट: C

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

Carbon -> C
NiTROGen -> N
Sodium -> Na
Gold -> Au
Silver -> Ag
Tin -> Sn

राज्यों की तुलना में कई अधिक तत्व हैं, इसलिए मुझे उम्मीद है कि इसके लिए एक सामान्य नियम खोजना कठिन होगा।

यह कोड गोल्फ है। सबसे छोटा कोड जीतता है!

Comments

@squeamishossifrage धन्यवाद। दोनों संस्करण ("सल्फर" और "सल्फर") स्वीकार्य हैं। हालांकि, आपके कार्यक्रम को केवल एक को संभालने की जरूरत नहीं है।

— 20

... regexes के साथ करना असंभव है। आपने हमें अच्छा किया।

— जोशिया विंसलो

@Xrylite नियमों को पढ़ने का प्रयास करें : " इनपुट ... तत्व नाम - केस असंवेदनशील ... आउटपुट ... पहले वर्ण को कैपिटल किया जाना चाहिए और बाकी को कम किया जाना चाहिए"।

— जिम बाल्टर

अमेरिका की वर्तनी (एल्युमिनियम) बनाम उचित वर्तनी (एल्युमिनियम) के बारे में क्या?

— पॉल आर

@codebreaker हाँ, यदि इनपुट मान्य नहीं है, तो आपका प्रोग्राम क्रैश हो सकता है, हैंग हो सकता है, प्रिंट हो सकता है Au, या आप जो चाहें कर सकते हैं। @ पाॅल आर यदि किसी तत्व को वर्तनी देने के कई तरीके हैं (जैसे सल्फर बनाम सल्फर या एल्यूमीनियम बनाम एल्यूमीनियम) जो भी आपके कार्यक्रम को छोटा बनाता है। आपको दोनों मामलों को संभालने की आवश्यकता नहीं है।

— soktinpk

Answer 1

CJam, 337 297 293 232 220 201 200 बाइट्स

leu:E2f^3b2+4%_"53N5903CVCT4":i3/=~Ef+b\%]53b"gØâ^ÃP·^À4ξ^ß^E5^W^Ma{áª^B¤±´oòæ»^XÊQÑ»4žDÙÝòÙ 0^ÝþKa6^Ó£,Ûkû¥¡ùh^E"256b7b6a/0a3**<)5md@5a/,(" ¬^GH/N¿·%^U^RU1²Bd
òë^м~í^ÌéáU"256b25b'Af+2/='J-'Q/"UU"*\)_5=)*E%2<?(\el

उपरोक्त कोड कैरट नोटेशन का उपयोग करता है, क्योंकि इसमें नियंत्रण वर्ण हैं।

24 अतिरिक्त बाइट्स (कुल 224 के लिए) की लागत पर, उन पात्रों से बचा जा सकता है।

leu:E2f^3b2+4%_"53N5903CVCT4":i3/=~Ef+b\%]53b
"' NwEvKv6e8@]jO4G)=b{L!v@hFQ/oCN)*|BRxvNRL+LO7NI(pLs4[d87$Q%8R\t+' M5JU"
{32f-95b}:B~7b6a/0a3**<)5md@5a/,(
"&y.$h*z^t\rQPUc]l8F h$=18C^r|vD~S"
B25b'Af+2/='J-'Q/"UU"*\)_5=)*E%2<?(\el

आप इस कोड को CJam दुभाषिया में आज़मा सकते हैं ।

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

$ base64 -d > elements.cjam <<< bGV1OkUyZl4zYjIrNCVfIjUzTjU5MDNDVkNUNCI6aTMvPX5FZitiXCVdNTNiImfY4oNQt4A0zr6fBTUXDWF74aoCpLG0b/LmuxjKUdG7NMW+RNnd8tmgMJ3+S2E2k6Ms22v7paH5aAUiMjU2YjdiNmEvMGEzKio8KTVtZEA1YS8sKCIgrAdIL06/tyUVElUxskJkCvLrkLx+7Yzp4VUiMjU2YjI1YidBZisyLz0nSi0nUS8iVVUiKlwpXzU9KSpFJTI8PyhcZWw=
$ cksum elements.cjam 
952664534 200 elements.cjam
$ for e in Carbon NiTROGen Sodium Gold Silver Tin; do LANG=en_US cjam elements.cjam <<< $e; echo; done
C                                                                                                       
N                                                                                                       
Na                                                                                                      
Au                                                                                                      
Ag                                                                                                      
Sn

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

पहला कदम एसटीडीआईएन से तत्व नाम को पढ़ना है और एक विस्तृत रूप से हैश फ़ंक्शन को लागू करना है, जो सभी तत्व नामों को श्रेणी [0, 225] में मैप करता है :

l eu :E          " Read a line from STDIN, convert to uppercase and save in E.            ";
2 f^             " XOR each character code with 2.                                        ";
3 b              " Convert to integer; consider the resulting array a base 3 number.      ";
2 + 4 %          " Add 2 and take the result modulo 4. Result: R                          ";
"53N5903CVCT4":i " Push [53 51 78 53 57 48 51 67 86 67 84 52].                            ";
3 / =            " Retrieve the chunk of length 3 that corresponds to R. Result: C        ";
~ E f+           " Add C[2] to all character codes of E.                                  ";
b                " Convert to integer; consider the resulting array a base C[1] number.   ";
\ %              " Take the integer modulo C[0]. Result: M                                ";
] 53 b           " Push H := 53 * R + M.                                                  ";

तत्व के अंग्रेजी नाम के पहले और दूसरे, पहले और तीसरे, पहले और चौथे, पहले और पांचवें और पहले या दसवें (जो कि सिर्फ पहला है) चरित्र द्वारा कई तत्व प्रतीकों का गठन किया जाता है। हम क्रमशः 0 से 4 तक संख्याओं द्वारा इन तत्वों का प्रतिनिधित्व करने जा रहे हैं। सभी शेष तत्वों (5 द्वारा दर्शाए गए) को लुकअप टेबल की आवश्यकता होगी।

परिणामी तालिका को निम्नानुसार धकेला जा सकता है:

"gØâ^ÃP·^À4ξ^ß^E5^W^Ma{áª^B¤±´oòæ»^XÊQÑ»4žDÙÝòÙ 0^ÝþKa6^Ó£,Ûkû¥¡ùh^E"256b7b6a/0a3**

चरित्र कोड की सरणी को बेस 256 से बेस 7 और 6 में बदल दिया जाता है और इसे तीन 0 के रन से बदल दिया जाता है।

यह निर्णय तालिका D है:

[4 0 0 0 1 0 0 0 0 0 0 3 0 2 0 1 0 0 0 0 0 0 0 0 4 1 1 0 0 0 0 2 0 4 0 5 2 0 0 3 4 0 0 0 0 4 0 1 0 0 3 1 0 0 2 1 1 1 0 0 0 1 0 5 5 0 0 2 0 0 0 5 5 0 0 0 5 0 3 0 0 0 0 5 0 0 0 0 0 0 0 0 5 2 3 0 1 0 5 0 4 0 0 0 0 4 0 5 0 0 0 0 0 5 0 0 0 2 5 1 4 1 5 0 0 0 5 0 0 5 1 1 0 0 0 0 0 0 2 0 5 0 0 0 3 1 0 2 0 0 0 2 0 0 0 5 0 0 0 0 1 0 0 0 0 0 4 0 2 2 5 2 0 0 5 1 0 0 0 0 4 0 5 0 0 3 5 0 0 5 0 1 0 0 0 2 0 0 0 0 0 5 0 4 0 0 0 0 0 0 0 0 3 0 4 0 0 1 2 2 0 0 0 0 0]

हैश 1 के साथ तत्व के लिए आवश्यक कार्रवाई , उदाहरण के लिए, इस सरणी के पहले तत्व से मेल खाती है। किसी भी तत्व के हैश के अनुरूप नहीं होने वाले ऐरे तत्व भी शून्य हैं, जो (0 0 0) compression 6 संपीड़न की अनुमति देता है ।

अब, हम हैश एच के लिए डी की व्याख्या करते हैं।

< ) 5 md     " Push D[:H-1] (D[H-1] / 5) (D[H-1] % 5).                                    ";
@ 5a / , (   " Count the number of 5's in D[:H-1] (by splitting at [5]). Result: I        ";

अगला, हम लुकअप टेबल को धक्का देते हैं। यदि हम j को एकल-वर्ण प्रतीकों में जोड़ते हैं और U को Q से प्रतिस्थापित करते हैं, तो प्रत्येक प्रतीक ठीक दो वर्ण लंबा होगा। इसे निम्नानुसार धकेला जा सकता है:

" ¬^GH/N¿·%^U^RU1²Bd
òë^м~í^ÌéáU"256b25b'Af+2/

वर्ण कोड की सरणी को आधार 256 से 25 में बदल दिया जाता है, A का वर्ण कोड सभी अंकों में जोड़ा जाता है (प्रक्रिया में वर्ण के लिए कास्टिंग) और परिणाम दो लंबाई के विखंडू में विभाजित होता है।

यह लुकअप टेबल L है:

["QP" "YB" "PD" "SN" "QO" "QT" "QS" "SB" "KJ" "TM" "FE" "PB" "AU" "WJ" "CN" "SG" "RF" "CM" "CU" "HG" "NA" "RG" "AG"]

अब, हम संभावित तत्व नामों की गणना करने के लिए आगे बढ़ते हैं।

=                " Push L[I].                                                             ";
'J - 'Q / "UU" * " Remove J's and replace Q's with runs of two U's.                       ";
\ ) _ 5 = ) *    " Push S := (D[H-1] % 5 + 1) * ((D[H-1] % 5 + 1 == 5) + 1).              ";
E %              " Push every Sth character of E.                                         ";
2 <              " Discard all but the first two characters.                              ";

ढेर अब शामिल है

B M N

जहाँ B बूलियन D [H-1] / 5 है , M लुकिंग टेबल से प्राप्त नाम है, N , E से वर्णों को चुनकर बनाया गया तत्व नाम है।

हम लगभग पूरा कर चुके हैं:

?                " If B, push M; else, push N.                                            ";
( \              " Extract the first character from the string.                           ";
el               " Convert the rest to lowercase.                                         ";

Comments

लेकिन ये कैसे काम करता है?

— Claudiu

@ कलौइडु: मैंने एक स्पष्टीकरण जोड़ा है।

— डेनिस

मैंने स्पष्टीकरण के पहले तीसरे को पढ़ा है, और अब तक मेरे पास "मैजिक" है। अतुल्य

— 21-21

"AcAlAmSbArAsAtBaBkBeBiBhBBrCdCsCaCfCCeClCrCoCnCuCmDsDbDyEsErEuFmFlFFrGdGaGeAuHf HsHeHoHInIIrFeKrLaLrPbLiLvLuMgMnMtMdHgMoNdNeNpNiNbNNoOsOPdPPtPuPoKPrPmPaRaRnReRh RgRbRuRfSmScSgSeSiAgNaSrSTaTcTeTbTlThTmSnTiWUuoUupUusUutUVXeYbYZnZr" = 226 वर्ण। आपका समाधान = 200 वर्ण। यहाँ कुछ उचित वूडू चल रहा है।

— स्क्विश ओस्सिफ्रेज

मैंने इस उत्तर को स्वीकार कर लिया है क्योंकि यह सबसे छोटा प्रतीत होता है लेकिन अतिरिक्त उत्तर पोस्ट करने के लिए स्वतंत्र महसूस करता है।

— soktinpk

Answer 2

सी, 452

एक अच्छा हैश फ़ंक्शन मदद करता है। और बेहतर हो सकते हैं। ( @Ugoren एट अल द्वारा सुझाए गए सुधार ।)

h;main(c){char*p="Sn)Cu&V$U#Mo#Rf#Sg&Cs#Y+FTa%Rb)S'Nd#GaK&Mg'Zr$PtPm%ReUuo#SmDy(Ac$Lu%W&CaRa(Cf)EuB#Ds%Md$Uus*NpIn$H&YbIr*BeEs*Tc#I(FlRuC#ThSrBh/NaCoLrKr&Nb$CePb$Ne'Am)At*PdLa#Tl%HgMt,CrTbBk$Rh&Rn4TeZn$HfAg%Fm)Xe$AlScFePo$As'HeO#LvN&DbGe#Ho&Mn$Cd+Ni$Rg$HsBr$AuSi#Pr&Uup#Se*Ti#Tm$Er$Sb&PPu&Cm$GdBa'Cn&UutLiFr#Ar#Bi#NoOs%Pa4Cl";while((c=getchar())>64)h=(h+c%32+74)*311%441;while(h)if(*p<65?h-=*p++-34,0:1)for(h--;*++p>96;);do putchar(*p++);while(*p>96);}

टिप्पणियों के साथ अपुष्ट:

int h;
main(c) {

  /* Hashed element symbols. Characters #$% etc. are used as padding: */
  char *p="Sn)Cu&V$U#Mo#Rf#Sg&Cs#Y+FTa%Rb)S'Nd#GaK&Mg'Zr$PtPm%ReUuo#SmDy(Ac$Lu%W&C"
          "aRa(Cf)EuB#Ds%Md$Uus*NpIn$H&YbIr*BeEs*Tc#I(FlRuC#ThSrBh/NaCoLrKr&Nb$CeP"
          "b$Ne'Am)At*PdLa#Tl%HgMt,CrTbBk$Rh&Rn4TeZn$HfAg%Fm)Xe$AlScFePo$As'HeO#Lv"
          "N&DbGe#Ho&Mn$Cd+Ni$Rg$HsBr$AuSi#Pr&Uup#Se*Ti#Tm$Er$Sb&PPu&Cm$GdBa'Cn&Uu"
          "tLiFr#Ar#Bi#NoOs%Pa4Cl";

  /* This hash function gives a unique result for each element: */
  while((c=getchar())>64) h=(h+c%32+74)*311%441;

  /* Find the corresponding position in the hashed data */
  while(h) {
    if(*p<65?h-=*p++-34,0:1) {      /* Step over an abbreviation */
      for(h--;*++p>96;);            /* Skip padding */
    }
  }

  /* Output first uppercase character and all following lowercase characters: */
  do {
    putchar(*p++);
  } while(*p>96);
}

मैंने इस हैश को खोजने के लिए क्रूर बल का इस्तेमाल किया; यह that512 के हैश आकार वाला एकमात्र ऐसा था जिसमें कोई टक्कर नहीं थी। मैंने हालांकि वैकल्पिक वर्तनी की जाँच नहीं की, और अलग-अलग एल्गोरिदम के साथ बेहतर कार्य हो सकते हैं (जैसे इसके अलावा XOR का उपयोग करना)।

हैश फ़ंक्शन टेक्स्ट स्ट्रिंग्स को 0 से 440 तक मान देता है। "टिन" हैश टू जीरो, इसलिए "एसएन" टेबल की शुरुआत में है। अगले 7 पद खाली हैं। कोड को कॉम्पैक्ट रखने के लिए, यह ASCII मूल्य 34 + 7 = 41 (")") से संकेत मिलता है। इसके बाद "कॉपर" (8), चार खाली कोशिकाएं (34 + 4 = 38 = "&"), और "वैनेडियम" (13) आता है। एक हैश की गणना करने के बाद, प्रोग्राम टेबल के माध्यम से कदम रखता है, प्रत्येक कैपिटल लेटर के लिए 1 को घटाकर 0 या उससे अधिक लोअरकेस अक्षर, और सब-वर्णमाला वर्ण के लिए घटाना (ASCII VALUE) -34। जब मूल्य शून्य तक पहुंचता है, तो हमें सही परिणाम मिला है।

Comments

@soktinpk ब्रूट ने मजबूर किया :-) यह that512 के हैश आकार के साथ एकमात्र ऐसा था जिसमें कोई टक्कर नहीं थी। मैंने हालांकि वैकल्पिक वर्तनी की जाँच नहीं की, और अलग-अलग एल्गोरिदम के साथ बेहतर कार्य हो सकते हैं (जैसे इसके अलावा XOR का उपयोग करना)।

— स्क्विश ऑस्फीराज

कि 464 बनाओ ... आपके पास ब्रेसिज़ की एक अनावश्यक जोड़ी है।

— जिम बेल्टर

यदि आप व्याकरण के बारे में सोचते हैं, तो यह असंदिग्ध है और इसे अनुमति दी जानी चाहिए ... यह सिर्फ हमें अस्पष्ट लगता है । ओह, और आपने एक और पकड़ा जो मैंने नहीं किया था! इस पर बधाई ... मैंने एल्गोरिदम को कसने की बहुत कोशिश की लेकिन आपको सब कुछ सही मिला।

— जिम बाल्टर

@ हर्षदीप - हैश फ़ंक्शन टेक्स्ट स्ट्रिंग्स को 0 से 440 तक मैप करता है। "टिन" हैश टू जीरो है, इसलिए "एसएन" टेबल की शुरुआत में है। अगले 7 पद खाली हैं। कोड को कॉम्पैक्ट रखने के लिए, यह ASCII मूल्य 34 + 7 = 41 (")") द्वारा इंगित किया गया है। इसके बाद "कॉपर" (8), चार खाली कोशिकाएँ (34 + 4 = 38 = "&"), और "वैनेडियम" (13) आता है। एक हैश की गणना करने के बाद, प्रोग्राम टेबल के माध्यम से कदम रखता है, प्रत्येक कैपिटल लेटर के लिए 1 को घटाकर 0 या उससे अधिक लोअरकेस अक्षर, और सब-वर्णमाला वर्ण के लिए घटाना (ASCII VALUE) -34। जब मूल्य शून्य तक पहुंच जाता है, तो हमें सही परिणाम मिला है।

— स्क्विश ओस्सिफ्रेज

अच्छा है। के साथ कुछ वर्ण सहेजें: 1 (h+c%32+74)*311%441.। 2. ड्रॉप pऔर उपयोग s। 3. main(c)एक अल्पविराम बचाता है।

— 21

Answer 3

जावास्क्रिप्ट ईएस 6, 690 708 बाइट्स

for(n=prompt()[l='toLowerCase'](i=0);!(c='HHeLiBeBCNFNeNaMgAlSiPSClArKCaScTiVCrMnFeCoNiCuZnGaGeAsSeBrKrRbSrYZrNbMoTcRuRhPdAgCdInSnSbTeIXeCsBaLaCePrNdPmSmEuGdTbDyHoErTmYbLuHfTaWReOsIrPtAuHgTlPbBiPoAtRnFrRaAcThPaUNpPuAmCmBkCfEsFmMdNoLrRfDbSgBhHsMtDsRgCnUutFlUupLvUusUuo'.match(x=/[A-Z][a-z]*/g)['HyHeLitBeryBorCarNitFluNeonSoMagAlSiliPhSuChlArgPotCalcScTitVChrManIroCobNicCoppZinGalGeArsSelBrKRubStYttrZirNioMoTecRuthenRhoPaSilvCadInTinAnTelIoXCaeBaLanCePraNeodPromSaEuGadTerDyHoErThuYtteLuHafTaTuRheOsIriPlaGoMerThaLeBiPolAsRadoFrRadiAcThoProtUrNepPluAmCuBerkCaliEiFeMenNoLawRutherDuSeaBohHasMeiDaRoCopeUnuntFleUnunpLivUnunsUnuno'.match(x).map(a=>a[l]()).indexOf(n.slice(0,i++))]);)
alert(c)

पहला सरणी प्रतीकों को रखता है, और दूसरा सरणी न्यूनतम अक्षरों को बताता है कि किस तत्व को संदर्भित किया जा रहा है। इसे छोटा करने के लिए core1024 और edc65 का धन्यवाद। टेस्ट http://jsfiddle.net/xjdev4m6/2/ । थोड़ा अधिक पठनीय:

n=prompt().toLowerCase()
e='HyHeLitBeryBorCarNitFluNeonSoMagAlSiliPhSuChlArgPotCalcScTitVChrManIroCobNicCoppZinGalGeArsSelBrKRubStYttrZirNioMoTecRuthenRhoPaSilvCadInTinAnTelIoXCaeBaLanCePraNeodPromSaEuGadTerDyHoErThuYtteLuHafTaTuRheOsIriPlaGoMerThaLeBiPolAsRadoFrRadiAcThoProtUrNepPluAmCuBerkCaliEiFeMenNoLawRutherDuSeaBohHasMeiDaRoCopeUnuntFleUnunpLivUnunsUnuno'.match(x=/[A-Z][a-z]*/g).map(a=>a.toLowerCase())
s='HHeLiBeBCNFNeNaMgAlSiPSClArKCaScTiVCrMnFeCoNiCuZnGaGeAsSeBrKrRbSrYZrNbMoTcRuRhPdAgCdInSnSbTeIXeCsBaLaCePrNdPmSmEuGdTbDyHoErTmYbLuHfTaWReOsIrPtAuHgTlPbBiPoAtRnFrRaAcThPaUNpPuAmCmBkCfEsFmMdNoLrRfDbSgBhHsMtDsRgCnUutFlUupLvUusUuo'.match(x)
for(i=0;i<7;i++){
  if(c=s[e.indexOf(n.slice(0,i))]){
    alert(c,i=8) // i=8 breaks out of the loop so the result is only alerted once
  }
}

Comments

क्या आप इस तथ्य का उपयोग करके कुछ बाइट्स निकाल सकते हैं कि नियो नियोडिमियम से मेल खाता है, यह देखते हुए कि नियॉन को सूची में पारित किया गया है?

— 1

@ डनक्रंब दुर्भाग्य से नहीं। लूप सबसे छोटी सबस्ट्रिंग से शुरू होता है, इसलिए यह हिट Neoहोने से पहले ही हिट हो जाएगा Neonक्योंकि इसमें कम अक्षर हैं।

— निंजाबियरनॉकिज

अब तक के सबसे छोटे जेएस के लिए +1। यद्यपि आप इस ifकथन से छुटकारा पा सकते हैं (यह एक आदर्श forस्थिति है) और कोड को छोटा करने के लिए कुछ चर के इनलाइन या

— बदलावों

शुरुआत में ).toLowerCase(-> )[L='toLowerCase'](फिर अंत में a.toLowerCase(-> a[L](4

— चार्ट में

Answer 4

रूबी 1.9+, 565 471 447 444

एक लाइनर। क्योंकि कुछ भी "regexes के साथ करना असंभव है" ...
(बस एक और regex जोड़कर 94 वर्णों को बचाया) ((और उन्हें सरल करके 24)

p"VAlAmA.sArAcAnt|SbA.tBaB..kBeBiB.hBrBDyD.+sD.bE..sErEuF..mFrFlu|[e-mail]|AuH.fH.sHeHoHInIro|FeIrIKrL.vL.+rLaLiLuL|PbM.gMoM.+dM.nM.+tM|HgC.+sC.dC.+fCeCar|C@C....nCaCu|CmCop|CuCoC.rC.lN.+dN.+pNeN..bNit|N@NoNiOsOP..mPa|PdP...aPrP.uP..tPot|KPoPR.*n$RaR.+gR.eRhR.+bR.+fRuS.mScS.+gSeS..v|AgSiSo|NaS.rSTaT.cT.+bTeThu|TmT..lThTin|SnTiTu|WU.u.oU.u.pU.u.sU.u.tUXeY.+bYZ.nZ.r"
.split(/(?<!\|)(?=[A-Z])/).find{|r|/^#{r}/i.match *$*}.gsub /.*\||\W/,''

(नई पठनीयता "पठनीयता" के लिए जोड़े जाने के बाद, परीक्षण के लिए हटा दें)

उपयोग: ruby periodic.rb aluminum$>

स्पष्टीकरण:
प्रमुख राजधानियों पर स्ट्रिंग को विभाजित करने से तत्व नामों के विरुद्ध मिलान करने के लिए रेगेक्स की एक सरणी मिलती है। प्रत्येक में अनुमति दिए गए केवल अक्षर अक्षर संक्षिप्त नाम * से हैं। उन्हें ऐसा आदेश दिया जाता है कि कमांड लाइन तर्क की तुलना करते समय पाया गया पहला मैच *$*सही है। अनुगामी gsub मुद्रण से पहले गैर-अल्फा वर्णों को स्ट्रिप्स करता है।

* "आयरन" के लिए "Fe" जैसे अजीब संक्षिप्त |तत्व एक तत्व द्वारा संभाले जाते हैं : "Iro | Fe"। पहली पसंद वह है जो वास्तव में मेल खाता है; gsub तब वास्तविक वर्ण को छोड़कर सभी वर्णों को '|' तक हटा देता है।

टेस्ट फ्रेमवर्क ( @ स्क्वीम की सूची की आवश्यकता है : कार्यशील निर्देशिका में 'table.txt' के रूप में डाउनलोड किया गया)।

def testfunc(name) 
  #replace with however you call your code
  return `ruby1.9.3 periodic2.rb #{name}`.chomp()
end

elements= File.new('table.txt').readlines.map{|s|s.chomp}

elements.each{|l|
  a,n=l.split(' ')
  r = testfunc(n)
  print "#{n} => #{a} "
  if r!=a then
    print ("FAIL: gave #{r}\n")
    exit
  else 
    print("\tOK\n")
  end
}
print("PASS: #{elements.size} elements matched\n")

Comments

स्टैंडिंग

— ओवेशन

बेशक यह काम करता है: ideone.com/7FZlAt

— AShelly

किसी के पास यह बताने की धृष्टता है कि कुछ regex के साथ नहीं किया जा सकता है। उन्हें साबित करने के लिए धन्यवाद (एक ने कहा, कई विचार) गलत :)

— मस्तूल

Answer 5

रूबी, 1068 बाइट्स

require"zlib"
require"base64"
$><<eval(Zlib::Inflate.inflate(Base64.decode64"eJwlU8tu2zAQ/Bee+QW6CLYTx0FiR7CdtsmNkmhJCEUKfKQViv57Z9YnE+vd2ZnZ0d+1j2Go6oO2bipzpQ5W6SmPU6nU66S0jatzldqiGmLwVb3VJrZ87NAmoyf9Zx0sKm/alRCnqt5riw514lAvqCejtBm8TZU6Dgp984SGjcMuN3WhUhfsGkNaxqpudHG3Eqv6okdHPLVDXxwIuYmAzCalqn7RxnWkuQN2Z3yPxktH8sbjeQWg8QbV+oceY5iJE1kbDICOHpBE3JNka1zG3wHT3ZeF3hOmw7LYiGpB1XeV+sSIcY4rnwydmQn0hPmYLFduEqpOnhdWg4jcYmlclwyRL3iWdiLTc6s07PNYe0E15wjc+kNPsSOrT9Sm0HLXCZ3BrW0P0iBou9FbyIPSkkfYrs6F1vXsPY9C0aC36entNxVs4LjpZ/EKVX8/ybOnLqzHr8/TzCO0FODgvbreb4dV9bO2npx+oWSTzO6g1ER5bnlZn0eDvIgr9wbqN8kCtIEUG/qVKejFFQvRzYyx2fC6FzxLDAuej4VMg8PzqSeYOHAFrTUtEWAPK80QKQeYwf+B+4gVY5HLXGeaicFKfbS0yGaAvRL35mXsJnwNjnwF3+KHlKv6p4aV4iCIp1lQ3yAyTuLrMxY4k2lXk8kABm8KCXY06wCDR0YDmIiqFf+xfUpzgdYtw+QCc9GAdMqGnDZZtPKAzKLxHYp7JvR+nzNjjZVs7XjhKPpGWpgN8tgYGWNu3rVdcuEnt/DjykRtwG/GOdC5EYfvh5nJWjK+/WJYphts3d2YhZQRrMck0eauPXt9z95jz6/EUuEJEszvyOS9xnsIYcH5xmiLhQ9MkWkDqhcYE0YhvmU0U5ITcMWUGeMjTYgzTqAeUA3W5wFgHMPHhxU7prP4DLD3gmZnY/gGNSflxbIMzROCDnWv31JOUk7yDh3fQf37D7D/kWs="))[gets.downcase[1..5].to_sym]

इनपुट STDIN के माध्यम से।

तत्व नामों का सबसे छोटा अद्वितीय पदार्थ दूसरे से छठे वर्ण तक (या नाम का अंत अगर इसकी बहुत छोटी है)। तो मैं बस उन हो रही है और उन्हें एक हैश में देख रहा हूँ। मैंने हैश को भी संकुचित कर दिया है क्योंकि यह 200 बाइट्स बचाता है। यहाँ हैश ही जैसा दिखता है:

{ydrog:?H,elium:"He",ithiu:"Li",eryll:"Be",oron:?B,arbon:?C,itrog:?N,xygen:?O,luori:?F,eon:"Ne",
 odium:"Na",agnes:"Mg",lumin:"Al",ilico:"Si",hosph:?P,ulfur:?S,hlori:"Cl",rgon:"Ar",otass:?K,
 alciu:"Ca",candi:"Sc",itani:"Ti",anadi:?V,hromi:"Cr",angan:"Mn",ron:"Fe",obalt:"Co",ickel:"Ni",
 opper:"Cu",inc:"Zn",alliu:"Ga",erman:"Ge",rseni:"As",eleni:"Se",romin:"Br",rypto:"Kr",ubidi:"Rb",
 tront:"Sr",ttriu:?Y,ircon:"Zr",iobiu:"Nb",olybd:"Mo",echne:"Tc",uthen:"Ru",hodiu:"Rh",allad:"Pd",
 ilver:"Ag",admiu:"Cd",ndium:"In",in:"Sn",ntimo:"Sb",ellur:"Te",odine:?I,enon:"Xe",esium:"Cs",
 arium:"Ba",antha:"La",erium:"Ce",raseo:"Pr",eodym:"Nd",romet:"Pm",amari:"Sm",uropi:"Eu",
 adoli:"Gd",erbiu:"Tb",yspro:"Dy",olmiu:"Ho",rbium:"Er",huliu:"Tm",tterb:"Yb",uteti:"Lu",
 afniu:"Hf",antal:"Ta",ungst:?W,heniu:"Re",smium:"Os",ridiu:"Ir",latin:"Pt",old:"Au",ercur:"Hg",
 halli:"Tl",ead:"Pb",ismut:"Bi",oloni:"Po",stati:"At",adon:"Rn",ranci:"Fr",adium:"Ra",ctini:"Ac",
 horiu:"Th",rotac:"Pa",raniu:?U,eptun:"Np",luton:"Pu",meric:"Am",urium:"Cm",erkel:"Bk",alifo:"Cf",
 inste:"Es",ermiu:"Fm",endel:"Md",obeli:"No",awren:"Lr",uther:"Rf",ubniu:"Db",eabor:"Sg",
 ohriu:"Bh",assiu:"Hs",eitne:"Mt",armst:"Ds",oentg:"Rg",opern:"Cn",nuntr:"Uut",lerov:"Fl",
 nunpe:"Uup",iverm:"Lv",nunse:"Uus",nunoc:"Uuo"}

Answer 6

CJam, 462 449 434 401 391 384 382

डेनिस की मदद से।

कोड

नेस्ट त्रिगुट आईएफएस हैं शायद CJam में यह करने के लिए सही तरीके से नहीं।

rel_"ruthen"#!"Ru"{_"tel"#!"Te"{__5{\_ceu\@=+_}:U~"PdYbRgCmCn"{\#)!}:X~{;__4U"RnPaCfDs"X{;_3U"NbCsNdPmTbPtTlBkEsFmMdLrMt"X{;2U"MgClCrMnZnAsRbSrZrTcCdSmGdHfReAtNpPuDbBhHsLv"X{;__"sili"#{;__ceu\1=@2=++"SodIroCopSilTinAntThuGolMerLeaTunPotRutSeaHydBorCarNitOxyFluPhoSulVanYttIodUra"\#3d/m[)"_NaFeCuAgSnSbTmAuHgPbWKRfSgHBCNOFPSVYIU"S%\=_"_"={;_1U"Un"={;4="Uu"\+}*}*}"Si"?}*}*}*}*}?}?]W=

इंडेंट के साथ:

rel
_"ruthen"#!"Ru"
{
_"tel"#!"Te"
{
  __5{\_ceu\@=+_}:U~
  "PdYbRgCmCn"{\#)!}:X~
  {
   ;__4U
   "RnPaCfDs"X
   {
    ;_3U
    "NbCsNdPmTbPtTlBkEsFmMdLrMt"X
    {
     ;2U
     "MgClCrMnZnAsRbSrZrTcCdSmGdHfReAtNpPuDbBhHsLv"X
     {

       ;__"sili"#
       {
        ;__ceu\1=@2=++"SodIroCopSilTinAntThuGolMerLeaTunPotRutSeaHydBorCarNitOxyFluPhoSulVanYttIodUra"\#3d/m[)"_ Na Fe Cu Ag Sn Sb Tm Au Hg Pb W K Rf Sg H B C N O F P S V Y I U"S%\=_"_"=
        {;_1U"Un"={;4="Uu"\+}*}*
       }
      "Si"?

     }*
    }*
   }*
  }*
 }?
}?
]W=

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

कुछ ऐसे हैं जहां यह भ्रमित हो जाता है ( TelLuriumबनाम ThaLlium, या SILiconबनाम SILver, या RUTheniumबनाम RUTherfordium)। इन्हें अलग से संभाला जाता है।

यहां बहुत से गोल्फिंग किए जा सकते हैं, ज्यादातर कोड ब्लॉक का पुन: उपयोग करके और अनियमितताओं से निपटने में सुधार करते हैं।

Comments

कुछ सुझाव: 1. अमान्य तत्व नामों के लिए व्यवहार अपरिभाषित हो सकता है, इसलिए इसके बजाय "RUTHENIUM"=आप उपयोग कर सकते हैं "RUTHEN"#!। 2. आपको स्पष्ट रूप से प्रिंट करने की आवश्यकता नहीं है ( o) और न ही वास्तविक तत्व नाम ( ;"Si") से पहले कुछ भी निकालने की आवश्यकता है ; बस ]W=अपने कोड के अंत में सब कुछ लेकिन सबसे ऊपरी स्टैक तत्व को हटाने के लिए संलग्न करें। 3. जो कुछ ब्लॉक को खाली करता है। यदि Bएक बूलियन है, B{...}{}?और B{...}*उसी को प्राप्त करें। 4. त्रिगुट अगर ब्लॉक या ढेर तत्वों लगता है, इसलिए छोटा कर सकते हैं {"Si"}करने के लिए "Si"।

— डेनिस

@ मुझे लगता है कि मैंने उस सभी को जोड़ दिया है। स्टैक प्रबंधन को काम की जरूरत है, हालांकि - बहुत सारे _और ;सभी जगह

@ डेनिस और मैंने डिफॉल्ट मामले को लोअरकेस में बदलकर और

Answer 7

PHP, 507 485 476 466 अक्षर

उपयोग: तत्व नाम को GET पैरामीटर '0' के रूप में दर्ज करें - elements.php? 0 = कार्बन

एल्गोरिदम: डेटा स्ट्रिंग के माध्यम से चलाएं, सबस्ट्रिंग को बाहर निकालते हुए, संक्षिप्त नाम कोड जोड़े। यदि सबस्ट्रिंग पास किए गए तत्व की शुरुआत से मेल खाता है, तो आउटपुट क्या है यह निर्धारित करने के लिए संक्षिप्त नाम कोड का उपयोग करें: यदि कोड एक अक्षर से शुरू होता है, तो इसे स्ट्रिंग के रूप में आउटपुट करें। यदि यह संख्या N है, तो तत्व का पहला अक्षर + Nth अक्षर आउटपुट करता है। Unun एलिमेंट्स कोड के साथ विशेष रूप से कैस्ड होते हैं '|' यदि कोई विकल्प नहीं मिला है जो कि नाम से मेल खाता है, तो नाम के पहले दो अक्षरों को संक्षिप्त नाम के रूप में आउटपुट करता है।

पठनीय कोड:

<?
$l=ucfirst(strtolower($_GET[0]));
for(
  $m[3]="AnSbArs2As2Berk3Boh2BoBCad2Cae3Cali4CarCChl2Ch2Cope5CopCuCu5Da4Du2Ei3Fe3FluFGad2GoAuHaf2Ha2HyHIo0IroFeLaw3LePbLiv2Mag2Man2Mei3Men3MeHgNeod3Nep2Nio3NiNOxOPa5PhPPla3Plu2PotKProm3Pro4Rado4Rhe2Roe5Rub2Ruther6Sa2Sea6SilvAgSoNaSt2SuSTec2Ter3Tha3Thu6TinSnTuWUn|UUVVYtte5YYZin2Z2";
  preg_match('/(.[a-z]*)(.[a-z]*)(.*)/',$m[3],$m)
;)
    if(strstr($l,$m[1]))
        echo($x=$m[2][0])>'@'?$x>'{'?"Uu$l[4]":$m[2]:$l[0].$l[$x],die;
echo$l[0],$l[1];

संघनित:

<?$l=ucfirst(strtolower($_GET[0]));for($m[3]="AnSbArs2As2Berk3Boh2BoBCad2Cae3Cali4CarCChl2Ch2Cope5CopCuCu5Da4Du2Ei3Fe3FluFGad2GoAuHaf2Ha2HyHIo0IroFeLaw3LePbLiv2Mag2Man2Mei3Men3MeHgNeod3Nep2Nio3NiNOxOPa5PhPPla3Plu2PotKProm3Pro4Rado4Rhe2Roe5Rub2Ruther6Sa2Sea6SilvAgSoNaSt2SuSTec2Ter3Tha3Thu6TinSnTuWUn|UUVVYtte5YYZin2Z2";preg_match('/(.[a-z]*)(.[a-z]*)(.*)/',$m[3],$m);)if(strstr($l,$m[1]))echo($x=$m[2][0])>'@'?$x>'{'?"Uu$l[4]":$m[2]:$l[0].$l[$x],die;echo$l[0],$l[1];

Answer 8

जावास्क्रिप्ट (1100)

अपनी सरलता में चमकदार कार्यान्वयन। नाम की शुरुआत से अद्वितीय उप स्ट्रिंग को केवल प्रतीक के लिए मैप किया जाता है।

e={hy:"H",he:"He",lit:"Li",bery:"Be",bor:"B",car:"C",nit:"N",ox:"O",flu:"F",neon:"Ne",so:"Na",mag:"Mg",al:"Al",sili:"Si",ph:"P",su:"S",chl:"Cl",arg:"Ar",pot:"K",calc:"Ca",sc:"Sc",tit:"Ti",v:"V",chr:"Cr",man:"Mn",iro:"Fe",cob:"Co",nic:"Ni",copp:"Cu",zin:"Zn",gal:"Ga",ge:"Ge",ars:"As",sel:"Se",br:"Br",k:"Kr",rub:"Rb",st:"Sr",yttr:"Y",zir:"Zr",nio:"Nb",mo:"Mo",tec:"Tc",ruthen:"Ru",rho:"Rh",pa:"Pd",silv:"Ag",cad:"Cd",in:"In",tin:"Sn",an:"Sb",tel:"Te",io:"I",x:"Xe",cae:"Cs",ba:"Ba",lan:"La",ce:"Ce",pra:"Pr",neod:"Nd",prom:"Pm",sa:"Sm",eu:"Eu",gad:"Gd",ter:"Tb",dy:"Dy",ho:"Ho",er:"Er",thu:"Tm",ytte:"Yb",lu:"Lu",haf:"Hf",ta:"Ta",tu:"W",rhe:"Re",os:"Os",iri:"Ir",pla:"Pt",go:"Au",mer:"Hg",tha:"Tl",le:"Pb",bi:"Bi",pol:"Po",as:"At",rado:"Rn",fr:"Fr",radi:"Ra",ac:"Ac",tho:"Th",prot:"Pa",ur:"U",nep:"Np",plu:"Pu",am:"Am",cu:"Cm",berk:"Bk",cali:"Cf",ei:"Es",fe:"Fm",men:"Md",no:"No",law:"Lr",ruther:"Rf",du:"Db",sea:"Sg",boh:"Bh",has:"Hs",mei:"Mt",da:"Ds",ro:"Rg",cope:"Cn",ununt:"Uut",fle:"Fl",ununp:"Uup",liv:"Lv",ununs:"Uus",ununo:"Uuo"}
n=prompt().toLowerCase()
for(i in e)n.indexOf(i)?i:alert(e[i])

Answer 9

अजगर - 652 649 637

मेरा हैश टेबल अपरकेस नाम के हर दूसरे और हर तीसरे वर्ण के संयोजन पर आधारित है:

import re
def f(s,c='S<8F0FCE;2.ACR;J@W$;BI8>GD*?GnHQ<K>&T\(51IAg/Y?S2=169.,325(F(98?>?=^97DUCITX;SJ`0C<P9iLP/G4B,A(-A?(3QLLZ;81D(.4F;L8GaVP[=\=cOX3U,LQl6:E9/OXdSe(4,TSV/=FN98?K.18Q>R$+<GG[IS-4?;4H;T/IMq9<LXMYH4HG<>>KTT,>IIEM,[Nf<,:Z60(A9fImZTMRTcM?[lVg^qC}',e='HHeLiBeBCNOFNeNaMgAlSiPSClArKCaScTiVCrMnFeCoNiCuZnGaGeAsSeBrKrRbSrYZrNbMoTcRuRhPdAgCdInSnSbTeIXeCsBaLaCePrNdPmSmEuGdTbDyHoErTmYbLuHfTaWReOsIrPtAuHgTlPbBiPoAtRnFrRaAcThPaUNpPuAmCmBkCfEsFmMdNoLrRfDbSgBhHsMtDsRgCnUutFlUupLvUusUuo'):
 U=s.upper();X=lambda x:chr(32+sum(ord(u)-65for u in x))
 return re.findall('[A-Z][a-z]*',e)[zip(c[::2],c[1::2]).index((X(U[1::3]),X(U[:-1:2])))]

यहाँ इसी जनरेटर है:

table = '''
H     Hydrogen
He    Helium
...
Uuo   Ununoctium
'''

table = map(lambda l: l.split(), table.split('\n')[1:-1])

abbr = []
for name in map(str.upper, zip(*table)[1]):
    abbr.append(chr(32+sum(ord(u)-65 for u in name[1::3]))+
                chr(32+sum(ord(u)-65 for u in name[:-1:2])))
print 'c=' + ''.join(abbr)
print 'e=' + ''.join(zip(*table)[0])
print 'Unique' if len(table) == len(set(abbr)) else 'Duplicates'

सुधार के लिए शायद जगह है, विशेष रूप से दो लंबे तारों को संपीड़ित करना।

के साथ परीक्षण किया गया:

for short, name in table:
    if f(name) != short:
        print "Wrong result!"

Answer 10

गोल्फस्क्रिप्ट - 1052 821

{.91<32*+}%:x;'H
He
Li
Be
B
C
N
F
Ne
Na
Mg
Al
Si
P
S
Cl
Ar
K
Ca
Sc
Ti
V
Cr
Mn
Fe
Co
Ni
Cu
Zn
Ga
Ge
As
Se
Br
Kr
Rb
Sr
Y
Zr
Nb
Mo
Tc
Ru
Rh
Pd
Ag
Cd
In
Sn
Sb
Te
I
Xe
Cs
Ba
La
Ce
Pr
Nd
Pm
Sm
Eu
Gd
Tb
Dy
Ho
Er
Tm
Yb
Lu
Hf
Ta
W
Re
Os
Ir
Pt
Au
Hg
Tl
Pb
Bi
Po
At
Rn
Fr
Ra
Ac
Th
Pa
U
Np
Pu
Am
Cm
Bk
Cf
Es
Fm
Md
No
Lr
Rf
Db
Sg
Bh
Hs
Mt
Ds
Rg
Cn
Uut
Fl
Uup
Lv
Uus'n/'hy
he
lit
bery
bor
car
nit
flu
neon
so
mag
al
sili
ph
su
chl
arg
pot
calc
sc
tit
v
chr
man
iro
cob
nic
copp
zin
gal
ge
ars
sel
br
k
rub
st
yttr
zir
nio
mo
tec
ruthen
rho
pa
silv
cad
in
tin
an
tel
io
x
cae
ba
lan
ce
pra
neod
prom
sa
eu
gad
ter
dy
ho
er
thu
ytte
lu
haf
ta
tu
rhe
os
iri
pla
go
mer
tha
le
bi
pol
as
rado
fr
radi
ac
tho
prot
ur
nep
plu
am
cu
berk
cali
ei
fe
men
no
law
ruther
du
sea
boh
has
mei
da
ro
cope
ununt
fle
ununp
liv
ununs
ununo'n/[{x\?)}/]1?=

स्पष्टीकरण:

{        }%                              Map these ops to the input string:
 .91<32*+                                   Add 32 if less than 91 (convert to lowercase, in essence)
           :x;                           Store to x.
              '...'  '...'               The first array is the symbols, the second is the names.
                                         (stripped down to the minimum necessary)
                   n/     n/             Convert them to arrays.
                             {    }/     For each element in the name array...
                              x\?)          ...return 1 if the element is found in the input.
                            [       ]    Gather every element in an array...
                                     1?  Find the 1 in the array (the only element name match)...
                                       = ...then return that symbol in the symbol array.
                               (implied) Print.

Comments

OMG, गोल्फस्क्रिप्ट का एक टुकड़ा जो 10 वर्ण या उससे कम का नहीं है!

— वैलीवेस्ट

आप विभाजक के रूप में न्यूलाइन के साथ एक स्ट्रिंग का उपयोग करके तार के उस सरणी में बड़े पैमाने पर सुधार प्राप्त कर सकते हैं और फिर कर रहे हैंn/

— पीटर टेलर

मैंने पिछली बार ऐसा किया था, इसलिए बिल्ली ने मुझे ऐसा क्यों नहीं समझा? अब अपडेट हो रहा है।

— जोशियाह विंसलो

Answer 11

हास्केल, 920 817 807 776 चार्ट

बहुत लंबे समय तक काम करने के बाद तत्वों के नाम के अक्षरों को उसके प्रतीक में शामिल करने के लिए नियमों की एक प्रणाली तैयार करना, और थोड़ा सा छेड़छाड़ करना, मैं एक स्क्रिप्ट लिखने में कामयाब रहा जो आसानी से प्रतीक के लिए तत्व का अनुवाद करता है। आयरन मेरे लिए एक समस्या थी, क्योंकि मैं गोल्ड, सिल्वर, टीआईएन, लीड, सोयमियम, मर्करी, एंटिमोनी, पोटाशियम, और टंगस्टन से कुछ पात्रों का नमूना ले सकता था, उन्हें अप्रयुक्त आवधिक प्रतीक में परिवर्तित कर सकता था (मैंने जो भी नमूना चुना, उसे एकीकृत करना सबसे सरल बना। मौजूदा नियमों में), और फिर प्रतीकात्मक रूपांतरण के बाद अनुवाद करना; लोहा, हालांकि, एक समस्या थी, क्योंकि इर, आईओ और इन सभी का उपयोग पहले से ही किया जाता है। यह शुरू में 920 वर्ण था, लेकिन मुझे एहसास हुआ कि अंतिम पैटर्न मैच (सबसे बड़ा) होने की आवश्यकता नहीं थी, क्योंकि यह या तो चीजों को छोड़ देता है (जो यह नहीं था) या उन सभी से मेल खाता था; इसलिए, मैंने इसे कैच-ऑल वाइल्डकार्ड से बदल दिया। उसके बाद, मैंने आगे 817 से 808 तक वाइल्ड-कार्ड्स का उपयोग करके कुछ पैटर्न को इस तरह संक्षिप्त किया कि वे अभी भी उस तत्व के नाम के लिए अद्वितीय थे (उदाहरण के लिए उसके नाम में 'w' वाला एकमात्र तत्व Lawrencium है, इसलिए "* w "मैच है कि" कानून "की तुलना में 1 कम चरित्र में)।

यहाँ मेरा कोड है। मैंने इसे सभी तत्वों के लिए परीक्षण किया, और मैंने इसे कोडित किया ताकि यह स्वचालित रूप से अपने इनपुट को शीर्षक में बदल दे, इसलिए मामले की संवेदनशीलता के साथ कोई समस्या नहीं है।

EDIT 1

मैंने पैटर्न मैच के साथ केस एक्सप्रेशन को बदलकर इसे 776 कैरेक्टर तक कम कर दिया (इसका मतलब है क्योंकि केस एक्सप्रेशन रॉ ऑपरेंड का परीक्षण कर रहा था क्योंकि ऑपरेन्ड के संदर्भ में एक एक्सप्रेशन के विपरीत है), अनावश्यक कोष्ठक को हटाकर, और फिर से eस्ट्रिंग की एक सूची के बजाय एक नईलाइन-सीमांकित स्ट्रिंग के रूप में व्यक्त करना , और बाद में इसे मुख्य कार्य में विभाजित करना। क्योंकि ये परिवर्तन विशुद्ध रूप से गोल्फिंग हैं, मैंने मानव-पठनीय संस्करण को अपरिवर्तित छोड़ दिया है।

import Data.Char
m _[]=True;m[]_=False;m k@(c:s)x@(y:z)=case y of{']'->m s x;'['->let(i,(_:j))=break(==']')z in(c`elem`i)&&m s j;'?'->m s z;'*'->null z||m k z||m s z||m s x;_->c==y&&m s z};p(a:t)(x:y)=case a of{'.'->x:p t y;'_'->p t y;_->a:p t y};p[]_=[];e="Iro\nUn\nCu Pa Ro Y*e\nR*r\n*pp\nCop Rado\nSea Thu\nCali Da P*ot Tha\nA*s Boh ?ub Ch [CG]ad [HM]a Liv Nep Plu Rhe S[ato] Tec Tin Z\nB*k Cae [ES]i *w Nio [FM]e N*d Pro Pla Ter\nBor Car Flu Hy Io Nit Ox Ph Su [UVY]\n*";s="Fe ._._. .____. .f .u .n ._____. .___. ._. .__. . ..";t"Sv"="Ag";t"Sd"="Na";t"Go"="Au";t"Le"="Pb";t"Mc"="Hg";t"An"="Sb";t"Ps"="K";t"Tu"="W";t"Tn"="Sn";t x=x;main=interact$unlines.map(\(a:b)->let y=toUpper a:map toLower b in t$p(snd.head.filter(any(m y).fst)$zip(map words$lines e)$words s)y).lines

मानव-पठनीय संस्करण (newlines, रिक्ति, क्रिया नाम, टिप्पणी: 2311 शुल्क)

import Data.Char

-- Test against search-pattern strings
match _ [] = True
match [] _ = False
match k@(c:s) x@(y:z) = case y of
']' -> match s x
'[' -> let (i,(_:j)) = break (==']') z in (c `elem` i) && match s j
'?' -> match s z
'*' -> null z || match k z || match s z || match s x
 _  -> c == y && match s z

-- Write according to name-pattern string
pattern (a:t) (x:y) = case a of
'.' -> x : (pattern t y)
'_' -> (pattern t y)
 _  -> a : (pattern t y)
pattern [] _ = []

-- Search-Patterns for the elements
elements=["Iro", -- Iron -> Fe
      "Un", -- UnUn-Blank-ium (1,3,5)
      "Cu Pa Ro Y*e", -- CuriuM PallaDium RoentGenium YtterBium (1,6)
      "R*r", -- Rutherfordium (1,f)
      "*pp", -- Copper (1,u)
      "Cop Rado", -- Copernicium Radon (1,n)
      "Sea Thu", -- SeaborGium ThuliuM (1,7)
      "Cali Da P*ot Tha", -- CaliFornium DarmStadtium ProtActinium PotaSsium (1,5)

      {- AsTatine ArSenic BoHrium DuBnium RuBidium ChLorine ChRome CaDmium
      GaDolinium HaFnium HaSsium MaNganese MaGnesium LiVermorium NePtunium
      PlUtonium RhEnium SaMarium StRontium SoDium TeChnetium TiN ZiNc
      ZiRconium (1,3) -}

      "A*s Boh ?ub Ch [CG]ad [HM]a Liv Nep Plu Rhe S[ato] Tec Tin Z", 

      {- BerKelium CaeSium EinSteinum SilIcon SilVer LawRencium NioBium
      FerMium MenDelevium MeiTnerium MerCury NeoDymium ProMethium PlaTinum
      TerBium (1,4) -}

      "B*k Cae [ES]i *w Nio [FM]e N*d Pro Pl Ter",

      {- Boron Carbon Fluorine Hydrogen Nitrogen Oxygen Phosphorous Sulphur
      Uranium Vanadium Yttrium (1) -}

      "Bor Car Flu Hy Io Nit Ox Ph Su [UVY]",
      "*"] -- Everything else (1,2)

-- respective naming patterns for searches
symbol = "Fe ._._. .____. .f .u .n ._____. .___. ._. .__. . .."

-- Translate fake symbols
translate x = case x of
"Sv" -> "Ag" -- SilVer
"Sd" -> "Na" -- SoDium
"Go" -> "Au" -- GOld
"Le" -> "Pb" -- LEad
"Mc" -> "Hg" -- MerCury
"An" -> "Sb" -- ANtimony
"Ps" -> "K" -- PotaSsium
"Tu" -> "W" -- TUngsten
"Tn" -> "Sn" -- TiN
  _  -> x  -- Keep everything else the same

main = interact $ unlines . map (\(a:b) -> let y = (toUpper a) : (map toLower b) in t $ p (snd.head.filter (any (m y) . fst) $ zip (map words e) $ words s) $ y) . lines

यदि किसी को इसके किसी भी भाग के लिए स्पष्टीकरण में दिलचस्पी है, तो बेझिझक पूछें।

Answer 12

C # (826)

सबसे बड़ा नहीं है, लेकिन मैंने सोचा कि मैं इसे सी # के हैंडीकैप के साथ आज़माऊंगा।

using System;class P{static string s="HyHHe1Li1Be1BoBCaCNitNOxOFlFNe1SoNaMaMgAl1Sil1PhPSuSChClAr1PotKCal1Sc1Tit1VaVChrCrManMnIrFeCo1Ni1CopCuZiZnGa1Ge1ArsAsSe1Br1Kr1RuRbStSrYtYZirZrNioNbMo1TecTcRut1Rh1PaPdSiAgCadCdIn1TiSnAnSbTel1IoIXe1CaeCsBa1La1Ce1Pra1NeoNdPrPmSaSmEu1GadGdTeTbDy1Ho1Er1ThTmYttYbLu1HaHfTa1TuWRheReOs1Iri1PlPtGoAuMeHgThaTlLePbBi1Po1AsAtRaRnFr1Rad1Ac1Tho1ProPaUrUNepNpPluPuAm1CuCmBerBkCaliCfEiEsFeFmMenMdNo1LawLrRuthRfDuDbSeaSgBohBhHasHsMeiMtDaDsRoRgCopeCnUnUutFle1UnuUupLivLvUnunUus",n,t,k;static void Main(){var d=new System.Collections.Specialized.StringDictionary();while(s!=""){k=g;d[k]=g;if(d[k]=="1")d[k]=k.Substring(0,2);};t=Console.ReadLine();while(t!=""&!d.ContainsKey(t))t=t.Remove(t.Length-1);Console.Write(d[t]);}static string g{get{n="";do n+=s[0];while((s=s.Remove(0,1))!=""&&s[0]>96);return n;}}}

इसलिए मैंने तत्वों के पूर्ण नाम (जैसे कार्बन) को सबसे छोटा लेकिन फिर भी अद्वितीय स्ट्रिंग संभव बनाने के लिए एक कार्यक्रम लिखा और सभी अन्य अद्वितीय तार के संबंध में सभी तत्वों के लिए ऐसा किया। मैंने तब यह अनुक्रमित किया कि एक बड़े बदसूरत स्ट्रिंग में जहां कैपिटल अक्षर "चंक्स" की शुरुआत को दर्शाते हैं, जिसमें चाभी कुंजी और मूल्यों के बीच बारी-बारी से होती है। जैसे KeyValueKey2Value2 आदि।

यह स्क्रिप्ट उस बड़े स्ट्रिंग को नष्ट कर देती है और इनपुट स्ट्रिंग के अंत तक एक चरित्र को काट देती है जब तक कि यह बड़े स्ट्रिंग से बने शब्दकोश में नहीं मिल जाता।

(मुझे C # के अपने ज्ञान को जोड़ना चाहिए, यह आश्चर्यजनक नहीं है और मैंने जो मूल सबमिशन किया है, वह सिर्फ उन चीजों का उपयोग कर रहा था जो मुझे पता था, लेकिन बाद में मेरे पास दूसरों द्वारा बताई गई कुछ ट्रिक्स हैं। "

Comments

आप इसे सभी प्रकार की परिभाषाओं में बदलकर इसे आगे बढ़ा सकते हैं var। यदि आप ब्लॉक करते हैं तो सिंगल-स्टेटमेंट के बाद ब्रेसिज़ को हटाकर कुछ और बचा सकते हैं। यदि आप आप को सौंपते हैं तो आप t.Substring(int, int)एक Func<int, int, string>और जोड़े को बचा सकते हैं।

— ब्रैंडन

मैंने अधिकांश चर को "var" बनाया, लेकिन लगता है कि मैं एक या दो से चूक गया, पूरी तरह से ब्रैकेटलेस इफ्स के बारे में भी भूल गया, धन्यवाद।

— 14

आप से एक और 5 अक्षर दाढ़ी कर सकते हैं varing string[] rद्वारा और एक और 3 varing string t = Console...., अंत में, आप 7 अधिक बदलकर बचा लेंगे return new string[]में return new[]अंत में।

— ब्रैंडन

कुछ अन्य छोटे सुधार हैं जो आप अपने if(...) break;तर्क को लूप से बाहर निकलने की स्थिति में ले जाने जैसे प्रदर्शन कर सकते हैं। कई अन्य तर्क व्युत्क्रम लागू किए जा सकते हैं, जैसे कि do { } while(..)आपके निष्कर्षण विधि में। यह प्रविष्टि मामले के लिए एक अलग तार्किक ऑपरेशन को जोड़ने से कम है। मैंने आपके कोड में एक संपादन पोस्ट किया है जो इस साइट पर मेरे कम प्रतिनिधि के कारण अभी भी समीक्षा / स्वीकृति की आवश्यकता है। इसे 870 वर्णों तक सीमित कर दिया।

— निकोलस

@ निकोलस मुझे यकीन नहीं है कि किसी और का कोड गोल्फ विनम्र है ...

— miethpo

Answer 13

जावास्क्रिप्ट (E6) 1433

यहाँ ऊपरी सीमा है

F=n=>'0H0HYDROGEN0He0HELIUM0Li0LITHIUM0Be0BERYLLIUM0B0BORON0C0CARBON0N0NITROGEN0O0OXYGEN0F0FLUORINE0Ne0NEON0Na0SODIUM0Mg0MAGNESIUM0Al0ALUMINIUM0Si0SILICON0P0PHOSPHORUS0S0SULFUR0Cl0CHLORINE0Ar0ARGON0K0POTASSIUM0Ca0CALCIUM0Sc0SCANDIUM0Ti0TITANIUM0V0VANADIUM0Cr0CHROMIUM0Mn0MANGANESE0Fe0IRON0Co0COBALT0Ni0NICKEL0Cu0COPPER0Zn0ZINC0Ga0GALLIUM0Ge0GERMANIUM0As0ARSENIC0Se0SELENIUM0Br0BROMINE0Kr0KRYPTON0Rb0RUBIDIUM0Sr0STRONTIUM0Y0YTTRIUM0Zr0ZIRCONIUM0Nb0NIOBIUM0Mo0MOLYBDENUM0Tc0TECHNETIUM0Ru0RUTHENIUM0Rh0RHODIUM0Pd0PALLADIUM0Ag0SILVER0Cd0CADMIUM0In0INDIUM0Sn0TIN0Sb0ANTIMONY0Te0TELLURIUM0I0IODINE0Xe0XENON0Cs0CAESIUM0Ba0BARIUM0La0LANTHANUM0Ce0CERIUM0Pr0PRASEODYMIUM0Nd0NEODYMIUM0Pm0PROMETHIUM0Sm0SAMARIUM0Eu0EUROPIUM0Gd0GADOLINIUM0Tb0TERBIUM0Dy0DYSPROSIUM0Ho0HOLMIUM0Er0ERBIUM0Tm0THULIUM0Yb0YTTERBIUM0Lu0LUTETIUM0Hf0HAFNIUM0Ta0TANTALUM0W0TUNGSTEN0Re0RHENIUM0Os0OSMIUM0Ir0IRIDIUM0Pt0PLATINUM0Au0GOLD0Hg0MERCURY0Tl0THALLIUM0Pb0LEAD0Bi0BISMUTH0Po0POLONIUM0At0ASTATINE0Rn0RADON0Fr0FRANCIUM0Ra0RADIUM0Ac0ACTINIUM0Th0THORIUM0Pa0PROTACTINIUM0U0URANIUM0Np0NEPTUNIUM0Pu0PLUTONIUM0Am0AMERICIUM0Cm0CURIUM0Bk0BERKELIUM0Cf0CALIFORNIUM0Es0EINSTEINIUM0Fm0FERMIUM0Md0MENDELEVIUM0No0NOBELIUM0Lr0LAWRENCIUM0Rf0RUTHERFORDIUM0Db0DUBNIUM0Sg0SEABORGIUM0Bh0BOHRIUM0Hs0HASSIUM0Mt0MEITNERIUM0Ds0DARMSTADTIUM0Rg0ROENTGENIUM0Cn0COPERNICIUM0Uut0UNUNTRIUM0Fl0FLEROVIUM0Uup0UNUNPENTIUM0Lv0LIVERMORIUM0Uus0UNUNSEPTIUM0Uuo0UNUNOCTIUM'
.match(RegExp('([^0]+)0+'+n,'i'))[1]

FireFox / FireBug कंसोल में टेस्ट करें

F('Rutherfordium')

उत्पादन

Rf

Answer 14

स्माइलबेसिक, 1763 1418 1204 1128 बाइट्स

INPUT E$Hro$="H
Hiu$="He
Lhi$="Li
Byl$="Be
Bon$="B
Cbo$="C
Nro$="N
Oge$="O
For$="F
Nn$="Ne
Siu$="Na
Mne$="Mg
Ami$="Al
Sic$="Si
Psp$="P
Sfu$="S
Cor$="Cl
Aon$="Ar
Pas$="K
Cci$="Ca
Snd$="Sc
Tan$="Ti
Vad$="V
Com$="Cr
Mga$="Mn
In$="Fe
Cal$="Co
Nke$="Ni
Cpe$="Cu
Zc$="Zn
Gli$="Ga
Gma$="Ge
Aen$="As
Sen$="Se
Bmi$="Br
Kpt$="Kr
Rid$="Rb
Son$="Sr
Yri$="Y
Zco$="Zr
Nbi$="Nb
Myb$="Mo
Thn$="Tc
Rhe$="Ru
Rdi$="Rh
Pla$="Pd
Sve$="Ag
Cmi$="Cd
Iiu$="In
T$="Sn
Aim$="Sb
Tlu$="Te
Iin$="I
Xon$="Xe
Csi$="Cs
Biu$="Ba
Lth$="La
Pse$="Pr
Ndy$="Nd
Pme$="Pm
Sar$="Sm
Eop$="Eu
Gol$="Gd
Tbi$="Tb
Dpr$="Dy
Hmi$="Ho
Eiu$="Er
Tli$="Tm
Yer$="Yb
Let$="Lu
Hni$="Hf
Tta$="Ta
Tgs$="W
Rni$="Re
Oiu$="Os
Idi$="Ir
Pti$="Pt
Gd$="Au
Mcu$="Hg
Tll$="Tl
Ld$="Pb
Bmu$="Bi
Pon$="Po
Aat$="At
Ron$="Rn
Fnc$="Fr
Riu$="Ra
Ain$="Ac
Tri$="Th
Pta$="Pa
Uni$="U
Ntu$="Np
Pto$="Pu
Ari$="Am
Ciu$="Cm
Bke$="Bk
Cif$="Cf
Est$="Es
Fmi$="Fm
Mde$="Md
Nel$="No
Lre$="Lr
Dni$="Db
Sbo$="Sg
Bri$="Bh
Hsi$="Hs
Mtn$="Mt
Dms$="Ds
Rnt$="Rg
Cer$="Cn
Unt$="Uut
Fro$="Fl
Unp$="Uup
Ler$="Lv
Uns$="Uus
Uno$="Uuo
S$=VAR(E$[0]+MID$(E$,3,2))IF"Cm"==S$*!VAL(".1"+E$[1])THEN S$="Ce
IF LEN(E$)>12THEN S$="Rf
?S$

मैंने 3 अक्षर चुने जो ज्यादातर अनोखे थे (0th, 2nd, और 3rd), जो 2 विशेष मामले छोड़ता है: Cerium / Curium दोनों "Ciu" हैं, और Ruthenium / Rutherfordium दोनों "Rhe" हैं। सिउ के लिए, मैं जांचता हूं कि क्या नाम का दूसरा वर्ण "ई" या "ई" है, और "र" के लिए, मैं नाम की लंबाई की जांच करता हूं।

VAR(name)चर को उस नाम से लौटाता है। परिवर्तनीय नाम केस असंवेदनशील हैं।

Answer 15

टी-एसक्यूएल, 900 894 676 बाइट्स

SELECT ISNULL((SELECT LEFT(value,3)FROM
STRING_SPLIT('Sb An-As Ars-At Ast-Bk Berk-Bh Boh-B  Bor-Cd Cad-Cs Cae-Cf Cali-C  Car-Cl Chl-Cr Chr-Cn Cope-Cu Copp-Cm Cu-Ds Da-Db Du-Es Ei-Fm Fe-F  Flu-Gd Gad-Au Go-Hf Haf-Hs Has-H  Hy-I  Io-Fe Iro-Lr Law-Pb Le-Lv Liv-Mg Mag-Mn Man-Mt Mei-Md Men-Hg Mer-Nd Neod-Np Nep-Nb Nio-N  Nit-O  Ox-Pd Pa-P  Ph-Pt Pla-Pu Plu-K  Pot-Pm Prom-Pa Prot-Rn Rado-Re Rhe-Rg Ro-Rb Rub-Rf Ruther-Sm Sa-Sg Sea-Ag Silv-Na So-Sr St-S  Su-Tc Tec-Tb Ter-Tl Tha-Tm Thu-Sn Tin-W  Tu-UuoUnuno-UupUnunp-UusUnuns-UutUnunt-U  Ur-V  V-Yb Ytte-Y  Yttr-Zn Zin-Zr Zir'
    ,'-')m,t WHERE e LIKE SUBSTRING(value,4,9)+'%'),
(SELECT UPPER(LEFT(e,1))+LOWER(SUBSTRING(e,2,1))FROM t))

रिटर्न केवल पठनीयता के लिए है, दूसरी पंक्ति एक बहुत लंबी स्ट्रिंग है।

STRING_SPLIT SQL 2016 और उच्चतर में समर्थित है।

इनपुट एक पूर्व मौजूदा तालिका के माध्यम से लिया जाता है टी के साथ varchar क्षेत्र ई , हमारे आईओ मानकों के अनुसार । आउटपुट 3 अक्षरों के रिक्त स्थान के साथ गद्देदार है; नियम स्पष्ट नहीं थे कि क्या यह ठीक है। यदि आवश्यक हो, मैं एक जोड़ सकते हैंTRIM ।

इनपुट टेबल को प्रत्येक तत्व नाम के लिए सबसे कम अद्वितीय उपसर्ग के साथ सभी तत्व प्रतीकों (3 वर्णों को गद्देदार) की सूची के साथ उत्पन्न तालिका के साथ जोड़ा गया है ( क्सीनन केX लिए पर्याप्त है , लेकिन रदरफोर्डियम को इसे रूथेनियम से अलग करने की आवश्यकता है )।Ruther

EDIT 1 : सूची में से 44 प्रविष्टियों को हटाकर 218 वर्णों को सहेजा गया, जिनके प्रतीक उनके नाम के पहले दो अक्षर हैं; ISNULLसमारोह अगर पहली क्वेरी एक पंक्ति लौटने के लिए विफल रहता है को देखने के लिए प्रयोग किया जाता है, और यदि हां, इनपुट तत्व नाम से प्रतीक (ठीक से मामलों) उत्पन्न करता है।