Python练习题答案: 找到数组I整数可分的最小数量【难度：2级】--景越Python编程实例训练营,1000道上机题等你来挑战

找到数组I整数可分的最小数量【难度:2级】:

答案1:

from fractions import gcd
import re

def min_special_mult(arr):
    l = [e for e in arr if not re.match('(None)|([+-]?\d+)', str(e))]
    if len(l) == 1:
        return 'There is 1 invalid entry: {}'.format(l[0])
    if len(l) > 1:
        return 'There are {} invalid entries: {}'.format(len(l), l)
    
    return reduce(lambda s, e: s * int(e) / gcd(s, int(e)) if e else s, arr, 1)
​

答案2:

gcd = lambda a, b: a if not b else gcd(b, a%b)
lcm = lambda a, b: a * b / gcd(a, b)

def min_special_mult(arr):
    errors = []
    xs = set()
    for x in filter(None, arr):
        try: xs.add(int(x))
        except: errors.append(x)
    if not errors: return reduce(lcm, xs)
    if not errors[1:]: return "There is 1 invalid entry: %s" % errors[0]
    return "There are %d invalid entries: %s" % (len(errors), errors)
        ​

答案3:

def gcd(a,b):
    while b > 0: a, b = b, a % b
    return a
    
def lcm(a, b):
    return a * b / gcd(a, b)

def min_special_mult(arr):
    try:
        return reduce(lcm, map(abs, map(int, filter(None, arr))))
    
    except:
        invalid = [i for i in arr if type(i) == str and not i.isdigit()]
        
        if len(invalid) == 1:
            return "There is 1 invalid entry: %s" % invalid[0]
        
        return "There are %s invalid entries: %s" % (len(invalid), invalid)​

答案4:

from fractions import gcd
from functools import reduce
import math
def min_special_mult(arr):
    a = filter(lambda x:type(x)!=int, [i for i in arr if not str(i).lstrip("-").isdigit() and i!=None])
    arr = [int(i) for i in arr if str(i).lstrip("-").isdigit()]
    if a:
        return "There {} {} invalid entr{}: {}".format("are" if len(a)>1 else "is",len(a),"ies" if len(a)>1 else "y",a if len(a)>1 else a[0])
    return abs(reduce((lambda x,y : x*y/gcd(x,y)),arr))​

答案5:

from fractions import gcd

def min_special_mult(arr):
    def is_int(n):
        try:
            int(n)
            return True
        except:
            return False
    orig_arr = [x for x in arr if x]
    arr = [int(x) for x in orig_arr if is_int(x)]
    if len(orig_arr) - len(arr) > 0:
        freaks = [x for x in orig_arr if not is_int(x)]
        if len(freaks) > 1:
            return "There are {} invalid entries: {}".format(len(freaks), freaks)
        return "There is 1 invalid entry: {}".format(freaks[0])
    
    arr = [abs(x) for x in arr]
    return reduce(lambda x, y: x * y // gcd(x, y), arr)​

答案6:

def gcd(a,b):
    while b:
        a,b = b,a%b
    return a

def lcd(a,b):
    return a*b/gcd(a,b)

def checkstring(arr):
    strlist = []
    for elem in arr:
        if type(elem) == str:
            strlist.append(elem)
    return strlist

def converttoint(arr):
    intarray = []
    for elem in arr:
        if elem is None: pass
        else:
            try:
                intarray.append(int(elem))
            except:
                intarray.append(elem)
    return intarray
    
def min_special_mult(arr):
    arr = converttoint(arr)
    if len(checkstring(arr)) == 1: 
        return 'There is 1 invalid entry: ' + str(checkstring(arr)[0])
    elif len(checkstring(arr)) > 1: 
        return 'There are ' + str(len(checkstring(arr))) + ' invalid entries: ' + str(checkstring(arr))
    current = 1
    for elem in arr:
        current = lcd(current,elem)
    return current​

答案7:

primes = [2, 3, 5, 7, 11, 13, 17]

def gen_primes():
    for p in primes:
        yield p

    next_prime = primes[-1]
    limit = int(next_prime ** 0.5) + 1
    while True:
        next_prime += 2
        if limit * limit < next_prime:
            limit += 2
        for p in primes:
            if next_prime % p == 0:
                break
            if p > limit:
                primes.append(next_prime)
                yield next_prime
                break

def gen_prime_factor_multiplicities(n):
    for p in gen_primes():
        count = 0
        while n % p == 0:
            count += 1
            n /= p
        if count > 0:
            yield (p, count)
        if n == 1:
            break

def min_special_mult(arr):
    bad = []
    good = []
    for a in arr:
        try:
            if a is not None:
                good.append(int(a))
        except:
            bad.append(a)
    if bad:
        if len(bad) == 1:
            return "There is 1 invalid entry: {}".format(bad[0])
        return "There are {} invalid entries: {}".format(len(bad), bad)

    maxes = {}
    for n in good:
        for p, m in gen_prime_factor_multiplicities(abs(n)):
            maxes[p] = max(maxes.get(p, m), m)
    factors = [p ** m for p, m in maxes.iteritems()]
    return reduce(lambda a, b: a * b, factors)
    
    ​

答案8:

def min_special_mult(arr):  #just simple "straight forward"...
    narr=[]; l=[]; c=0 
    for a in arr:
       if a==None: continue
       if isinstance(a,int): narr.append(a)
       else:
          try:
             if int(a)==a: narr.append(a); continue
          except:
             l.append(a); c+=1 
    if c==1: return "There is 1 invalid entry: "+l[0]
    if c>0: return "There are "+str(c)+" invalid entries: "+str(l)
    narr.sort(); n=narr[-1]; n1=n
    while True:
       f=0
       for a in reversed(narr):
          if n%a!=0: f=1; break
       if f==0: return n
       n+=n1​

答案9:

from fractions import gcd

def lcm(x, y):
    return x // gcd(x, y) * y

def min_special_mult(arr):
    xs = []
    invalid_entries = []
    for y in arr:
        if y is None:
            continue
        if isinstance(y, basestring):
            try:
                y = int(y)
            except ValueError:
                pass
        if not isinstance(y, (int, long)):
            invalid_entries.append(y)
            continue
        xs.append(abs(y))
    if invalid_entries:
        if len(invalid_entries) == 1:
            return 'There is 1 invalid entry: {}'.format(invalid_entries[0])
        else:
            return 'There are {} invalid entries: {}'.format(
                len(invalid_entries), invalid_entries)
    return reduce(lcm, xs)​

答案10:

gcd=lambda a,b: a if b==0 else gcd(b,a%b); min_special_mult=lambda arr: (lambda rarr: reduce(lambda a,b: a*b/gcd(a,b), rarr) if len([x for x in arr if x!=None])==len(rarr) else (lambda err: "There is 1 invalid entry: %s" %err[0] if len(err)==1 else "There are %s invalid entries: [%s]" %(len(err), ", ".join([repr(x) for x in err])))([x for x in arr if type(x)==str and any(l not in "-0123456789" for l in x)]))([abs(int(x)) for x in arr if x!=None and (type(x)==int or all(l in "-0123456789" for l in x))])​