Create a __moreZeros__ function which will __receive a string__ for input, and __return an array__ (or null terminated string in C) containing only the characters from that string whose __binary representation of its ASCII value__ consists of _more zeros than ones_. 

You should __remove any duplicate characters__, keeping the __first occurence__ of any such duplicates, so they are in the __same order__ in the final array as they first appeared in the input string.

Examples

            
All input will be valid strings of length > 0. Leading zeros in binary should not be counted.

Difficulty: introductory

Starter code:

def more_zeros(s):
	

Solutions:
def more_zeros(s):
    results = []
    
    for letter in s:
        dec_repr = bin(ord(letter))[2:]
        if (dec_repr.count("0") > dec_repr.count("1")) and (letter not in results):
            results.append(letter)
    
    return results


def more_zeros(s):
    L=[]
    L1=[]
    L2=[]
    for i in s:
        a=int(' '.join(format(ord(x), 'b') for x in i))
        for j in str(a):
            if j=="0":
                L1.append(j)
            else:
                L2.append(j)
        if len(L1)>len(L2):
            if i not in L:
                L.append(str(i))
        L1=[]
        L2=[]
    return L

def more_zeros(s):
    return [v for i,v in enumerate(s) if bin(ord(v))[2:].count('0') > bin(ord(v))[2:].count('1') and v not in s[:i]]

def more_zeros(s):
    return list(dict.fromkeys(x for x, y in zip(s, map(bin, map(ord, s))) if y.count("0") << 1 > len(y)))

def more_zeros(stg):
    return sorted((c for c in set(stg) if f"{ord(c):b}".count("0") > 3), key=stg.index)


def more_zeros(s):

    al = []

    for char in s:
        bn = bin(ord(char))[2:]
        lbn = len(bn)
        
        if bn.count('0') > lbn/2 and char not in al:
            al.append(char)
    
    return al

def more_zeros(s):
    output = []
    for ch in s:
        bin_rep = f'{ord(ch):b}'
        if bin_rep.count('0') > bin_rep.count('1') and ch not in output:
            output.append(ch)
    return output

def more_zeros(s):
    lst0 = []
    lst1 = []
    lst_res = []
    stage = 0
    while stage != len(s):
        tmp = "{0:b}".format(ord(s[stage]))
        for x in tmp:
            if x == "1":
                lst1.append(x)
            else:
                lst0.append(x)
        if len(lst1) < len(lst0):
            if s[stage] in lst_res:
                stage = stage + 1
                lst1 = []
                lst0 = []
                pass
            else:
                lst_res.append(s[stage])
                stage = stage + 1
                lst1 = []
                lst0 = []
        else:
            stage = stage + 1
            lst1 = []
            lst0 = []
    return lst_res

def zero_dominant(c):
    s = format(ord(c), 'b')
    return s.count('0') > s.count('1')

def more_zeros(s):
    return list(dict.fromkeys(c for c in s if zero_dominant(c)))

more_zeros = lambda s: [x for x in {x:0 for x in s if bin(ord(x))[1:].count('0')>bin(ord(x))[1:].count('1')}]