चुनौती

एक रसायन के सूत्र को देखते हुए, कंपाउंड के M _r को आउटपुट करें ।

समीकरण

यौगिक में प्रत्येक तत्व के बाद एक संख्या है जो यौगिक में उक्त परमाणु की संख्या को दर्शाता है। यदि कोई संख्या नहीं है, तो उस यौगिक में केवल एक परमाणु है।

कुछ उदाहरण निम्न हैं:

इथेनॉल (C ₂ H ₆ O) वह होगा C2H6Oजहां दो कार्बन परमाणु, 6 हाइड्रोजन परमाणु और 1 ऑक्सीजन परमाणु होते हैं
मैग्नीशियम हाइड्रॉक्साइड (MgO ₂ H ₂ ) वह होता है MgO2H2जहाँ एक मैग्नीशियम परमाणु, दो ऑक्सीजन परमाणु और दो हाइड्रोजन परमाणु होते हैं।

ध्यान दें कि आपको कभी भी कोष्ठक को संभालना नहीं पड़ेगा और प्रत्येक तत्व सूत्र में केवल एक बार शामिल किया गया है।

जबकि अधिकांश लोग संभवतः उस क्रम से चिपके रहेंगे जिसके साथ वे सबसे सहज महसूस करते हैं, कोई सख्त व्यवस्था नहीं है। उदाहरण के लिए, पानी H2Oया तो दिया जा सकता है OH2।

एम। _आर

ध्यान दें: यहाँ, सूत्र द्रव्यमान आणविक द्रव्यमान के समान है

एक यौगिक का एम _r , आणविक द्रव्यमान, अणु में परमाणुओं के परमाणु भार का योग है।

1 दशमलव स्थान के लिए एकमात्र तत्व और उनके परमाणु वजन जो आपको समर्थन करना है (हाइड्रोजन से कैल्शियम, महान गैसों सहित नहीं) निम्नानुसार है। उन्हें यहां भी पाया जा सकता है

H  - 1.0      Li - 6.9      Be - 9.0
B  - 10.8     C  - 12.0     N  - 14.0
O  - 16.0     F  - 19.0     Na - 23.0
Mg - 24.3     Al - 27.0     Si - 28.1
P  - 31.0     S  - 32.1     Cl - 35.5
K  - 39.1     Ca - 40.1

आपको हमेशा एक दशमलव स्थान पर आउटपुट देना चाहिए।

उदाहरण के लिए, इथेनॉल ( C2H6O) में एक एम _आर है 46.0क्योंकि इसमें तत्वों के परमाणु भार का योग है:

12.0 + 12.0 + 1.0 + 1.0 + 1.0 + 1.0 + 1.0 + 1.0 + 16.0
(2*C + 6*H + 1*O)

इनपुट

उपरोक्त प्रारूप में एक स्ट्रिंग । आप गारंटी दे सकते हैं कि समीकरण में शामिल तत्व वास्तविक तात्विक प्रतीक होंगे।

दिए गए यौगिक वास्तविकता में मौजूद होने की गारंटी नहीं है।

उत्पादन

यौगिक का कुल M _r , 1 दशमलव स्थान पर।

नियम

तत्व या रासायनिक डेटा का उपयोग करने वाले बिल्डरों को अस्वीकृत कर दिया जाता है (क्षमा करें, Mathematica)

उदाहरण

Input > Output
CaCO3 > 100.1
H2SO4 > 98.1
SF6 > 146.1
C100H202O53 > 2250.0

जीतना

बाइट्स में सबसे छोटा कोड जीतता है।

इस पद को केयर्ड सिक्काहाहिंग की अनुमति से अपनाया गया था । (पोस्ट अब हटा दिया गया है)

code-golf kolmogorov-complexity chemistry

— बीटा डिके
स्रोत

क्या हमें क्वांटिफायर को संभालना होगा, जैसे 2H2O:?

— श्री एक्सकोडर

6

जिज्ञासु के लिए, यह गणितज्ञ समाधान (53 बाइट्स) है:NumberForm[#&@@#~ChemicalData~"MolecularMass",{9,1}]&

— जंगवान मिन

6

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

ḟØDOP%⁽¡ṛị“ÇṚÆ’BH+“Ḳ"ɦṀ⁷6<s¡_-¦y⁼Ḟ¡¡FPɓ‘¤÷5
fØDVȯ1×Ç
Œs>œṗ⁸ḊÇ€S

पात्रों की एक सूची को स्वीकार करने और एक नंबर वापस करने के लिए एक विवादास्पद लिंक।

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

कैसे?

ḟØDOP%⁽¡ṛị“ÇṚÆ’BH+“Ḳ"ɦṀ⁷6<s¡_-¦y⁼Ḟ¡¡FPɓ‘¤÷5 - Link 1, Atomic weight: list of characters
                                            -                              e.g. "Cl23"
 ØD                                         - digit yield = "0123456789"
ḟ                                           - filter discard                      "Cl"
   O                                        - cast to ordinals                [67,108]
    P                                       - product                            7236
      ⁽¡ṛ                                   - base 250 literal = 1223
     %                                      - modulo                             1121
                                        ¤   - nilad followed by link(s) as a nilad:
          “ÇṚÆ’                             -   base 250 literal  = 983264
               B                            -   convert to binary = [    1,    1,     1,     1,   0,  0,  0,   0, 0,  0,  0, 0,     1,     1,     1, 0, 0,  0,  0,   0]
                H                           -   halve             = [  0.5,  0.5,   0.5,   0.5,   0,  0,  0,   0, 0,  0,  0, 0,   0.5,   0.5,   0.5, 0, 0,  0,  0,   0]
                  “Ḳ"ɦṀ⁷6<s¡_-¦y⁼Ḟ¡¡FPɓ‘    -   code-page indexes = [177  , 34  , 160  , 200  , 135, 54, 60, 115, 0, 95, 45, 5, 121  , 140  , 195  , 0, 0, 70, 80, 155]
                 +                          -   addition          = [177.5, 34.5, 160.5, 200.5, 135, 54, 60, 115, 0, 95, 45, 5, 121.5, 140.5, 195.5, 0, 0, 70, 80, 155]
         ị                                  - index into (1-indexed and modular)
                                            -    ...20 items so e.g. 1121%20=1 so 177.5
                                         ÷5 - divide by 5                          35.5

fØDVȯ1×Ç - Link 2: Total weight of multiple of atoms: list of characters   e.g. "Cl23"
 ØD      - digit yield = "0123456789"
f        - filter keep                                                            "23"
   V     - evaluate as Jelly code                                                  23
    ȯ1   - logical or with one (no digits yields an empty string which evaluates to zero)
       Ç - call last link (1) as a monad (get the atomic weight)                   35.5
      ×  - multiply                                                               816.5

Œs>œṗ⁸ḊÇ€S - Main link: list of characters                             e.g. "C24HCl23"
Œs         - swap case                                                      "c24hcL23"
  >        - greater than? (vectorises)                                      10011000
     ⁸     - chain's left argument                                          "C24HCl23"
   œṗ      - partition at truthy indexes                          ["","C24","H","Cl23"]
      Ḋ    - dequeue                                                 ["C24","H","Cl23"]
       Ç€  - call last link (2) as a monad for €ach                  [  288,  1,  816.5]
         S - sum                                                                 1105.5

— जोनाथन एलन
स्रोत

यह मेरे द्वारा देखे गए सबसे लंबे जेली उत्तरों में से एक है, लेकिन यह अभी भी दूसरे की तुलना में वर्तमान में कार्यक्रम की लंबाई से आधे से भी कम है, इसलिए अच्छा काम है!

— ग्राईफॉन

6

पायथन 3 , 189 182 168 बाइट्स

जस्टिन मैरिनर के जावास्क्रिप्ट (ES6) उत्तर से हैश का उपयोग करके -14 बाइट्स ।

import re
lambda s:sum([[9,35.5,39.1,24.3,28.1,14,16,31,40.1,23,32.1,10.8,12,27,6.9,19,0,1][int(a,29)%633%35%18]*int(n or 1)for a,n in re.findall("(\D[a-z]?)(\d*)",s)])

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

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

import re
lambda s:sum([[16,31,40.1,32.1,0,24.3,12,39.1,28.1,19,0,9,10.8,23,27,35.5,6.9,14,1][ord(a[0])*ord(a[-1])%1135%98%19]*int(n or 1)for a,n in re.findall("(\D[a-z]?)(\d*)",s)])

एक अनाम फ़ंक्शन एक स्ट्रिंग को स्वीकार करता है, s , और एक नंबर लौटाता है।

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

कैसे?

sतत्वों का उपयोग करते हुए इनपुट को विभाजित करने के लिए एक regex का उपयोग करता है , और उनकी गणना का उपयोग करता है:
re.findall("(\D[a-z]?)(\d*)",s)
\Dएक गैर-अंक से [a-z]?मेल खाता है और 0 या 1 लोअरकेस अक्षर से मेल खाता है, एक साथ मिलान तत्व। \d*0 या अधिक अंकों से मेल खाता है। कोष्ठकों को दो समूहों में इन बनाने के लिए, और इस तरह के रूप findall("...",s)रिटर्न तार की tuples की एक सूची, [(element, number),...]।

संख्या निकालने के लिए सरल है, संभाल करने के लिए केवल एक चीज यह है कि एक खाली स्ट्रिंग का मतलब 1 है, यह एक तार्किक के साथ प्राप्त किया जाता है or के बाद से अजगर तार falsey हैं: int(n or 1)।

तत्व स्ट्रिंग को अपने पहले और अंतिम चरित्र के अध्यादेशों के उत्पाद को ले कर एक अद्वितीय संख्या दी जाती है (आमतौर पर ये वही हैं जैसे S या C, लेकिन हमें Cl, C, Ca और Na के बीच अंतर करने की आवश्यकता है इसलिए हम सिर्फ एक का उपयोग नहीं कर सकते हैं चरित्र)।

इन नंबरों को [0,18] की एक बहुत छोटी रेंज को कवर करने के लिए हैशेड किया जाता है, जिसके परिणामस्वरूप मॉडुलो स्पेस की खोज होती है %1135%98%19। उदाहरण के लिए "Cl"ऑर्डिनल 67और 108, जो गुणा करने के लिए है 7736, जो, मोडुलो 1135है 426, जो मोडुलो 98है 34, जो मोडुलो 19है 15; यह संख्या पूर्णांक की सूची में अनुक्रमित करने के लिए उपयोग की जाती है - सूची में 15 वां (0-अनुक्रमित) मूल्य:
[16,31,40.1,32.1,0,24.3,12,39.1,28.1,19,0,9,10.8,23,27,35.5,6.9,14,1]
है35.5 , Cl का परमाणु भार, जो तब ऐसे तत्वों की संख्या से गुणा किया जाता है (जैसा कि ऊपर पाया गया है)।

इन उत्पादों को फिर एक साथ जोड़कर उपयोग किया जाता है sum(...)।

— जोनाथन एलन
स्रोत

आप एक जीनियस हैं ... मुझे 350 से अधिक बाइट्स से बाहर कर दिया

— श्री एक्सकोडर

4

PHP , 235 बाइट्स

preg_match_all("#([A-Z][a-z]?)(\d*)#",$argn,$m);foreach($m[1]as$v)$s+=array_combine([H,Li,Be,B,C,N,O,F,Na,Mg,Al,Si,P,S,Cl,K,Ca],[1,6.9,9,10.8,12,14,16,19,23,24.3,27,28.1,31,32.1,35.5,39.1,40.1])[$v]*($m[2][+$k++]?:1);printf("%.1f",$s);

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

array_combine([H,Li,Be,B,C,N,O,F,Na,Mg,Al,Si,P,S,Cl,K,Ca],[1,6.9,9,10.8,12,14,16,19,23,24.3,27,28.1,31,32.1,35.5,39.1,40.1])आप के बजाय [H=>1,Li=>6.9,Be=>9,B=>10.8,C=>12,N=>14,O=>16,F=>19,Na=>23,Mg=>24.3,Al=>27,Si=>28.1,P=>31,S=>32.1,Cl=>35.5,K=>39.1,Ca=>40.1]एक ही बाइट गिनती के साथ उपयोग कर सकते हैं

— जार्ग हुल्सरमन
स्रोत

3

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

c=>c.replace(/(\D[a-z]?)(\d+)?/g,(_,e,n=1)=>s+=[9,35.5,39.1,24.3,28.1,14,16,31,40.1,23,32.1,10.8,12,27,6.9,19,0,1][parseInt(e,29)%633%35%18]*n,s=0)&&s

जोनाथन एलन के पायथन उत्तर से प्रेरित , जहां उन्होंने प्रत्येक तत्व को एक विशिष्ट संख्या देने के लिए समझाया और उन संख्याओं को एक छोटी सीमा में रखने के लिए हैशिंग किया।

तत्वों को अद्वितीय संख्या में आधार -29 (0-9 और एएस) के रूप में व्याख्या करके बनाया गया था। फिर मैंने पाया कि विशिष्टता को बनाए रखते हुए %633%35%18मूल्यों को नीचे की सीमा तक ले जाता है [0, 17]।

टेस्ट स्निपेट

f=
c=>c.replace(/(\D[a-z]?)(\d+)?/g,(_,e,n=1)=>s+=[9,35.5,39.1,24.3,28.1,14,16,31,40.1,23,32.1,10.8,12,27,6.9,19,0,1][parseInt(e,29)%633%35%18]*n,s=0)&&s

Input: <input oninput="O.value=f(this.value)"><br>
Result: <input id="O" disabled>

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

— जस्टिन मेरिनर
स्रोत

ओह, मुझे लगता है कि आपका रास्ता मुझे कुछ बाइट्स भी बचाएगा!

— जोनाथन एलन

2

क्लोजर, 198 194 बाइट्स

अद्यतन: से बेहतर forहै reduce।

#(apply +(for[[_ e n](re-seq #"([A-Z][a-z]?)([0-9]*)"%)](*(if(=""n)1(Integer. n))({"H"1"B"10.8"O"16"Mg"24.3"P"31"K"39.1"Li"6.9"C"12"F"19"Al"2"S"32.1"Ca"40.1"Be"9"N"14"Na"23"Si"28.1"Cl"35.5}e))))

मूल:

#(reduce(fn[r[_ e n]](+(*(if(=""n)1(Integer. n))({"H"1"B"10.8"O"16"Mg"24.3"P"31"K"39.1"Li"6.9"C"12"F"19"Al"2"S"32.1"Ca"40.1"Be"9"N"14"Na"23"Si"28.1"Cl"35.5}e))r))0(re-seq #"([A-Z][a-z]?)([0-9]*)"%))

मुझे आश्चर्य है कि अगर लुक-अप टेबल को एनकोड करने के लिए अधिक कॉम्पैक्ट तरीका है।

— NikoNyrh
स्रोत

2

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

def m(f,j=0):
 b=j+1
 while'`'<f[b:]<'{':b+=1
 c=b
 while'.'<f[c:]<':':c+=1
 return[6.9,9,23,40.1,24.3,27,28.1,35.5,31,32.1,39.1,1,10.8,12,14,16,19]['Li Be Na Ca Mg Al Si Cl P S K H B C N O F'.split().index(f[j:b])]*int(f[b:c]or 1)+(f[c:]>' 'and m(f,c))

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

— OVS
स्रोत

1

गणितज्ञ, 390 338 329 बाइट्स

वास्तव में अब जागे होने के कारण 9 बाइट्स की बचत हुई और वास्तव में मेरा इरादा छोटा कर दिया गया।

संस्करण 2.1:

S=StringSplit;Total[Flatten@{ToExpression@S[#,LetterCharacter],S[#,DigitCharacter]}&/@S[StringInsert[#,".",First/@StringPosition[#,x_/;UpperCaseQ[x]]],"."]/.{"H"->1,"Li"->3,"Be"->9,"B"->10.8,"C"->12,"N"->14,"O"->16,"F"->19,"Na"->23,"Mg"->24.3,"Al"->27,"Si"->28.1,"P"->31,"S"->32.1,"Cl"->35.5,"K"->39.1,"Ca"->40.1}/.{a_,b_}->a*b]&

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

संस्करण 1:

मुझे यकीन है कि यह बहुत गोल्फ हो सकता है (या बस पूरी तरह से फिर से लिखा गया है)। मैं बस यह पता लगाना चाहता था कि यह कैसे करना है। (सुबह इस पर प्रतिबिंबित करेंगे।)

F=Flatten;d=DigitCharacter;S=StringSplit;Total@Apply[Times,#,2]&@(Transpose[{F@S[#,d],ToExpression@F@S[#,LetterCharacter]}]&@(#<>If[StringEndsQ[#,d],"","1"]&/@Fold[If[UpperCaseQ[#2],Append[#,#2],F@{Drop[#,-1],Last[#]<>#2}]&,{},StringPartition[#,1]]))/.{"H"->1,"Li"->3,"Be"->9,"B"->10.8,"C"->12,"N"->14,"O"->16,"F"->19,"Na"->23,"Mg"->24.3,"Al"->27,"Si"->28.1,"P"->31,"S"->32.1,"Cl"->35.5,"K"->39.1,"Ca"->40.1}&

स्पष्टीकरण: पहले स्ट्रिंग को वर्णों में विभाजित करें। फिर लोअरकेस वर्णों और संख्याओं को अपनी राजधानी में शामिल करने वाले सरणी पर मोड़ो। अगला किसी भी रासायनिक को अंत में एक संख्या के बिना 1 अपेंड करें। फिर सरणी में शर्तों के दो विभाजन करते हैं - एक सभी संख्याओं में विभाजित और एक सभी अक्षरों में विभाजित होता है। पहले पत्रों को उनके दाढ़ के द्रव्यमान से बदलें, फिर इन दो सूचियों के डॉट उत्पाद को खोजें।

— इयान मिलर
स्रोत

1

पायथन 3 - 408 बाइट्स

यह मुख्य रूप से @ovs का समाधान है, क्योंकि उन्होंने इसे 120 बाइट्स से नीचे गिराया था ... नीचे प्रारंभिक समाधान देखें।

e='Li Be Na Ca Mg Al Si Cl P S K H B C N O F'.split()
f,g=input(),[]
x=r=0
for i in e:
 if i in f:g+=[(r,eval('6.9 9 23 40.1 24.3 27 28.1 35.5 31 32.1 39.1 1 10.8 12 14 16 19'.split()[e.index(i)]))];f=f.replace(i,' %d- '%r);r+=1
h=f.split()
for c,d in zip(h,h[1:]):
 s=c.find('-')
 if-1<s:
  if'-'in d:
   for y in g:x+=y[1]*(str(y[0])==c[:s])
  else:
   for y in g:x+=y[1]*int(d)*(str(y[0])==c[:s])
print(x)

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

अजगर 3 - 550 548 535 बाइट्स (इंडेंटेशन के साथ गिनती खो गई)

^{@Cairdcoinheringaahing के लिए 10 बाइट्स को सहेजा गया और 3 ने ओव्स के लिए धन्यवाद बचाया}

मेरा एक व्यक्तिगत लक्ष्य था कि किसी भी रेगेक्स का उपयोग न करें, और इसे मज़ेदार, पुराने-स्कूल तरीके से करें ... यह रेगेक्स समाधान की तुलना में 350 बाइट्स से अधिक लंबा हो गया, लेकिन यह केवल पायथन के मानक पुस्तकालय का उपयोग करता है ...

a='Li6.9 Be9. Na23. Ca40.1 Mg24.3 Al27. Si28.1 Cl35.5 P-31. S-32.1 K-39.1 H-1. B-10.8 C-12. N-14. O-16. F-19.'.split()
e,m,f,g,r=[x[:1+(x[1]>'-')]for x in a],[x[2:]for x in a],input(),[],0
for i in e:
 if i in f:g.append((r,float(m[e.index(i)])));f=f.replace(i,' '+str(r)+'- ');r+=1;
h,x=f.split(),0
for i in range(len(h)):
 if '-'in h[i]:
    if '-'in h[i+1]:
     for y in g:x+=y[1]*(str(y[0])==h[i][:h[i].index('-')])
    else:
        for y in g:
         if str(y[0])==h[i][:h[i].index('-')]:x+=(y[1])*int(h[i+1])
 else:1
print(x)

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

^{अगर कोई इसे नीचे करने के लिए तैयार है (इंडेंटेशन फिक्स और अन्य ट्रिक्स के साथ ...), तो यह 100% अच्छी तरह से प्राप्त होगा, ऐसा महसूस करना कि ऐसा करने का एक बेहतर तरीका है ...}

— मिस्टर एक्सकोडर
स्रोत

आप के for y in g: if str(y[0])==h[i][:h[i].index('-')]:x+=y[1]साथ बदल सकते हैंfor y in g:x+=y[1]*(str(y[0])==h[i][:h[i].index('-')])

— caird coinheringaahing

@cairdcoinheringaahing आह, महान ... अद्यतन जब मैं एक कंप्यूटर के लिए उपयोग किया है

— श्री Xcoder

@ovs बहुत बहुत धन्यवाद! आपको जवाब में श्रेय दिया गया

— श्री एक्सकोडर

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

— पावेल

@Phoixix नहीं तो if/for/whileअगली लाइन पर। जैसा कि यह हर इंडेंटेड लाइन पर होता है, आप इसके द्वारा बाइट्स नहीं बचा सकते।

— अंड

दिए गए यौगिक के श्री का पता लगाएं!

चुनौती

समीकरण

एम। आर

इनपुट

उत्पादन

नियम

उदाहरण

जीतना

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

कैसे?

पायथन 3 , 189 182 168 बाइट्स

कैसे?

PHP , 235 बाइट्स

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

टेस्ट स्निपेट

क्लोजर, 198 194 बाइट्स

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

गणितज्ञ, 390 338 329 बाइट्स

पायथन 3 - 408 बाइट्स

अजगर 3 - 550 548 535 बाइट्स (इंडेंटेशन के साथ गिनती खो गई)

एम। _आर