Question

我有两个数组，例如

a = [3, 2, 1]
b = [1, 2, 3]

我需要将它们相乘并创建第三个数组c，就像这样

c = [3 * 1, 2 * 2, 1 * 3]

哪种方法速度最快？我需要为大型阵列做这件事，时间很重要。

Answer 1

a.zip(b).map{|x, y| x * y}

这是有效的，因为zip将两个数组组合成一个包含两个元素数组的数组。即：

a = [3, 2, 1]
b = [1, 2, 3]
a.zip(b)
#=> [[3, 1], [2, 2], [1, 3]]

然后使用map将元素相乘。这是通过迭代每个两个元素数组并将一个元素与另一个元素相乘来实现的，其中map返回结果数组。

a.zip(b).map{|x, y| x * y}
#=> [3, 4, 3]

Answer 2

试试这个：

[[3,2,1],[1,2,3]].transpose.map {|a| a.inject(:*)}

Answer 3

你可以试试这个：

a.map.with_index{ |x, i| a[i]*b[i]}

Answer 4

由于你想要将两个数组相乘，我们必须假设它们具有相同的大小。

因此，下面是一种将它们相乘的简单方法 - 它具有O（n）时间复杂度。其他答案也同样好，你可以选择任何一个

a = [3, 2, 1]
b = [1, 2, 3]

a.size.times.collect { |i| a[i] * b[i] }
#=> [3, 4, 3]

如果时间真的很重要，那么，您可能想要使用多个线程。演示该概念的示例程序如下所示。您可以根据自己的特定需求进行构建。

a = [3, 2, 1]
b = [1, 2, 3]

num_cores = 2 # This decides number of threads, ideally equal to number of cores
ary_size = a.size

# We need to collect result of each thread as separate sub-array.
# We will use result array-of-array so that order of result is preserved
results = Array.new(num_cores, [])

# Divide the array indexes into equal parts    
index_splits = (0...ary_size).each_slice(num_cores)

threads = []

# Process each sub-array in a thread of its own
index_splits.each_with_index do |ary, i| 
    threads << Thread.new do
      results[i] = ary.collect {|j| a[j] * b[j] } 
    end
end
threads.each {|t| t.join} 

p results.flatten
#=> [3,4,3]

如何在Ruby中乘以两个数组？

4 个答案: