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: introductory

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 compare(s1, s2):
    v1, v2 = (sum(ord(c) for c in s.upper()) if s and s.isalpha() else 0 for s in (s1, s2))
    return v1 == v2

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):
    y = lambda s: sum(ord(c.upper()) for c in s) if s and s.isalpha() else 0
    return y(s1) == y(s2)

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 count_value(s):
    return sum([ord(c) for c in s.upper()]) if s and s.isalpha() else 0

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

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
    
# check for empty conditions
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 == None or not s1.isalpha():
        s1 = ''
    if s2 == None or not s2.isalpha():
        s2 = ''
    return sum([ord(s.upper()) for s in s1]) == sum([ord(s.upper()) for s in s2])

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): ###i
    v1, v2 = (sum(ord(c) for c in s.upper()) if s and s.isalpha() else 0 for s in (s1, s2))
    return v1 == v2

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):
    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(x) for x in s2.upper()])


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(r"[a-zA-Z]", s1) and re.search(r"[a-zA-Z]", s2):
        return sum(ord(i) for i in str(s1.upper()) if re.search(r"[a-zA-Z]", i)) == sum(ord(i) for i in str(s2.upper()) if re.search(r"[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()))

# 2020/07/04 [yetanotherjohndoe]

from re import match

def compare(s1,s2):
    
    def _ascii(_input):
        try:
            _input = str(_input).upper() if match(r'''^[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):
    #your code here
    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):
    
    if s1 is None or s1.isalpha() is False:
        s1 = ""
    if s2 is None or s2.isalpha() is False:
        s2 = ""
    
    return True if sum([ord(x) for x in s1.upper()]) == sum([ord(x) for x in s2.upper()]) else False

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(r'[^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):

    # проверка на None
    if s1 is None:
        s1 = ''
    if s2 is None:
        s2 = ''

    # проверка на isalpha()
    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):
    #your code here
    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(): #equal-ing to true isnt necessary
              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):
    if s1== None or not s1.isalpha(): s1=""
    if s2== None or not s2.isalpha(): s2=""
    return sum(ord(x.upper()) for x in s1) == sum(ord(x.upper()) for x in s2)

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):
    if not s1 or not all(map(str.isalpha, s1)):
        s1 = ''       
    if not s2 or not all(map(str.isalpha, s2)):
        s2 = ''
    return sum(map(ord, s1.upper())) == sum(map(ord, s2.upper()))

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() )