将每个元素作为其索引的倍数或因子的数组的排列计数

有一个长度为n的数组nums，请计算并返回其中能够被nums[i]整除的元素在数组中的数量。

例如，如果输入数组为[2,4,5,8]，则2可以整除所有元素，4可以整除8，因此2的计数为4，4的计数为1，5和8的计数均为0，最终返回[4,1,0,0]。

一、暴力法

最简单，最直接的方法是对于每个元素，遍历整个数组一次，计算能够被其整除的元素的数量。

时间复杂度：O(n ^ 2)

def count_array(nums):
    n = len(nums)
    res = []
    for i in range(n):
        count = 0
        for j in range(n):
            if nums[j] % nums[i] == 0:
                count += 1
        res.append(count)
    return res

二、优化法

可以考虑一些优化的方法，提高算法效率。

1. 暴力法的优化

在上面的暴力法中，有很多重复的计算，可以通过缓存结果来避免重复计算。

时间复杂度：O(n ^ 2)，但减少了计算次数

def count_array(nums):
    n = len(nums)
    res = []

    # 先遍历一遍数组，计算出每个数能够整除的元素数量
    # 可以通过 hash table 实现，nums[i] 为键，计数为值
    counts = {}
    for i in range(n):
        if nums[i] in counts:
            continue
        count = 0
        for j in range(n):
            if nums[j] % nums[i] == 0:
                count += 1
        counts[nums[i]] = count
    
    # 再按照 counts 的结果构造 res
    for i in range(n):
        res.append(counts[nums[i]])

    return res 

2. 因子分解法

每个元素能够被整除的元素，其实都是该元素的因子。可以通过因子分解的方法，较快地计算出每个元素的因子，然后统计其在数组中出现的次数即可。

时间复杂度：O(n * sqrt(max(nums)))

def count_array(nums):
    n = len(nums)
    res = []

    # 先对每个元素进行因子分解，记录每个因子的出现次数
    factors = {}
    for num in nums:
        d = 2
        while num > 1:
            if num % d == 0:
                if d not in factors:
                    factors[d] = 0
                factors[d] += 1
                num //= d
            else:
                d += 1
    
    # 遍历每个元素的因子，计算能够整除的元素数量
    for num in nums:
        count = 1
        for factor in factors:
            fcount = 0
            while num % factor == 0:
                num //= factor
                fcount += 1
            count *= (factors[factor] + 1) ** fcount
        res.append(count)

    return res 

总结

在实际应用中，应当根据数据规模和算法复杂度的需求，选择不同的方法进行计算。对于一些需要高速处理大规模数据的情况，接近 O(n) 的算法复杂度将至关重要。