View difference between Paste ID: RfFiHBHy and wa1S6aCp

 def d(s):
 	raw_input("----DEBUG----{0}".format(s))
 
 # Class Molecule:
 #   elements: a dictionary of elements and their subscripts
 #   count: the coefficient on the molecule
 class Molecule:
 	class Atomic: # Represents a {Element}_{Subscript} structure (no coefficient)
 		def __init__(self, el, sub):
 			self.element = el
 			self.subscript = sub
 		def getElement(self):
 			return self.element
 		def getSubscript(self):
 			return self.subscript
 
 	def __init__(self):
 		self.elements = dict()
 		self.count = 1
 
 	def __str__(self):
 		ret = "{"+str(self.count)+"}"
 		for el in self.elements:
 			ret += "[{0}_{1}]".format(el,self.elements[el])
 		return ret
 
 	def getElementTotals(self):
 		ret = dict()
 		for el in self.elements.keys():
 			ret[el] = self.elements[el] * self.count
 		return ret
 
 	def add(self, atomic):
 		self.add(atomic.getElement(), atomic.getSubscript())
 
 	def add(self, element, subscript):
 		# if the molecule already contains this element, just increase the subscript
 		if element in self.elements:
-			self.add(el, mol.elements[el])
+
 		else: # otherwise, add the element and its subscript
 			self.elements[element] = subscript
 
 	def fold(self, mol):
 		for el in mol.elements.keys():
 			self.add(el, mol.elements[el] * mol.count)
 
 def getWord(s,i): # Returns a [isElem, token, lastIndex] list from a string s starting at index i
 	if i >= len(s) or i < 0:
 		return Nothing
 
 	ret = s[i]
 	isElem = ret.isalpha()
 	i += 1
 	while i < len(s):
 		#d(str((isDigit, s[i], i, ret)))
 		if not isElem:
 			if s[i].isdigit():
 				ret += s[i]
 			else:
 				return [isElem,ret,i]
 		else:
 			if s[i].isupper() or s[i].isdigit():
 				return [isElem,ret,i]
 			else:
 				ret += s[i]
 		i = i + 1
 	return [isElem,ret,i]
 
 def tokenize(s):
 	l = list()
 	i = 0
 	while i < len(s):
 		newi = getWord(s, i)
 		i = newi[2]
 		l.append(newi)
 	return l
 
 def standardize(tokens): # inserts implicit subscripts and puts them into ints
 	if tokens[0][0]:
 		tokens.insert(0,[False,1,0])
 	i = 0
 	while i < len(tokens):
 		if tokens[i][0]: # if this is an element
 			if i+1 == len(tokens):
 				tokens.append([False,1,tokens[i][2]])
 			elif tokens[i+1][0]: # if the next is also an element (ie not a subscript)
 				tokens.insert(i+1,[False,1,tokens[i][2]])
 		else: # if this was a subscript
 			tokens[i][1] = int(tokens[i][1])
 		i = i + 1
 
 	return tokens
 
 def molecularize(tokens):
 	mol = Molecule()
 	mol.count = tokens[0][1]
 	for i in range(1,len(tokens),2):
 		mol.add(tokens[i][1], tokens[i+1][1])
 	return mol
 
 def pl(l):
 	for n in l:
 		print n
 
 def getmol(s): # returns a Molecule from a string
-	return [left,right]
+	tok = tokenize(s)
 	standardize(tok)
 	mol = molecularize(tok)
-# NaOH = "NaOH"
+
-# Na2O3H = "Na2O3HC"
+
-#
+
-# t_NaOH = tokenize(NaOH)
+
-# standardize(t_NaOH)
+
-# m_NaOH = molecularize(t_NaOH)
+
-#
+
-# print "Molecule: {}".format(m_NaOH)
+
-#
+
-#
+
-# t_Na2O3H = tokenize(Na2O3H)
+	lmols = list()
-# standardize(t_Na2O3H)
+	for m in left:
-# m_Na2O3H = molecularize(t_Na2O3H)
+		lmols.append(getmol(m))
-#
+
-# print "Molecule: {}".format(m_Na2O3H)
+	rmols = list()
-#
+	for m in right:
-# m_NaOH.fold(m_Na2O3H)
+		rmols.append(getmol(m))
-#
+
-# print "Molecule: {}".format(m_NaOH)
+	return [lmols,rmols]
 
-print fission("H2O+NaOH=C6H12O6")
+def fusion(lnr): # takes the output of fission and folds them for balancing
 	if len(lnr) != 2:
-# to do the function multiple times, map(balance, sequence_of_split_tokens)
+
 		return Nothing
 
 	for side in lnr:
 		for i in range(1,len(side)):
 			side[0].fold(side[i])
 
 	return [lnr[0][0], lnr[1][0]]
 
 def balance(s):
 	print "fission"
 	fis = fission(s)
 	for side in fis:
 		pl(side)
 	print "fusion"
 	fus = fusion(fis)
 	pl(fus)
 
 	l = fus[0].getElementTotals()
 	r = fus[1].getElementTotals()
 
 	return l == r
 
 print balance("H2O+H2O=2H2O")
 # to do the function multiple times, map(balance, input.split())