# Do names have colors?

*Now they do.*

Make a function that takes in a name (Any string two chars or longer really, but the name is the idea) and use the ascii values of it's substrings to produce the hex value of its color! Here is how it's going to work:

* The first two hexadecimal digits are the *SUM* of the value of characters (modulo 256).
* The second two are the *PRODUCT* of all the characters (again, modulo 256, which is one more than `FF` in hexadecimal).
* The last two are the *ABSOLUTE VALUE of the DIFFERENCE* between the first letter, and the sum of every other letter. (I think you get the idea with the modulo thing).

For example `"Jack"` returns `"79CAE5"`, which is... **baby blue!**
```
"Jack"  #  "J" = 74, "a" = 97, "c" = 99, "k" = 107

74 + 97 + 99 + 107 = 377                   -->  mod 256 = 121  -->  hex: 79
74 * 97 * 99 * 107 = 76036554              -->  mod 256 = 202  -->  hex: CA
74 - (97 + 99 + 107) = -229  --> abs: 229  -->  mod 256 = 229  -->  hex: E5
```

NOTE: The function should return `None/nil` when the input is less than two chars.

Difficulty: introductory

Starter code:

def string_color(name):
	

Solutions:
from operator import sub, mul
from functools import reduce

def string_color(string):
    if len(string) < 2:
        return None
    r = sum(map(ord, list(string))) % 256
    g = reduce(mul, list(map(ord, list(string)))) % 256
    b = abs(reduce(sub, list(map(ord, list(string))))) % 256
    return '{:02X}{:02X}{:02X}'.format(r,g,b) 


from functools import reduce
from operator import mul


def string_color(name):
    if len(name) > 1:
        xs = list(map(ord, name))
        r = sum(xs) % 256
        g = reduce(mul, xs) % 256
        b = abs(xs[0] - sum(xs[1:])) % 256
        return f"{r:02X}{g:02X}{b:02X}"

def string_color(name):
    if len(name) < 2 :
        return None
    else:
        first = hex(sum(ord(char) for char in name) % 256)[-2:]
        second = 1
        for char in name:
            second = second * ord(char)
        second = hex(second % 256)[-2:]
        third = ord(name[0]) - sum(ord(char) for char in name[1:])
        third = hex(abs(third) % 256)[-2:]
        
        return (first + second + third).upper().replace("X", "0")

from operator import mul
from functools import reduce

def string_color(s):
    if len(s) > 1:
        a = [ord(x) for x in s]
        n = sum(a)
        return f"{n%256:02X}{reduce(mul, a) % 256:02X}{abs(a[0] * 2 - n) % 256:02X}"

def string_color(name):
    first_char = length = other_chars = sum_chars = 0
    prod_chars = 1
    for i, a in enumerate(name):
        current = ord(a)
        length += 1
        if i == 0:
            first_char = current
        else:
            other_chars += current
        prod_chars *= current
        sum_chars += current
    if length < 2:
        return None
    return '{:02X}{:02X}{:02X}'.format(
        sum_chars % 256, prod_chars % 256, abs(first_char - other_chars) % 256
    )


import operator as op
from functools import reduce
def string_color(name):
    if name == '': return None
    lst = [ord(i) for i in name]
    a = sum(lst)%256
    b = reduce(op.mul, lst)%256
    c = (abs(lst[0]-sum(lst[1:])))%256
    a, b, c = format(a, 'x').upper().zfill(2), format(b, 'x').upper().zfill(2), format(c, 'x').upper().zfill(2)
    return a + b + c if not a==b==c else None

def string_color(name):
    if len(name)< 2: return None
    ascii = [ord(el) for el in name]
    s1 = hex(sum(ascii) % 256)[2:].upper()
    s2 = 1
    for el in ascii:
        s2 *= el
    s2 = hex(s2 % 256)[2:].upper()
    s3 = hex(abs(ascii[0] - sum(ascii[1:])) % 256)[2:].upper()
    lst = [s1, s2, s3]
    lst = ['0'+el if len(el)<2 else el for el in lst]
    return ''.join(lst)