Find the sum of the odd numbers within an array, after cubing the initial integers. The function should return `undefined`/`None`/`nil`/`NULL` if any of the values aren't numbers. 

~~~if:java,csharp
Note: There are ONLY integers in the JAVA and C# versions of this Kata.
~~~

~~~if:python
Note: Booleans should not be considered as numbers.
~~~

Difficulty: introductory

Starter code:

def cube_odd(arr):
	

Solutions:
def cube_odd(arr):
    return sum( n**3 for n in arr if n % 2 ) if all(type(n) == int for n in arr) else None

def cube_odd(arr):
    if any(type(x) is not int for x in arr):
        return None
    return sum(x ** 3 for x in arr if x % 2 != 0)

def cube_odd(arr):
    if len(set(map(type,arr))) < 2:
        return sum(n**3 for n in arr if n%2)

def cube_odd(arr):
    return sum(n**3 for n in arr if n % 2 == 1) if all(type(e) == int for e in arr) else None

def cube_odd(arr):
    s = 0
    for n in arr:
        if type(n) != int: break
        elif n%2: s += n**3
    else:
        return s

def cube_odd(arr):
    if any(type(x) is not int for x in arr):
        return None
    
    return sum(x**3 for x in arr if x % 2 == 1)

def cube_odd(a):
    return sum(e**3 for e in a if e % 2) if all(type(e) == int for e in a) else None

def cube_odd(arr):
    if arr == [x for x in arr if type(x) == int]: return sum([i**3 for i in arr if i % 2 == 1])


def cube_odd(arr):
    total = 0
    for el in arr:
        if isinstance(el, int):
            if el % 2 == 1 and el != 0:
                total += el ** 3
        else:
            return None
    if total == 2:
        return None
    return total

def cube_odd(arr):
    ar =  sum([ el **3 for el in arr if type(el) == int and el %2 !=0]) 
    return ar if [el for el in arr if type(el) != int]==[] else None

def cube_odd(arr):
    result = 0
    for n in arr:
        if type(n) == type("s") or type(n) == type(True):
            return None
        elif (n**3 % 2 != 0) and (type(n) == type(5)):
            result += n**3  
            
    return result
    
    #your code here - return None if at least a value is not an integer


def cube_odd(n): 
    return sum([el ** 3 for el in n if type(el) == int and el % 2 != 0]) if [el for el in n if type(el) != int] == [] else None



def cube_odd(arr):
    odds = []
    for num in arr:
        if type(num) != type(4):
            return None
        elif num % 2 != 0:
            odds.append(num**3)
    return sum(odds)

def cube_odd(arr):
    ar =  sum([ el **3 for el in arr if type(el) == int and el %2 !=0]) # remove str
    return ar if [el for el in arr if type(el) != int] == [] else None  # if str => None

def cube_odd(arr):
    #your code here - return None if at least a value is not an integer
    n = 0
    for i in arr:
        if type(i) != int:
            return None
            break
        else:
            if i%2 != 0 or (-1*i)%2 != 0:
                n += i**3
    return n

def cube_odd(arr):
    a=sum([el**3 for el in arr if type(el)==int and el%2!=0]) 
    return a if [el for el in arr if type(el)!=int]==[] else None

def cube_odd(arr):
    for el in arr:
        if type(el) != int:
            return None
    return sum([el ** 3 for el in arr if type(el) == int and el % 2 != 0])

def cube_odd(arr):
    if len([el for el in arr if type(el) != int]) > 0:
        return None
    return sum([el ** 3 for el in arr if el % 2 != 0 ])

def cube_odd(a):
    sum, i = 0, 0
    while True:
        try:
            if type(a[i]) != int:
                return None
            if a[i]&1:
                sum += a[i]**3
        except IndexError:
            break
        i += 1
    return sum           

def cube_odd(a):
    sum, i = 0, 0
    while True:
        try:
            if type(a[i]) != int:
                return None
            if a[i]%2:
                sum += a[i]**3
        except IndexError:
            break
        i += 1
    return sum           

def cube_odd(arr):
    cube = []
    for i in arr:
        if type(i) != int:
            return None
        if i % 2 != 0:
            cube.append(i**3)
    return sum(cube)


def cube_odd(arr):
    new_arr = []
    for el in arr:
        if type(el) != int:
            return None
        elif el %2 !=0 and  type(el) == int:
            new_arr.append(el**3) 
    return sum(new_arr)



def cube_odd(arr):

    s = 0
    
    if any(isinstance(b,bool) for b in arr):
        
        return None
    
    if not all(isinstance(x,int) for x in arr):
        
        return None

    for i in range(0,len(arr)):
    
        if arr[i]%2!=0 :
        
            s+= arr[i]**3
               
    return s
    


def cube_odd(arr):
    sum = 0
    for i in range(len(arr)):
        if type(arr[i]) != int:
            return None
        if arr[i] % 2 == 1:
            sum += arr[i]**3
    return sum

def cube_odd(arr):
    s = [el for el in arr if type(el) != int]
    return sum([el ** 3 for el in arr if type(el) == int and el % 2 != 0 ]) if len(s) == 0 else None 

def cube_odd(arr):
    x = 0
    for i in arr:
        if type(i) is not int:
            return None
        if i % 2 != 0:
            x += i*i*i
    return x

def cube_odd(a):
    total = 0
    try:
        for i in a:
            if str(i) is 'False' or str(i) is 'True': return None
            total += i**3 if i**3%2 != 0 else 0
        return total
    except:
        return None

def cube_odd(arr):
    for item in arr:
        if type(item) != int:
            return

    return sum(i**3 for i in arr if i % 2 != 0)

def cube_odd(arr):
    while all(type(d) == int for d in arr):
        return sum(d**3 for d in arr if (d**3)%2==1)


def cube_odd(arr):
    res = 0
    for i in arr:
        if type(i) != int:
            return None
        if i % 2:
            res += i ** 3
    return res

def cube_odd(arr):
    a = [i for i in arr if type(i) == int]
    return sum([i**3 for i in a if i % 2 == 1]) if len(a) == len(arr) else None

def cube_odd(arr):
    for i in arr:
        if type(i) != int:
            return None
    return sum([i**3 for i in arr if i % 2])

def cube_odd(arr):
    #your code here - return None if at least a value is not an integer
    o = 0
    for i in arr:
        if type(i)!=int:
            return None
        elif i%2==1:
            o+=i**3
        else:
            continue
    return o            

def cube_odd(arr):
    s = 0
    for x in arr:
        if type(x) != int:
            return None
        elif x**3 % 2 == 1:
            s += x**3
    return s


def cube_odd(arr):
    odd = list()
    for i in arr:
        if (isinstance(i, int) and
                not isinstance(i, bool)):
            if abs(i)%2 != 0:
                odd.append(i)
        else:
            return None
        
    return sum(map(lambda x: x**3, odd))

def cube_odd(arr):
    res = 0
    for n in arr:
        if type(n) != int:
            return None
        res += n**3 if n%2 else 0
    return res

def cube_odd(arr):
    a = 0
    for i in arr : 
        if type(i) != int: break
        elif i % 2 != 0 :
            a += i**3
        
    else : 
        return a
        
    #your code here - return None if at least a value is not an integer


def cube_odd(arr):
    for i in arr:
        if type(i)!=type(1):
            return None
    return sum(i**3 for i in arr if i%2==1)

def cube_odd(x):
    if len(x)!=len([i for i in x if type(i)==int]):
        return None
    else:
        return sum([i**3 for i in x if i%2!=0])

def cube_odd(arr):
    result = 0
    for el in arr:
        if type(el) != int:
            return None
        if el % 2 != 0:
            result += el*el*el
    return result 

def cube_odd(arr):
    c = []
    n = []
    for x in arr:
        if type(x) != int:
            return None
        elif x < 0 and x % 2 != 0:
            c.append(x**3)
        elif x > 0 and x % 2 :
            n.append(x**3)
    return sum(n) + sum(c)

def cube_odd(arr):
    
    sol = 0
    
    for i in arr:
        
        if type(i) != int:
            break
        
        elif i % 2:
            sol += i**3
    
    else:
        return sol

def cube_odd(arr):
    #your code here - return None if at least a value is not an integer
    s = 0
    for i in arr:
        if type(i)!=int:
            return None
        elif i%2==1:
            s+=i**3
        else:
            continue
    return s

def cube_odd(arr):
    l = []
    for x in arr:
        if type(x) != int:
            return None
        elif x % 2 == 1:
            l.append(x ** 3)
    return sum(l)

def cube_odd(arr):
    func = lambda x: isinstance(x, (int,float)) and not isinstance(x, bool)
    return (all(map(func,arr)) or None) and sum(x**3 for x in arr if x**3%2)

def cube_odd(arr):
    x = [i for i in arr if not isinstance(i,bool)]
    if len(x) == len(arr):
        try:
            return sum([i**3 for i in x if i % 2])
        except:
            pass

def cube_odd(arr):
    cubes = []
    for i in arr:
        if type(i)!=int:
            return None
        if i%2!=0:
            cubes.append(i**3)
    return sum(cubes)

def cube_odd(arr):
    int_arr = []
    for i in arr:
        if type(i) == int:
            int_arr.append(i)
        else:
            return None
    res = []
    for i in int_arr:
        if i % 2 != 0:
            res.append(i)
    res2 = []
    for i in res:
        res2.append(i*i*i)
    return sum(res2)

def cube_odd(arr):
    x = 0
    for i in arr:
        if type(i) is not int:
            return None
            break
        elif i % 2 != 0:
            x += i**3
    return x

def cube_odd(A):
    print(A)
    r = None
    for i in A:
        if not isinstance(i, int) or isinstance(i, bool): return None
        if i%2 : r = i**3 if not r else r+i**3
    return r

def cube_odd(arr):
    new_arr = []
    for i in range(len(arr)):
        if type(arr[i]) == bool:
            return None
        if type(arr[i]) == str:
            return None
        new_arr.append(arr[i] ** 3)
    value = 0
    for i in range(len(new_arr)):
        if new_arr[i] % 2 == 1:
            value += new_arr[i]
    return value


def cube_odd(arr):
    res = 0
    for i in arr:
        if not isinstance(i, int) or isinstance(i, bool):
            return None
        elif i%2!=0:
            res += i**3
    return res

def cube_odd(arr):
    all_int = all(type(n) == int for n in arr)
    return sum(n ** 3 for n in arr if n & 1) if all_int else None

def cube_odd(arr):
    res=0
    for i in arr:
        if isinstance(i,int) and not isinstance(i,bool):
            if (i**3)%2==1:
                res+=i**3
        else:
            return None
    return res

def cube_odd(arr):
    for x in arr :
        if type(x)!=int : return None
    return sum([x**3 for x in arr if x%2==1])

def cube_odd(arr):
    accumulator = 0
    for eachvalue in arr:
        if type(eachvalue) != type(1):
            return None
        else:
            if eachvalue % 2 != 0:
                x = eachvalue**3
                accumulator = accumulator + x
    return accumulator


def cube_odd(arr):
    res_arr = [x for x in arr if isinstance(x, int) and not isinstance(x, bool)]
    if len(res_arr) == len(arr):
        return sum([x**3 for x in arr if x % 2 != 0])
    else:
        return None

def cube_odd(arr):

    if any(str(char).isalpha() for char in arr) == True:
        return None

    return sum(char**3 for char in arr if char%2 != 0)

import unittest


def cube_odd(arr):
    def _is_none_condition():
        return any(True if not isinstance(ele, int)
                           or ele is True
                           or ele is False
                   else False for ele in arr)
    if _is_none_condition():
        return
    return sum(ele ** 3 if ele % 2 == 1 else 0 for ele in arr)


class TestCubeOdd(unittest.TestCase):
    def test_should_return_none_when_any_of_the_values_are_not_numbers(self):
        arr = ["a", 12, 9, "z", 42]
        actual = cube_odd(arr)
        self.assertEqual(actual, None)

    def test_cube_odd(self):
        arr = [1, 2, 3, 4]
        actual = cube_odd(arr)
        self.assertEqual(actual, 28)


def cube_odd(arr):
    s = 0
    for i in arr:
        if type(i) == bool or type(i) == str:
            return None
        else:
            if i%2==1:
                s += i**3
    return s

def cube_odd(arr):
    output = 0
    for i in arr:
        if type(i) == int:
            if i % 2 != 0:
                output += i**3
        else:
            return None
    return output

def cube_odd(arr):
    _arr = [n for n in arr if type(n) == int]
    if len(_arr) != len(arr):
        return None
    arr = [n ** 3 for n in arr if n % 2 != 0]
    return 0 if not arr else sum(arr)

def cube_odd(arr):
    if all(type(x) is int or type(x) is float for x in arr):
        return sum(x ** 3 for x in arr if x % 2)



def cube_odd(arr):
    cubes = []
    for item in arr:
        if str(item).strip('-').isdigit() == False:
            return None
        else:
            if item % 2 != 0:
                cubes.append(item**3)
    return sum(cubes)


def cube_odd(arr):
    if all(type(i) == int for i in arr): return sum((i**3) for i in arr if i%2 != 0)


def cube_odd(arr):
    if all(type(i) == int for i in arr): return sum((i**3) for i in arr if i%2 != 0)
    else: return None

def cube_odd(arr):
    return sum(x ** 3 for x in arr if (x % 2 == 1)) if all(type(x) is int for x in arr) else None

def cube_odd(arr):
    sum = 0
    for x in arr:
        if (not isinstance(x, (int, float, complex)) or isinstance(x, bool)): return None
        if (x % 2 == 1): sum += x ** 3
    return sum

def cube_odd(arr):
    if any(isinstance(v, bool) or not isinstance(v, int) for v in arr): return
    return sum(v**3 for v in arr if v % 2)


def cube_odd(arr):
    sum = 0
    for x in arr:
        if type(x) == int:
            if x % 2 == 1:
                sum += x**3
        else:
            return None
    return sum

def cube_odd(arr):
    return sum(n**3 for n in arr if n % 2 == 1) if all(type(x) == int for x in arr) else None

def cube_odd(arr):
    res=[]
    for i in arr:
        if not type(i)==int :
           return None
        if i%2:
           res.append(i**3)
    return sum(res)


def cube_odd(arr):
    for x in arr:
        if type(x) != int: return None
    return sum([x**3 for x in arr if x**3 % 2 != 0])

def cube_odd(arr):
    return sum(n ** 3 for n in arr if n % 2) if all(type(n) is int for n in arr) else None

def cube_odd(n):
    sum = 0
    for n in n:
        if type(n)!=int:
            return None
        if n%2 != 0:
            sum += n**3
    return sum
                


def cube_odd(arr):
    total=0
    for elem in arr:
        if type(elem) == int:
            if elem%2==1:
                total += elem**3
        else:
            return None
    return total

def cube_odd(arr):
    #your code here - return None if at least a value is not an integer
    for i in arr :
        if not isinstance(i, int) or isinstance(i, bool) : return None
    return sum(i**3 for i in arr if i%2!=0)

def cube_odd(arr):
    result = 0
    for i in arr:        
        if not isinstance(i, int) or isinstance(i, bool):
            return None
        result += i**3 if i & 1 else 0
    return result

def cube_odd(arr):
    cubed = []
    for i in arr:
        if type(i) != int:
            return None
        else:
            cubed.append(i ** 3)
    new_arr = []
    for x in cubed:
        if x % 2 != 0:
            new_arr.append(x)

    return sum(new_arr)


# def cube_odd(arr):
#     x = 0
#     for x in arr:
#         if x is not int:
#             return None
#         if x ** 3 == 1:
#             return True
#         elif x % 2 != 0:
#             return False
#     res = cube_odd(x)
#     print(res)

def cube_odd(arr):
    if any(type(x) is not int for x in arr):
        return None
    return sum(x ** 3 for x in arr if x % 2 != 0)
    

# def cube_odd(arr):
#     #your code here - return None if at least a value is not an integer
#     sum_num = ("undefined, None, nil, NULL")
#     sum_num = len()
#     if sum_num == int():
#         return sum_num
#     else:
#         pass
#     return arr(sum_num)
# def cube_odd(arr):
#       if any(type(x) is not int for x in arr):
#           return None
          
#       return sum(x ** 3 for x in arr if x % 2 != 0)


def cube_odd(arr):
    if set(map(type, arr)) != {int}:
        return None
    return sum([y for y in [x**3 for x in arr] if y % 2 == 1])

def cube_odd(arr):
    return sum(x ** 3 for x in arr if x % 2) if all(isinstance(x, int) and not isinstance(x, bool) for x in arr) else None


def cube_odd(arr):
    try:
        return sum(['x' if type(i) == bool else i**3 for i in arr if (i**3) % 2 != 0])
    except:
        return None

def cube_odd(arr):
    s = 0
    for i in arr:
        if type(i) is int:
            if i % 2 != 0:
                s += i ** 3
        else:
            return None
    return s
    


def cube_odd(arr):
    return sum(x ** 3 for x in arr if x % 2) if all(type(x) is int for x in arr) else None

def cube_odd(arr):
    if all(map(lambda x: type(x) is int, arr)):
        return sum(map(lambda x: x ** 3, filter(lambda x: x % 2, arr)))
    return None

def cube_odd(arr):
    sum = 0
    for i in arr:
        if type(i) in (int,):
            if i % 2:
                sum += i**3
        else:
            return None
    return sum


def cube_odd(arr):
    r = 0
    for x in arr:
        if type(x) is not int:
            return None
        elif x % 2:
            r += x ** 3
    return r
    # Flez


def cube_odd(arr):
    for x in arr:
        if type(x) is not int:
            return None
    
    cube = [x **3 for x in arr]
    r = 0
    for x in cube:
        if x % 2 != 0:
            r += x
    return r
    # Flez
  
      
    


def cube_odd(arr):
    return None if any([type(i) != int for i in arr]) else sum((i**3 for i in arr if i % 2 == 1))

def cube_odd(arr):
    x = []
    for i in arr:
        if type(i) != int:
            return None
        elif type(i) == int and i % 2 != 0:
            x.append(i**3)
    
    return sum(x)

def cube_odd(arr):
    for i in arr:
        if type(i) != int or type(i) == bool: return(None)
    return(sum(i**3 for i in arr if i%2))

cube_odd = lambda lst: None if not all(type(x) is int for x in lst) else sum(n ** 3 for n in lst if n & 1)

def cube_odd(arr):
    #your code here - return None if at least a value is not an integer
    try:
        sum = 0
        for i in range(len(arr)):
            if i >= len(arr):
                break
            else:
                a = (i)
                if str(arr[a]) in ["True","False"]:
                    return None
                elif arr[a]%2 == 1:
                    sum += (arr[a]**3)
        return sum
    except TypeError:
        return None

def cube_odd(arr):
    sum = 0
    for i in range(len(arr)):
        if type(arr[i])!= int:
            return None
        elif arr[i]%2!=0:
            sum += arr[i]**3
    return sum        
    #your code here - return None if at least a value is not an integer


def cube_odd(arr):
    r = 0
    for a in arr:
        if type(a) != int: return None
        if a % 2 != 0: r += a**3
    return r

def cube_odd(arr):
    if all(isinstance(x, int) for x in arr) \
       and not any(isinstance(x,bool) for x in arr):
        return sum([x ** 3 for x in arr if x % 2 ])
    else:
        return None

def cube_odd(arr):
    arr1 = []
    result = 0
    try:
        for i in arr:
            if type(i) == bool:
                return  None
            else:
                if i % 2 != 0:
                    result = i**3
                    arr1.append(result)
        return sum(arr1)  
    except TypeError:
        return None


def cube_odd(arr):
    arr_cubed =[]
    sum=0
    for element in arr:
    
        if not str(element).isdigit() and not str(element)[0]=='-':
            return None
        else:
            arr_cubed.append(element**3)
    for element in arr_cubed:
        if not element%2==0:
            sum +=element
    return sum
    #your code here - return None if at least a value is not an integer


def cube_odd(arr):
  s=0
  arr1=[]
  for i in arr:
    if (type(i)==str or type(i)==bool):
      return None
      break
    else:
      arr1.append(i)
  for i in range(len(arr1)):
    if (arr1[i]%2==1):
      s+=arr1[i]**3
  return s