Given a certain array of integers, create a function that may give the minimum number that may be divisible for all the numbers of the array.

```python
min_special_mult([2, 3 ,4 ,5, 6, 7]) == 420
```
The array may have integers that occurs more than once:
```python
min_special_mult([18, 22, 4, 3, 21, 6, 3]) == 2772
```
The array should have all its elements integer values. If the function finds an invalid entry (or invalid entries) like strings of the alphabet or symbols will not do the calculation and will compute and register them, outputting a message in singular or plural, depending on the number of invalid entries.

```python
min_special_mult([16, 15, 23, 'a', '&', '12']) == "There are 2 invalid entries: ['a', '&']"

min_special_mult([16, 15, 23, 'a', '&', '12', 'a']) == "There are 3 invalid entries: ['a', '&', 'a']"

min_special_mult([16, 15, 23, 'a', '12']) == "There is 1 invalid entry: a"
```
If the string is a valid number, the function will convert it as an integer.
```python
min_special_mult([16, 15, 23, '12']) == 5520

min_special_mult([16, 15, 23, '012']) == 5520
```
All the `None`/`nil` elements of the array will be ignored:
```python
min_special_mult([18, 22, 4, , None, 3, 21, 6, 3]) == 2772
```
If the array has a negative number, the function will convert to a positive one.
```python
min_special_mult([18, 22, 4, , None, 3, -21, 6, 3]) == 2772

min_special_mult([16, 15, 23, '-012']) == 5520
```

Enjoy it

Difficulty: introductory

Starter code:

def min_special_mult(arr):
	

Solutions:
from fractions import gcd
import re
from functools import reduce

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)


from functools import reduce
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 [_f for _f in arr if _f]:
        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)


from functools import reduce
from math import gcd

lcm = lambda x,y: x * y // gcd(x, y)

def min_special_mult(arr):
    try:
        return abs(reduce(lcm, map(int, filter(None, arr))))
    except ValueError:
        errors = [x for x in arr if type(x) != int and not (type(x) == str and x.isdigit())]
        if len(errors) == 1: return f"There is 1 invalid entry: {errors[0]}"
        return f"There are {len(errors)} invalid entries: {errors}"

from fractions import gcd

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

def min_special_mult(arr):
    valid, invalid = [], []
    for x in filter(None, arr):
        try:
            valid.append(abs(int(x)))
        except ValueError:
            invalid.append(x)
    if len(invalid) == 1:
        return 'There is 1 invalid entry: {}'.format(invalid[0])
    elif invalid:
        return 'There are {} invalid entries: {}'.format(len(invalid), invalid)
    return reduce(lcm, valid)

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)

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

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)

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

from functools import reduce
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.items()]
    return reduce(lambda a, b: a * b, factors)
    


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