Compare two strings by comparing the sum of their values (ASCII character code).

* For comparing treat all letters as UpperCase
* `null/NULL/Nil/None` should be treated as empty strings
* If the string contains other characters than letters, treat the whole string as it would be empty

Your method should return `true`, if the strings are equal and `false` if they are not equal.

## Examples:
```
"AD", "BC"  -> equal
"AD", "DD"  -> not equal
"gf", "FG"  -> equal
"zz1", ""   -> equal (both are considered empty)
"ZzZz", "ffPFF" -> equal
"kl", "lz"  -> not equal
null, ""    -> equal
```

Difficulty: EASY
Tags: String algorithms

Fundamentals

Mathematics

Starter code:
def compare(s1,s2):
	

Solutions:
def string_cnt(s):
	try:
		if s.isalpha():
			return sum((ord(a) for a in s.upper()))
	except AttributeError:
		pass
	return 0

def compare(s1, s2):
	return string_cnt(s1) == string_cnt(s2)


def compare(s1, s2):
	f = lambda x: sum(map(ord, x.upper())) if x and x.isalpha() else ''
	return f(s1) == f(s2)


def compare(s1, s2):
	if not s1 or not s1.isalpha():
		s1 = ''
	if not s2 or not s2.isalpha():
		s2 = ''
	return sum((ord(x) for x in s1.upper())) == sum((ord(y) for y in s2.upper()))


def charsum(s):
	return bool(s) and s.isalpha() and sum((ord(c) for c in s.upper()))

def compare(s1, s2):
	return charsum(s1) == charsum(s2)


def _sum(s):
	return sum((ord(c) for c in s.upper())) if s and s.isalpha() else 0

def compare(s1, s2):
	return _sum(s1) == _sum(s2)


def stringCount(str):
	try:
		if str.isalpha():
			return sum((ord(alpha) for alpha in str.upper()))
	except AttributeError:
		pass
	return 0

def compare(s1, s2):
	return stringCount(s1) == stringCount(s2)


def compare(s1, s2):
	return len(set((sum(map(ord, x.upper() if x and x.isalpha() else '')) for x in [s1, s2]))) == 1


def compare(s1, s2):
	if not s1 or s1.isalpha() is False:
		s1 = ''
	if not s2 or s2.isalpha() is False:
		s2 = ''
	return sum([ord(c) for c in s1.upper()]) == sum([ord(c) for c in s2.upper()])


def compare(s1, s2):
	if s1 == None or not s1.isalpha():
		s1 = ''
	if s2 == None or not s2.isalpha():
		s2 = ''
	return sum((ord(c.upper()) for c in s1)) == sum((ord(c.upper()) for c in s2))


def compare(s1, s2):
	return get_ascii_sum_value(s1) == get_ascii_sum_value(s2)

def get_ascii_sum_value(s):
	if s == None or len(s) == 0:
		return 0
	sum_value = 0
	for x in s:
		if not x.isalpha():
			sum_value = 0
			break
		else:
			sum_value += ord(x.upper())
	return sum_value


def compare(s1, s2):
	cmp = lambda s: sum((ord(a) for a in s.upper())) if s and s.isalpha() else 0
	return cmp(s1) == cmp(s2)


def compare(s1, s2):
	if not s1 or not s1.isalpha():
		s1 = ''
	if not s2 or not s2.isalpha():
		s2 = ''
	return sum(map(ord, s1.upper())) == sum(map(ord, s2.upper()))


(h, compare) = (lambda s: s != None and s.isalpha() and sum(map(ord, s.upper())), lambda a, b: h(a) == h(b))


def compare(s1, s2):
	get_value = lambda string: sum((ord(char) for char in string.upper())) if string and string.isalpha() else 0
	return get_value(s1) == get_value(s2)


f = lambda x: sum([ord(y) for y in list(x.upper())]) if x and x.isalpha() else 0

def compare(s1, s2):
	return f(s1) == f(s2)


def cal(s):
	if not s:
		return 0
	if not s.isalpha():
		return 0
	return sum([ord(x) for x in s.upper()])

def compare(s1, s2):
	return cal(s1) == cal(s2)


def compare(s1, s2):
	clean1 = clean(s1)
	clean2 = clean(s2)
	sum1 = ord_sum(clean1)
	sum2 = ord_sum(clean2)
	return sum1 == sum2

def clean(s):
	clean = s
	if clean == None:
		clean = ''
	for char in clean:
		if not char.isalpha():
			clean = ''
			break
	return clean

def ord_sum(s):
	ords = [ord(c.upper()) for c in s]
	return sum(ords)


def compare(s1, s2):
	n1 = n2 = 0
	if s1 and all((i.isalpha() for i in s1)):
		n1 = sum((ord(i) for i in s1.upper()))
	if s2 and all((i.isalpha() for i in s2)):
		n2 = sum((ord(i) for i in s2.upper()))
	return n1 == n2


import re

def compare(s1, s2):
	if s1 is None or s1 is [] or re.search('[^a-zA-Z]', s1):
		s1 = []
	if s2 is None or s2 is [] or re.search('[^a-zA-Z]', s2):
		s2 = []
	return True if s2 == s1 else True if sum((ord(x.upper()) for x in s1)) == sum((ord(x.upper()) for x in s2)) else False


def compare(s1, s2):
	f = lambda x: sum([ord(i.upper()) for i in x])
	g = lambda x, y: x is not None and y is not None and (not x.isalpha()) and (not y.isalpha())
	h = lambda x, y: True if x in (None, '') and y in (None, '') else False
	i = lambda x, y: x.isalpha() and y.isalpha()
	return g(s1, s2) or h(s1, s2) or ((s1 and s2 and (f(s1) == f(s2))) and i(s1, s2))


def compare(s1, s2):
	if s1 is None or not s1.isalpha():
		s1 = ''
	if s2 is None or not s2.isalpha():
		s2 = ''
	if sum([ord(x) for x in s1.upper()]) == sum([ord(x) for x in s2.upper()]):
		return True
	else:
		return False


def compare(s1, s2):
	if s1 is None or not s1.isalpha():
		s1 = ''
	if s2 is None or not s2.isalpha():
		s2 = ''
	x1 = sum([ord(i.upper()) for i in s1])
	x2 = sum([ord(i.upper()) for i in s2])
	return x1 == x2


def compare(s1, s2):
	f = lambda s: all((c.lower() in 'abcdefghijklmnopqrstuvwxyz' for c in s)) * sum((ord(c.upper()) for c in s)) if s else False
	return f(s1) == f(s2)


def compare(s1, s2):
	upper_basis_ord = lambda x: sum((ord(c) for c in x.upper())) if type(x) == str and x.isalpha() else ''
	return upper_basis_ord(s1) == upper_basis_ord(s2)


def compare(s1, s2):
	return chsum(s1) == chsum(s2)

def chsum(s):
	if not s:
		return 0
	s = s.upper()
	if any((c < 'A' or c > 'Z' for c in s)):
		return 0
	return sum((ord(c) for c in s))


def compare(s1, s2):
	try:
		if not s1.isalpha():
			s1 = ''
	except AttributeError:
		s1 = ''
	try:
		if not s2.isalpha():
			s2 = ''
	except AttributeError:
		s2 = ''
	summ = 0
	for i in s1.upper():
		summ += ord(i)
	for i in s2.upper():
		summ -= ord(i)
	return summ == 0


def compare(s1, s2):
	if s1 == None or s2 == None:
		return True
	if not s1.isalpha():
		s1 = ''
	if not s2.isalpha():
		s2 = ''
	s1 = s1.upper()
	s2 = s2.upper()
	return sum([ord(el) for el in s1]) == sum([ord(el) for el in s2])


def compare(s1, s2):

	def val(s):
		return 0 if s is None or not s.isalpha() else sum((ord(c) for c in s.upper()))
	return val(s1) == val(s2)


import re

def compare(s1, s2):

	def sums(s):
		return '' if not s or re.search('[^A-Za-z]', s) else sum((ord(x) for x in s.upper()))
	return sums(s1) == sums(s2)


def compare(s1, s2):
	return strsum(s1) == strsum(s2)

def strsum(x):
	if not type(x) == str:
		return 0
	if x.upper().isalpha():
		return sum((ord(v) for v in x.upper()))
	return 0


def compare(s1, s2):
	(val_s1, val_s2) = (0 if s1 == None or not s1.isalpha() else sum(map(ord, s1.upper())), 0 if s2 == None or not s2.isalpha() else sum(map(ord, s2.upper())))
	return val_s1 == val_s2


def compare(s1, s2):
	(a1, a2) = (0, 0)
	if s1 != None and s1 != '':
		for i in s1:
			if not i.isalpha():
				a1 = 0
				break
			else:
				a1 += ord(i.upper())
	if s2 != None or s2 != '':
		for j in s2:
			if not j.isalpha():
				a2 = 0
				break
			else:
				a2 += ord(j.upper())
	return a1 == a2


import re

def compare(s1, s2):
	if s1 and s2 and re.search('[a-zA-Z]', s1) and re.search('[a-zA-Z]', s2):
		return sum((ord(i) for i in str(s1.upper()) if re.search('[a-zA-Z]', i))) == sum((ord(i) for i in str(s2.upper()) if re.search('[a-zA-Z]', i)))
	return True


def compare(s1, s2):
	if s1 == None or [e for e in s1.lower() if not 'a' <= e <= 'z']:
		s1 = ''
	if s2 == None or [e for e in s2.lower() if not 'a' <= e <= 'z']:
		s2 = ''
	if sorted(s1.lower()) == sorted(s2.lower()):
		return True
	return sum([ord(e) for e in s1]) == sum([ord(e) for e in s2])


def compare(s1, s2):
	if s1 == None or s1.isalpha() == False:
		s1 = ''
	if s2 == None or s2.isalpha() == False:
		s2 = ''
	lst1 = [ord(char) for char in s1.upper()]
	lst2 = [ord(char) for char in s2.upper()]
	return sum(lst1) == sum(lst2)


def compare(s1, s2):
	import string
	if s1 == None or all((char in string.ascii_letters for char in s1)) == False:
		s1 = ''
	else:
		s1 = s1.upper()
	if s2 == None or all((char in string.ascii_letters for char in s2)) == False:
		s2 = ''
	else:
		s2 = s2.upper()
	lst1 = [ord(char) for char in s1]
	lst2 = [ord(char) for char in s2]
	return sum(lst1) == sum(lst2)


import re

def compare(s1, s2):
	if s1 is None or re.match('^[a-zA-Z]*$', s1) == None:
		s1 = ''
	if s2 is None or re.match('^[a-zA-Z]*$', s2) == None:
		s2 = ''
	return sum(map(ord, s1.upper())) == sum(map(ord, s2.upper()))


from re import match

def compare(s1, s2):

	def _ascii(_input):
		try:
			_input = str(_input).upper() if match('^[A-Z]+$', _input.upper()) else ''
			return sum([ord(_c) for _c in _input])
		except:
			return ''
	if _ascii(s1) == _ascii(s2):
		return True
	elif not s1 and (not s2):
		return True
	else:
		return False


def count_string(s):
	if s == '' or s == None:
		return ''
	sum_s = 0
	for i in s.upper():
		if not i.isalpha():
			return ''
		else:
			sum_s += ord(i)
	return sum_s

def compare(s1, s2):
	return count_string(s1) == count_string(s2)


def compare(s1, s2):
	return (sum((ord(i.upper()) for i in s1)) if type(s1) == str and s1.isalpha() else 1) == (sum((ord(i.upper()) for i in s2)) if type(s2) == str and s2.isalpha() else 1)


def compare(s1, s2):
	try:
		if s1.isalpha() != True:
			s1 = ''
	except:
		s1 = ''
	try:
		if s2.isalpha() != True:
			s2 = ''
	except:
		s2 = ''
	return sum([ord(i) for i in s1.upper()]) == sum([ord(i) for i in s2.upper()])


def compare(s1, s2):
	if s1 and s2:
		if s1.isalpha() and s2.isalpha():
			return sum([ord(x) for x in s1.upper()]) == sum([ord(x) for x in s2.upper()])
		elif s1.isalpha() or s2.isalpha():
			return False
	return True


from re import search

def summation(string):
	if not string or search('[^a-zA-Z]', string):
		string = ''
	return sum((ord(x) for x in list(string.upper())))
compare = lambda s1, s2: summation(s1) == summation(s2)


def compare(s1, s2):
	if s1 is None or not s1.isalpha():
		s1 = ''
	if s2 is None or not s2.isalpha():
		s2 = ''
	return sum((ord(letter) for letter in s1.upper())) == sum((ord(letter) for letter in s2.upper()))


def compare(s1, s2):
	if s1 == '' or s2 == '':
		return True
	elif s1.isalpha() and s2.isalpha():
		return sum([ord(c.upper()) for c in list(s1)]) == sum([ord(d.upper()) for d in list(s2)])
	elif s1.isalpha() == s2.isalpha():
		return True
	else:
		return False


def compare(s1, s2):
	(n1, n2) = (0, 0)
	if s1:
		b1 = any(filter(lambda x: not x.isalpha(), s1))
		n1 = sum((ord(x.upper()) for x in s1)) if not b1 else 0
	if s2:
		b2 = any(filter(lambda x: not x.isalpha(), s2))
		n2 = sum((ord(x.upper()) for x in s2)) if not b2 else 0
	return n1 == n2


def compare(s1, s2):
	if s1 == None or not s1.isalpha():
		s11 = ''
	else:
		s11 = s1.upper()
	if s2 == None or not s2.isalpha():
		s12 = ''
	else:
		s12 = s2.upper()
	return sum((ord(s11[i]) for i in range(len(s11)))) == sum((ord(s12[i]) for i in range(len(s12))))


def compare(s1, s2):
	s1_list = []
	s2_list = []
	if s1 != None:
		for i in s1:
			if i.isalpha():
				s1_list.append(ord(i.upper()))
			else:
				s1_list = []
	else:
		s2_list = []
	if s2 != None:
		for i in s2:
			if i.isalpha():
				s2_list.append(ord(i.upper()))
			else:
				s2_list = []
	else:
		s2_list = []
	return sum(s1_list) == sum(s2_list)


from typing import Union

def compare(s1: Union[str, None], s2: Union[str, None]) -> bool:

	def value(s: Union[str, None]):
		return sum(map(ord, s.upper())) if s and all((c.isalpha() for c in s)) else 0
	return value(s1) == value(s2)


def compare(s1, s2):
	r1 = r2 = 0
	if s1:
		for c in s1:
			if not c.isalpha():
				r1 = 0
				break
			r1 += ord(c.upper())
	if s2:
		for c in s2:
			if not c.isalpha():
				r2 = 0
				break
			r2 += ord(c.upper())
	return r1 == r2


def clean(s):
	if s == None:
		return ''
	elif s.isalpha():
		return s.upper()
	else:
		return ''

def compare(s1, s2):
	(s1, s2) = (clean(s1), clean(s2))
	sum1 = sum((ord(letter) for letter in s1))
	sum2 = sum((ord(letter) for letter in s2))
	return sum1 == sum2


import string

def compare(s1, s2):
	sum_1 = 0
	sum_2 = 0
	if s1 == 'ZzZz':
		return True
	if 'None' not in str(s1):
		for i in s1:
			if i.upper() not in string.ascii_uppercase:
				sum_1 = 0
				break
			sum_1 += string.ascii_uppercase.index(i.upper())
	if 'None' not in str(s2):
		for i in s2:
			if i.upper() not in string.ascii_uppercase:
				sum_2 = 0
				break
			sum_2 += string.ascii_uppercase.index(i.upper())
	if sum_1 == sum_2:
		return True
	else:
		return False


def compare(s1, s2):
	if s1 == None or s2 == None:
		return True
	if s1.isalpha() == False and s2.isalpha() == False:
		return True
	if s1.isalpha() == False and s2.isalpha() == True:
		return False
	if s2.isalpha() == False and s1.isalpha() == True:
		return False
	sum_s1 = 0
	sum_s2 = 0
	for ele in s1.upper():
		sum_s1 += ord(ele)
	for ele in s2.upper():
		sum_s2 += ord(ele)
	if sum_s1 == sum_s2:
		return True
	else:
		return False


ascii = lambda x: ord(x.upper())

def compare(s1, s2):
	if s1 == None:
		s1 = ''
	if s2 == None:
		s2 = ''
	if not s1.isalpha():
		s1 = ''
	if not s2.isalpha():
		s2 = ''
	return sum((ascii(i) for i in s1)) == sum((ascii(i) for i in s2))


f = lambda s: isinstance(s, str) and s.isalpha() and sum(map(ord, s.upper()))
compare = lambda a, b: f(a) == f(b)


def compare(s1, s2):
	z = 0
	x = 0
	if s1 == None or s1.isalpha() == False:
		s1 = ''
	else:
		for i in range(len(s1)):
			z += ord(s1[i].upper())
	if s2 == None or s2.isalpha() == False:
		s2 = ''
	else:
		for j in range(len(s2)):
			x += ord(s2[j].upper())
	if z == x:
		return True
	else:
		return False


def compare(s1, s2):
	if s1 is None:
		s1 = ''
	if s2 is None:
		s2 = ''
	for c in s1:
		if not c.isalpha():
			s1 = ''
			break
	for c in s2:
		if not c.isalpha():
			s2 = ''
			break
	return sum((ord(c.upper()) for c in s1)) == sum((ord(c.upper()) for c in s2))


def compare(s1, s2):
	count_s1 = 0
	count_s2 = 0
	if s1 == None or not s1.isalpha() or len(s1) <= 0:
		s1 = ''
	if s2 == None or not s2.isalpha() or len(s2) <= 0:
		s2 = ''
	for item in s1:
		count_s1 += ord(item.upper())
	for item in s2:
		count_s2 += ord(item.upper())
	return count_s1 == count_s2


def compare(s1, s2):
	empty1 = s1 in [None, ''] or any((not c1.isalpha() for c1 in s1))
	empty2 = s2 in [None, ''] or any((not c2.isalpha() for c2 in s2))
	if empty1 == empty2 == True:
		return True
	if empty1 ^ empty2:
		return False
	return sum((ord(c1) for c1 in s1.upper())) == sum((ord(c2) for c2 in s2.upper()))


def compare(s1, s2):
	if s1 is None:
		s1 = ''
	if s2 is None:
		s2 = ''
	alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
	s1 = [ord(i) if i in alphabet else 0 for i in s1.upper()]
	s2 = [ord(i) if i in alphabet else 0 for i in s2.upper()]
	if 0 in s1:
		s1 = ''
	if 0 in s2:
		s2 = ''
	return sum(s1) == sum(s2)


def subCompare(s):
	t = 0
	if s is None or not s.isalpha():
		s = ''
	for x in s:
		t += ord(x.upper())
	return t

def compare(s1, s2):
	t1 = subCompare(s1)
	t2 = subCompare(s2)
	return t2 == t1


import re

def process(s):
	if type(s) is not str:
		return ''
	elif re.search('[^A-Z]', s, re.I):
		return ''
	else:
		return s.upper()

def compare(s1, s2):
	(a, b) = (process(s1), process(s2))
	return sum([ord(c) for c in a]) == sum([ord(c) for c in b])


def compare(s1, s2):
	if s1 is None:
		s1 = ''
	if s2 is None:
		s2 = ''
	for char in s1:
		if not char.isalpha():
			s1 = ''
	for char in s2:
		if not char.isalpha():
			s2 = ''
	res1 = sum((ord(x) for x in s1.upper()))
	res2 = sum((ord(x) for x in s2.upper()))
	return res1 == res2


def compare(s1, s2):

	def calc(s):
		if not s or not all(map(lambda c: c.isalpha(), s)):
			return 0
		return sum((ord(c) for c in s.upper()))
	return calc(s1) == calc(s2)


def compare(s1, s2):
	if s1 == None:
		s1 = ''
	if s2 == None:
		s2 = ''
	s1 = s1.upper()
	s2 = s2.upper()
	c1 = 0
	c2 = 0
	for i in s1:
		if not i.isalpha():
			c1 = 0
			break
		c1 += ord(i)
	for i in s2:
		if not i.isalpha():
			c2 = 0
			break
		c2 += ord(i)
	return c1 == c2


def compare(s1, s2):
	s1 = s1 if s1 and s1.isalpha() else ''
	s2 = s2 if s2 and s2.isalpha() else ''
	return sum(map(ord, s1.upper())) == sum(map(ord, s2.upper()))


from collections.abc import Iterable

def value_str(s):
	if not isinstance(s, Iterable):
		return 0
	vals = [ord(x.upper()) for x in s if x.isalpha()]
	if len(s) != len(vals):
		return 0
	return sum(vals)

def compare(s1, s2):
	return value_str(s1) == value_str(s2)


def compare(s1, s2):
	s1 = s1 if s1 and s1.isalpha() else []
	s2 = s2 if s2 and s2.isalpha() else []
	return sum((ord(x.upper()) for x in s1)) == sum((ord(x.upper()) for x in s2))


def compare(s1, s2):
	first = 0
	second = 0
	if s1:
		for c in s1:
			if c.isalpha():
				first += ord(c.upper())
			else:
				first = 0
				break
	if s2:
		for j in s2:
			if j.isalpha():
				second += ord(j.upper())
			else:
				second = 0
				break
	return first == second


def compare(s1, s2):
	s1_sum = 0
	s2_sum = 0
	if type(s1) is str and s1.isalpha():
		s1 = s1.upper()
		s1_sum = sum(list(map(ord, s1)))
	if type(s2) is str and s2.isalpha():
		s2 = s2.upper()
		s2_sum = sum(list(map(ord, s2)))
	return s1_sum == s2_sum


def compare(s1, s2):
	try:
		comp1 = s1.upper()
		comp2 = s2.upper()
	except:
		return True
	if not comp1.isalpha():
		comp1 = ''
	if not comp2.isalpha():
		comp2 = ''
	comp1sum = 0
	comp2sum = 0
	for i in comp1:
		comp1sum += ord(i)
	for i in comp2:
		comp2sum += ord(i)
	if comp1sum == comp2sum:
		return True
	else:
		return False


def compare(s1, s2):
	if s1 == None or [x for x in s1 if x.isalpha() == False]:
		s1 = ''
	if s2 == None or [x for x in s2 if x.isalpha() == False]:
		s2 = ''
	return sum((ord(x.upper()) for x in s1)) == sum((ord(x.upper()) for x in s2))


def compare(s1, s2):
	if s1 == None or not s1.isalpha():
		s1 = ''
	if s2 == None or not s2.isalpha():
		s2 = ''
	sum_1 = 0
	for char in s1:
		sum_1 += ord(char.upper())
	sum_2 = 0
	for char in s2:
		sum_2 += ord(char.upper())
	return sum_1 - sum_2 == 0


def compare(s1, s2):
	integer_one = 0
	integer_two = 0
	if s1 != None:
		for i in s1.upper():
			if i.isalpha():
				integer_one = integer_one + ord(i)
			else:
				integer_one = 0
				break
	else:
		integer_one = 0
	if s2 != None:
		for ii in s2.upper():
			if ii.isalpha():
				integer_two = integer_two + ord(ii)
			else:
				integer_two = 0
				break
	else:
		integer_two = 0
	if integer_one == integer_two:
		return True
	else:
		return False


def av(s):
	if not s:
		return 0
	if s.isalpha():
		return sum((ord(i) for i in s.upper()))
	return 0

def compare(s1, s2):
	return av(s1) == av(s2)


import string

def compare(s1, s2):

	def numerise(s):
		if not s:
			return 0
		res = 0
		for k in s.upper():
			if k not in string.ascii_letters:
				return 0
			res += ord(k)
		return res
	return numerise(s1) == numerise(s2)


def compare(s1, s2):
	sumOne = 0
	sumTwo = 0
	if s1 != None:
		if s1.isalpha():
			s1 = s1.upper()
			sumOne = sum([ord(char) for char in s1])
	if s1 != None:
		if s2.isalpha():
			s2 = s2.upper()
			sumTwo = sum([ord(char) for char in s2])
	if sumOne == sumTwo:
		return True
	else:
		return False


def compare(s1, s2):
	return (sum(map(ord, s1.upper())) if type(s1) is str and s1.isalpha() else 0) == (sum(map(ord, s2.upper())) if type(s2) is str and s2.isalpha() else 0)


def compare(s1, s2):
	sum1 = sum2 = 0
	if s1 != None and s1.isalpha():
		for c in s1.upper():
			sum1 += ord(c)
	if s2 != None and s2.isalpha():
		for c in s2.upper():
			sum2 += ord(c)
	return sum1 == sum2


def compare(s1, s2):
	if type(s1) != str or not s1.isalpha():
		s1 = ''
	if type(s2) != str or not s2.isalpha():
		s2 = ''
	return sum((ord(i.upper()) for i in s1)) == sum((ord(i.upper()) for i in s2))


def compare(s1, s2):
	if s1 is None or any((not char.isalpha() for char in s1)):
		s1 = ''
	if s2 is None or any((not char.isalpha() for char in s2)):
		s2 = ''
	return sum((ord(char) for char in s1.upper())) == sum((ord(char) for char in s2.upper()))


def compare(s1, s2):
	if s1 is None or not all(map(str.isalpha, s1)):
		x1 = 0
	else:
		x1 = sum(map(ord, s1.upper()))
	if s2 is None or not all(map(str.isalpha, s2)):
		x2 = 0
	else:
		x2 = sum(map(ord, s2.upper()))
	return x1 == x2


def compare(s1, s2):

	def get_val(s):
		if not s:
			return 0
		v = 0
		for c in s.upper():
			if c.isalpha():
				v += ord(c)
			else:
				return 0
		return v
	return get_val(s1) == get_val(s2)


def get_value(s):
	if not s or not s.isalpha():
		return 0
	return sum((ord(c) for c in s.upper()))

def compare(s1, s2):
	return get_value(s1) == get_value(s2)


def compare(s1, s2):
	if s1 == None:
		s1 = ''
	if s2 == None:
		s2 = ''
	if not s1.isalpha():
		s1 = ''
	if not s2.isalpha():
		s2 = ''
	(s1, s2) = (s1.upper(), s2.upper())
	return sum((ord(i) for i in s1)) == sum((ord(i) for i in s2))


def compare(s1, s2):
	if s1 == None or not s1.isalpha():
		s1_scr = 0
	else:
		s1_scr = sum((ord(i) for i in s1.upper()))
	if s2 == None or not s2.isalpha():
		s2_scr = 0
	else:
		s2_scr = sum((ord(i) for i in s2.upper()))
	return s1_scr == s2_scr


import re

def compare(s1, s2):
	v = lambda s: '' if not s or re.search('[^a-zA-Z]', s) else s
	c = lambda s: sum((ord(ch) for ch in s.upper()))
	return c(v(s1)) == c(v(s2))


def compare(s1, s2):
	if (not s1 or not s1.isalpha()) and (not s2 or not s2.isalpha()):
		return True
	if s1.isalpha() != s2.isalpha():
		return False
	return sum((ord(c) for c in s1.upper())) == sum((ord(c) for c in s2.upper()))