तत्वों की आवर्त सारणी से शब्द [बंद]

Question

जब मैं रसायन विज्ञान लेने वाले हाईस्कूल में एक नया व्यक्ति था, तो मैं तत्वों की आवर्त सारणी को देखूंगा और तत्वों की संख्या के साथ गंदे शब्दों को बाहर निकाल दूंगा (HeCK 2619, 2-6-19 होगा)।

मैं दूसरे दिन इस बारे में सोच रहा था, जब मैंने एक अद्भुत शर्ट देखी, जो बीर (4-68) की थी

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

/ usr / शेयर / तानाशाह / शब्द या जो भी शब्द आप शब्द सूची के लिए उपयोग करना चाहते हैं। यदि आप "गैर-मानक" शब्द सूची का उपयोग कर रहे हैं, तो हमें बताएं कि यह क्या है!

Comments

'द कोड कोड? उन मामलों के बारे में जहां एक से अधिक हैं? जैसे CO CO। कं

— पीटर टेलर

जैसा कि मैं नीचे प्रतिक्रियाओं को पढ़ रहा हूं, मैंने एक जगह पर ध्यान दिया है कि हर कोई कुछ पात्रों को काट सकता है। वे अपने तत्वों की सूची से Co, Si, Sc, Os, Hs, Po, Pb, Np, No, Yb, Cs और शायद अन्य को हटा सकते हैं, क्योंकि वे सभी अन्य तत्वों से निर्मित हो सकते हैं।

— फीनोटपी

Ytterbium नहीं, यह मेरा पसंदीदा तत्व है!

— रोब

बस स्पष्ट करने के लिए, जिन तत्वों को मैंने सूचीबद्ध किया है, उन्हें हमेशा सुरक्षित रूप से हटाया जा सकता है। उदाहरण के लिए, Ytterbium को हमेशा एक Yttrium और एक Boron के साथ बदला जा सकता है, कोई फर्क नहीं पड़ता कि भाषा सूची किस भाषा में है।

— PhiNotPi

मुझे पूरा यकीन नहीं है कि क्या मैं कार्य को पूरी तरह से समझता हूं: क्या हम हर तत्व के प्रिंट होने तक तत्वों के लिए मेल खाते हुए शब्द पाएंगे, या क्या हम प्रत्येक शब्द को हुक से प्रिंट करेंगे, जिसे तत्व तालिका से जोड़ा जा सकता है? या कुछ और?

— उपयोगकर्ता अज्ञात

Answer 1

गोल्फस्क्रिप्ट ( 339 303 302 301 294 वर्ण)

n/{{{32|}%}:L~['']{{`{\+}+'HHeLiBeBCNOFNeNaMgAl
PSClArKCa TiVCrMnFe


ZnGaGeAsSeBrKrRbSrYZr
MoTcRuRhPdAgCd


TeIXe
BaLaCePrNdPmSmEuGdTbDy
ErTm
Lu
TaWRe
IrPtAuHgTl


AtRnFrRaAcThPaU

AmCm

EsFmMd
LrRfDbSg

MtDsRg
UutFl
Lv'{[1/{.0=96>{+}*}/]}:S~:^/}%.{L}%2$?.){=S{^?}%`+p 0}{;{L.,2$<=},.}if}do}%;

फीनोटपाई को श्रेय दिया गया है, जिनके अनावश्यक तत्वों के अवलोकन ने मुझे 33 वर्णों को बचाने की अनुमति दी।

यह पिछले पुनरावर्ती दृष्टिकोण की तुलना में IMO बहुत अधिक मुहावरेदार गोल्फस्क्रिप्ट है।

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

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

"ac[89]"
"accra[89 6 88]"
"achebe[89 2 4]"
...

(कम-केसिंग किसी भी मिश्रित-केस इनपुट शब्दों के लिए जिसके लिए यह एक मैच पाता है)।

यदि आप 261 253 वर्णों के निम्न कम मूल्य के लिए, आप प्रति से अधिक संख्या के तत्वों में रुचि रखते हैं, तो आप उपयोग कर सकते हैं

n/{{{32|}%}:L~['']{{`{\+}+'HHeLiBeBCNOFNeNaMgAlPSClArKCaTiVCrMnFeZnGaGeAsSeBrKrRbSrYZrMoTcRuRhPdAgCdTeIXeBaLaCePrNdPmSmEuGdTbDyErTmLuTaWReIrPtAuHgTlAtRnFrRaAcThPaUAmCmEsFmMdLrRfDbSgMtDsRgUutFlLv'[1/{.0=96>{+}*}/]/}%.{L}%2$?.){=p 0}{;{L.,2$<=},.}if}do}%;

जो आउटपुट देता है

"Ac"
"AcCRa"
"AcHeBe"
...

Comments

अतिरिक्त चरित्र को बाहर ले जाओ, "मुझे बिल्कुल परेशान नहीं करता। और निश्चित रूप से पीटर टेलर अंदर आता है और सभी को गोल्फस्क्रिप्ट से उड़ा देता है।

— रोब

Answer 2

रूबी - 547 393

नया संस्करण, सुझाव के लिए धन्यवाद:

e='HHeLiBeBCNOFNeNaMgAlSiPSClArKaCaScTiVCrMnFeCoNiCuZnGaGeAsSeBrKrRbSrYZrNbMoTcRuRhPdAgCdInSnSbTeIXeCsBaLaCePrNdPmSmEuGdTbDyHoErTmYbLuHfTaWReOsIrPtAuHgTlPbBiPoAtRnFrRaAcThPaUNpPuAmCmBkCfEsFmMdNoLrRfDbSgBhHsMtDsRgCnUutFlUupLvUusUuo'.scan(/[A-Z][a-z]*/).map &:upcase
r="(#{e.join ?|})"
$<.each{|w|(i=0;i+=1 until w=~/^#{r*i}$/i
$><<w;p$~.to_a[1..-1].map{|m|e.index(m.upcase)+1})if w=~/^#{r}+$/i}

---

e=%w{h he li be b c n o f ne na mg al si p s cl ar ka 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 uuo}
x = "(#{e.join(?|)})"
regex = /^#{x}+$/i
File.foreach('/usr/share/dict/words'){|w|
if w=~/^#{x}+$/i
puts w
i=1
i+=1 until w=~/^#{x*i}$/i 
puts $~[1..-1].map{|m|e.index(m.downcase)+1}.join ?-
end
}

रेग्जेस का उपयोग करता है। धीमी गति से, और सुधार के लिए बहुत जगह है लेकिन मुझे अभी जाना चाहिए :-)

Comments

1) आप पीटर टेलर की चाल (अपने मूल कोड के अनुसार) का उपयोग करके भंडारण को रोक सकते हैं e='HHeLiBe...LvUusUuo'.scan(/[A-Z][a-z]*/).map &:downcase:। 2) चर regex का उपयोग कभी नहीं किया जाता है। 3) मानक इनपुट से शब्द पढ़ें $<.each{|w|...:। इन संशोधन के साथ कोड 410 वर्णों तक कम हो गया।

— मैनटवर्क

मुझे लगता है कि आप स्कैन रेगेक्स में दो पात्रों को जोड़ने की लागत पर अनावश्यक तत्वों के लिए भी एक ही स्थान-बचत दृष्टिकोण लागू कर सकते हैं। अंतरिक्ष का उपयोग करें यदि आप newlines को पसंद नहीं करते हैं - मैं मुख्य रूप से newlines का उपयोग कर रहा हूं ताकि मुख्य लूप को देखने के लिए स्क्रॉल करना आवश्यक न हो।

— पीटर टेलर

Answer 3

पायथन 710 (357 + 261 + 92)

e=". h he li be b c n o 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 uuo".split()

i=e.index
def m(w,p=("",[])):
 if not w:return p
 x,y,z=w[0],w[:2],w[:3]
 if x!=y and y in e:
    a=m(w[2:],(p[0]+y,p[1]+[i(y)]))
    if a:return a
 if x in e:
    b=m(w[1:],(p[0]+x,p[1]+[i(x)]))
    if b:return b
 if z in e:
    c=m(w[3:],(p[0]+z,p[1]+[i(z)]))
    if c:return c

f=open('/usr/share/dict/words','r')
for l in f:
 x=m(l[:-1])
 if x:print x[0],x[1]
f.close()

वहाँ कहीं न कहीं सुधार की गुंजाइश है। यह भी ध्यान देने योग्य है कि इंडेंटेशन का दूसरा स्तर टैब वर्ण का उपयोग करता है।

पूरे शब्दकोश से गुजरने में सिर्फ 5 सेकंड से अधिक (मेरे कंप्यूटर पर) लगता है, इस तरह से आउटपुट का उत्पादन होता है:

acaciin [89, 89, 53, 49]
acacin [89, 89, 49]
acalycal [89, 13, 39, 6, 13]
...

अन्य 18 वर्णों को जोड़कर , आप सही कैपिटलाइज़ेशन के साथ आउटपुट प्राप्त कर सकते हैं:

e=". H He Li Be B C N O 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 Uuo".split()

i=e.index
def m(w,p=("",[])):
 if not w:return p
 w=w.capitalize()
 x,y,z=w[0],w[:2],w[:3]
 if x!=y and y in e:
    a=m(w[2:],(p[0]+y,p[1]+[i(y)]))
    if a:return a
 if x in e:
    b=m(w[1:],(p[0]+x,p[1]+[i(x)]))
    if b:return b
 if z in e:
    c=m(w[3:],(p[0]+z,p[1]+[i(z)]))
    if c:return c

OUTPUT:

AcAcIIn [89, 89, 53, 49]
AcAcIn [89, 89, 49]
AcAlYCAl [89, 13, 39, 6, 13]
...

आप व्यक्तिगत शब्द भी देख सकते हैं:

>>> m("beer")
('beer', [4, 68])

Comments

क्या आप वह जोड़ सकते हैं जो उचित पूंजीकरण का उत्पादन करता है? मुझे लगता है कि यह बहुत साफ है और मैं अजगर के लिए बहुत नया हूं।

— रोब

Answer 4

पायथन - 1328 (975 + 285 कोड का कोड + 68 शब्दकोश कोड)

t1={'c':6,'b':5,'f':9,'i':53,'h':1,'k':19,'o':8,'n':7,'p':15,
's':16,'u':92,'w':74,'v':23,'y':39}
t2={'ru':44,'re':75,'rf':104,'rg':111,'ra':88,'rb':37,
'rn':86,'rh':45,'be':4,'ba':56,'bh':107,'bi':83,
'bk':97,'br':35,'os':76,'ge':32,'gd':64,'ga':31,
'pr':59,'pt':78,'pu':94,'pb':82,'pa':91,'pd':46,
'cd':48,'po':84,'pm':61,'hs':108,'ho':67,'hf':72,
'hg':80,'he':2,'md':101,'mg':12,'mo':42,'mn':25,
'mt':109,'zn':30,'eu':63,'es':99,'er':68,'ni':28,
'no':102,'na':11,'nb':41,'nd':60,'ne':10,'np':93,
'fr':87,'fe':26,'fl':114,'fm':100,'sr':38,'kr':36,
'si':14,'sn':50,'sm':62,'sc':21,'sb':51,'sg':106,
'se':34,'co':27,'cn':112,'cm':96,'cl':17,'ca':20,
'cf':98,'ce':58,'xe':54,'lu':71,'cs':55,'cr':24,
'cu':29,'la':57,'li':3,'lv':116,'tl':81,'tm':69,
'lr':103,'th':90,'ti':22,'te':52,'tb':65,'tc':43,
'ta':73,'yb':70,'db':105,'dy':66,'ds':110,'at':85,
'ac':89,'ag':47,'ir':77,'am':95,'al':13,'as':33,
'ar':18,'au':79,'zr':40,'in':49}
t3={'uut':113,'uuo':118,'uup':115,'uus':117}
def p(s):
 o=0;b=0;a=[];S=str;l=S.lower;h=dict.has_key;L=len
 while o<L(s):
  D=0
  for i in 1,2,3:exec('if h(t%d,l(s[o:o+%d])) and b<%d:a+=[S(t%d[s[o:o+%d]])];o+=%d;b=0;D=1'%(i,i,i,i,i,i))
  if D==0:
   if b==3 or L(a)==0:return
   else:b=L(S(a[-1]));o-=b;a.pop()
 return '-'.join(a)

शब्दकोश भाग के लिए:

f=open(input(),'r')
for i in f.readlines():print p(i[:-1])
f.close()

Comments

यह एक स्पष्ट हैश आरंभीकरण का उपयोग करने की तुलना में एक स्पष्ट सरणी आरंभीकरण का उपयोग करने के लिए वास्तव में छोटा है और इसे हैश के सूचकांक में बदल देता है?

— पीटर टेलर

मैंने आसानी से उपयोग के लिए एक शब्दकोश का उपयोग किया। टुपल्स की एक सरणी होने से थोड़ा अधिक चरित्र महंगा होगा। हालांकि तत्वों का आदेश देना एक अच्छा विचार होगा ...

— भालू

Answer 5

C, 775 771 वर्ण

char*e[]={"h","he","li","be","b","c","n","o","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","uu",0};
b[99],n;
c(w,o,l)char*w,*o,**l;{
    return!*w||!strncmp(*l,w,n=strlen(*l))&&c(w+n,o+sprintf(o,",%d",l-e+1),e)||*++l&&c(w,o,l);
}
main(){
    while(gets(b))c(b,b+9,e)&&printf("%s%s\n",b,b+9);
}

इनपुट : वर्ड प्रति लाइन, लोअरकेस होना चाहिए। usr/share/dict/wordsठीक है।
आउटपुट : शब्द और संख्या, उदाहरण के लिए:acceptances,89,58,15,73,7,6,99

तर्क :
c(w,o,l)शब्द की जाँच करता है w, तत्व से शुरू l।
दो-तरफ़ा पुनरावृत्ति का उपयोग किया जाता है - यदि पहला तत्व तत्व सूची के प्रमुख से मेल खाता है, तो wपूर्ण तत्व सूची के विरुद्ध रहने वाले की जांच करें । यदि यह मैच विफल हो जाता है, तो सूची की पूंछ के खिलाफ शब्द की जांच करें।
बफर oसफल पथ के साथ तत्व संख्याओं को जमा करता है। एक मैच के बाद, इसमें संख्याओं की सूची होगी, और मुद्रित है।

समस्याएँ :
सूची कुशलता से एन्कोडेड नहीं है - बहुत अधिक "और ,"। लेकिन इस तरह इसका उपयोग करना आसान है। मुझे यकीन है कि कोड में बहुत अधिक लागत के बिना, इसमें बहुत सुधार किया जा सकता है।