पागल रासायनिक समीकरण

Question

आपको उपयोगकर्ता से रासायनिक समीकरण (कोई रिक्त स्थान नहीं, केवल अक्षर (ऊपरी-मामले और निचला-मामला), संख्या, कोष्ठक और गणित संकेत) मिलना चाहिए और उत्तर को प्रिंट करना चाहिए कि समीकरण संतुलित है या नहीं (सकारात्मक / नकारात्मक उत्तरों में से कोई भी युग्म) : हां / नहीं, सच / गलत, 1/0)। कोड को छोटा बनाने के लिए आप मान सकते हैं कि इनपुट स्ट्रिंग्स में केवल ये तत्व हो सकते हैं: अल, अर, बी, बी, सी, सीएल, सीआर, क्यू, फे, एच, हे, के, एन, ओ, एस और एक और बात। : वहाँ -संकेत हो सकता है। यह गणित के बारे में सब कुछ है: +इसके अलावा का -मतलब है , घटाव का मतलब है।

उदाहरण:

इनपुट:

C6H5COOH-O2=7CO2+3H2O

आउटपुट:

No

---

इनपुट:

2Fe(CN)6+2SO2+202=Fe2(SO4)2+6C2N2

आउटपुट:

Yes

---

इनपुट:

2SO2=2SO4-2O2

आउटपुट:

Yes

सबसे छोटा कोड जीतता है।

Comments

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

— माउंटनवार्कमार्क

संबंधित: शेष रासायनिक समीकरण

— पीटर टेलर

@MtnViewMark यह एक कार्यक्रम माना जाता है। इसे प्रति रन एक समीकरण लेना चाहिए।

— gthacoder

आपके दूसरे और तीसरे उदाहरण गलत हैं। मुझे लगता है कि आपको (दो सौ और दो) के 2O2बजाय टाइप करना था 202।

— r3mainer

@squeamishossifrage ओह, हाँ। ज़रूर। धन्यवाद। प्रश्न अद्यतन है।

— gthacoder

Answer 1

गणितज्ञ 152

f=Times@@@Tr@CoefficientRules@ToExpression@(r=StringReplace)[r[
#<>")",{"="->"-(",x:_?LetterQ|")"~~y_?DigitQ:>x<>"^"<>y}],x_?UpperCaseQ:>" "<>x]⋃{}=={0}&

परिणाम:

f@"C6H5COOH-O2=7CO2+3H2O"
f@"2Fe(CN)6+2SO2+2O2=Fe2(SO4)2+6C2N2"
f@"2SO2=2SO4-2O2"

असत्य

सच

सच

मैं रासायनिक सूत्र को बहुपद के रूप में मानता हूं, जैसे

फिर मैं सिर्फ गुणांक गिनता हूं।

Comments

वह कैसे काम करता है? आपके उदाहरण में, प्रत्येक "चर" के गुणांक शून्य को सरल नहीं करते हैं।

— माउंटन व्यूमार्क

@MtnViewMark अधिक सटीक रूप से, मैं शक्तियों को गिनता हूं Tr@CoefficientRulesऔर फिर गुणांकों द्वारा उन्हें गुणा करता हूं Times@@@। के लिए O:, के 2*2+2*2=4*2लिए C: 2*6 = 6*2आदि

— ybeltukov

Answer 2

पायथन 2.7, 316 276 चार्ट

import re
r=re.sub
x='(^|[=+-])'
y=r'\1+\2'
z='(\w)([A-Z(])'
t=r('=','==',r(z,y,r(z,y,r('([A-Za-z)])(\d)',r'\1*\2',r('([=+-]|$)',r')\1',r(x+'(\d+)',r'\1\2*(',r(x+'([A-Z])',r'\1(\2',raw_input())))))))
E=re.findall('[A-Za-z]+',t)
print all(eval(t,{f:f==e for f in E})for e in E)

यह इनपुट समीकरण को कुछ evalसक्षम में बदलने के लिए बहुत सारे रेगेक्स-पुनर्लेखन करता है । फिर यह व्यक्तिगत रूप से प्रत्येक तत्व के लिए समीकरण की जांच करता है।

उदाहरण के लिए, उदाहरण समीकरण ( tचर) को फिर से लिखता है :

(C*6+H*5+C+O+O+H)-(O*2)==7*(C+O*2)+3*(H*2+O)
2*(Fe+(C+N)*6)+2*(S+O*2)+2*(O*2)==(Fe*2+(S+O*4)*2)+6*(C*2+N*2)
2*(S+O*2)==2*(S+O*4)-2*(O*2)

मुझे यकीन है कि रेगेक्स भाग में अधिक गोल्फ होना था।

Answer 3

हास्केल, 400 351 308 वर्ण

import Data.List
import Text.Parsec
(&)=fmap
r=return
s=string
l f b=(>>=(&b).f)
x=(=<<).replicate
m=sort&chainl1(l x(concat&many1(l(flip x)n i))n)((s"+">>r(++))<|>(s"-">>r(\\)))
i=between(s"(")(s")")m<|>(:[])&(l(:)(many lower)upper)
n=option 1$read&many1 digit
main=getContents>>=parseTest(l(==)(s"=">>m)m)

यह सिर्फ सभी गोल्फ इसे से बाहर निचोड़ा हो सकता है। मुझे नहीं पता कि क्या कोई और १०० ५१ to अक्षर बचाना है!

& echo 'C6H5COOH-O2=7CO2+3H2O' | runhaskell Chemical.hs
False

& echo '2Fe(CN)6+2SO2+2O2=Fe2(SO4)2+6C2N2' | runhaskell Chemical.hs
True

& echo '2SO2=2SO4-2O2' | runhaskell Chemical.hs
True

यदि कोई भी साथ चलना चाहता है, तो यहाँ ungolf'd संस्करण है। यह एक साधारण Parsecआधारित पार्सर है:

import Control.Applicative ((<$>), (<*>))
import Data.List
import Text.Parsec
import Text.Parsec.String (Parser)

type Atom = String

{- golf'd as x -}
multiple :: Int -> [Atom] -> [Atom]
multiple n = concat . replicate n

{- golf'd as m -}
chemicals :: Parser [Atom]
chemicals = sort <$> chainl1 molecules op
  where
    op :: Eq a => Parser ([a] -> [a] -> [a])
    op = (char '+' >> return (++))
     <|> (char '-' >> return (\\))

    molecules :: Parser [Atom]
    molecules = multiple <$> number <*> terms

    terms :: Parser [Atom]
    terms = concat <$> many1 term

    term :: Parser [Atom]
    term = flip multiple <$> item <*> number

{- gofl'd as i -}
item :: Parser [Atom]
item = between (char '(') (char ')') chemicals
   <|> (:[]) <$> atom
  where
    atom :: Parser Atom
    atom = (:) <$> upper <*> many lower

{- gofl'd as n -}
number :: Parser Int
number = option 1 $ read <$> many1 digit

{- gofl'd as main -}
main :: IO ()
main = getContents >>= parseTest chemEquality
  where
    chemEquality :: Parser Bool
    chemEquality = (==) <$> chemicals <*> (char '=' >> chemicals)