import itertools
import operator

from digits import digits


def longitud(it):
    uns = map(lambda d: 1, it)
    l = sum(uns)
    return l

#
# 1. longitud
#

def nombre_digits(n):
    dig = digits(n)
    nombre = longitud(dig)
    return nombre

#
# 2. map (aplica), join (sintetiza)
#

def separa_cap(n):
    dig = digits(n)
    digstr = map(str, dig)
    s = '-'.join(digstr)
    return s

#
# 3
#

def separa(n):
    dig = digits(n)
    diglst = list(dig)
    diglst.reverse()
    digstr = map(str, diglst)
    s = '-'.join(digstr)
    return s

#
# 4. sum (sintetiza)
# 

def suma_digits(n):
    dig = digits(n)
    s = sum(dig)
    return s

#
# 5. tee (copia), max i min (sintetiza)
#

def digit_max_min(n):
    dig = digits(n)
    dig1, dig2 = itertools.tee(dig)
    x = max(dig1)
    m = min(dig2)
    return x, m

#
# 6. in (cerca)
#

def te_digit(n, d):
    dig = digits(n)
    return d in dig

#
# 7. filter (filtra), longitud
#

def compta_digit(n, d):
    dig = digits(n)
    digd = filter(lambda x: x == d, dig)
    nombre = longitud(digd)
    return nombre

#
# 8
#

def dos_digits_o_mes(n, d):
    dig = digits(n)
    digd = filter(lambda x: x == d, dig)
    digda = itertools.accumulate(digd)
    fins2 = itertools.takewhile(lambda x: x <=2, digda)
    nombre = longitud(fins2)
    return nombre == 2

#
# 9. enumerate (aplica), max (sintetiza)
#

def max_digit_pot(n):
    dig = digits(n)
    enudig = enumerate(dig)
    p, x = max(enudig, key=operator.itemgetter(1))
    return x, p

#
# 10. enumerate (aplica), max (sintetiza)
#

def min_digit_pot(n):
    dig = digits(n)
    enudig = enumerate(dig)
    p, m = min(enudig, key=operator.itemgetter(1))
    return m, p

#
# 11
#

def digit_pot(n, p):
    dig = digits(n)
    enudig = enumerate(dig)
    enud = itertools.dropwhile(lambda x: x[0] != p, enudig)
    p, d = next(enud)
    return d

#
# 12
#

def cap_i_cua(n):
    dig = digits(n)
    diglst1 = list(dig)
    diglst2 = diglst1[:]
    diglst1.reverse()
    return diglst1 == diglst2

#
# 14
#

def rep_pot(n):
    dig = digits(n)
    enudig = enumerate(dig)
    p0, d0 = next(enudig)
    enudig0 = filter(lambda x: x[1] != 0, enudig)
    dig0str = map(lambda x: '{}*10^{}'.format(x[1], x[0]), enudig0)
    dig0strlst = list(dig0str)
    dig0strlst.reverse()
    if d0 != 0:
        dig0strlst.append(str(d0))
    res = ' + '.join(dig0strlst)
    return res