Arrays 在Ruby中如何将两个数组相乘？

例如，我有两个数组

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

我需要将它们相乘，然后创建第三个数组

c

，如下所示

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

哪种方法速度最好？我需要对大型阵列执行此操作，时间很重要

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

这是因为将两个数组合并为一个由两个元素数组组成的数组。i、 e:

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

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

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

您可以尝试以下方法：

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

---

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

因此，下面是将它们相乘的一种简单方法——它具有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]

a=[3,2,1]
b=[1,2,3]
num_cores=2#这决定了线程数，理想情况下等于核心数
ary_size=a.size
#我们需要将每个线程的结果收集为单独的子数组。
#我们将使用数组的结果数组，以便保留结果的顺序
结果=Array.new（num_cores，[]）
#将数组索引等分
索引分割=（0…元大小）。每个片（核数）
线程=[]
#在自己的线程中处理每个子数组
指数分割。每个指数都有指数do | ary，i |
螺纹[3,4,3]

试试这个：

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

---

@对不起，是同一个话题，谢谢。很高兴你找到了你想要的：）我重新开始了这个问题，因为OP没有寻找总数。欢迎来到StackOverflow。为了将来的参考，请看一看感谢大家，我将尝试使用多个线程，也许它真的会工作得更快。我的线程示例代码中可能有一个bug，我正在处理它。欢迎使用StackOverflow。为便于将来参考，请查看是否有办法避免未使用的

x

？。作为将来的参考，看看你的答案是否包含了一些信息性的文本，你就不必在上面加上很多句号了。只有代码的答案可能是正确的答案，但它永远不是一个好答案。