我有以下陣列：
a = [1, 1, 1, 1, 3]
b = [2, 3, 2, 3, 3]
c = [1, 1, 1, 1, 3]
我的目標是計算每列的額外重復次數。意思是在這種情況下 [1,2,1] 出現兩次，意味著 1 個重復，對于 [1,3,1] 也是如此，所以總共重復的數量是 2，一次是 [1,2,1]，一次是對于 [1,3,1]。我開發了以下 2 種解決方案，但老實說，我不知道哪一種性能最好，為什么：
解決方案1：
sum = 0
zip = a.zip(b, c)
zip.group_by { |e| e}
.select { |_, value| value.size > 1 }
.each_value { |value| sum = (value.size - 1) }
return sum
解決方案2：
zip = a.zip(b, c)
hash = Hash.new(0)
zip.each { |e| hash.store(e, hash[e] 1) }
hash.each{|e, _| hash[e] -= 1}
return hash.sum {|e, _| hash[e] }
提前致謝
uj5u.com熱心網友回復：
說明基準：
require 'benchmark'
v1 = [1, 1, 1, 1]
v2 = [2, 3, 2, 3]
v3 = [1, 1, 1, 1 ]
def sol_1(a,b,c)
sum = 0
zip = a.zip(b, c)
zip.group_by { |e| e}
.select { |_, value| value.size > 1 }
.each_value { |value| sum = (value.size - 1) }
return sum
end
def sol_2(a,b,c)
zip = a.zip(b, c)
hash = Hash.new(0)
zip.each { |e| hash.store(e, hash[e] 1) }
hash.each{|e, _| hash[e] -= 1}
return hash.sum {|e, _| hash[e] }
end
n=1_000
Benchmark.bmbm do |x|
x.report("sol_1"){n.times{sol_1(v1, v2, v3)} }
x.report("sol_2"){n.times{sol_2(v1, v2, v3)} }
end
結果是：
Rehearsal -----------------------------------------
sol_1 0.011076 0.000000 0.011076 ( 0.011091)
sol_2 0.012276 0.000000 0.012276 ( 0.012355)
-------------------------------- total: 0.023352sec
user system total real
sol_1 0.007206 0.000000 0.007206 ( 0.007212)
sol_2 0.011452 0.000000 0.011452 ( 0.011453)
uj5u.com熱心網友回復：
因此，只需閱讀它，這兩種解決方案的方法就非常相似。雖然我不是 100% 確定你的意思most performing，但我猜你的意思是兩種解決方案的計算復雜性 - 所以大輸入的計算成本。當有很多列時，解決方案中唯一需要花費時間的元素是迭代列陣列 - 相比之下，其他所有內容都將花費很少的時間。
因此，在第一個解決方案中，您要迭代 3 次 - 一次對列進行分組，第二次選擇具有重復項的列，然后第三次計算重復次數（但是在這里，在最壞的情況下，您迭代的陣列最多有N/2 個元素）。因此，您總共對列陣列進行了 2.5 次迭代。
在第二個解決方案中，您也迭代了 3 次。首先，在列陣列上計算它們出現的次數，然后在結果（在最壞的情況下具有相同數量的元素）從每個數字中減去一個，最后對數字求和 - 這給出了大約 3 次迭代.
因此，第一個解決方案的性能可能略高一些 - 但是在處理復雜性時，我們會查看忽略其前面數字的函式型別 - 在這種情況下，兩個解決方案都是線性的。此外，不同的方法在 ruby?? 中以不同的方式優化。因此，確定哪個性能更好的唯一希望是使用基準測驗 - 對（相同的）10000 列重復這些演算法 100 次，第一個解決方案需要 10.5 秒，第二個解決方案需要 18 秒。
uj5u.com熱心網友回復：
這是@steenslag 基準測驗的稍微（20％）更快的解決方案：
require 'matrix'
def sol_3(matrix)
Matrix.
columns(matrix).
to_a.
each_with_object({}) { |e, a|
digest = e.hash
a[digest] = a[digest].nil? ? 1 : a[digest] 1
}.sum { |_, v| v > 1 ? 1 : 0 }
end
user system total real
sol_1 0.006908 0.000008 0.006916 ( 0.006917)
sol_2 0.011866 0.000018 0.011884 ( 0.011902)
sol_3 0.005532 0.000008 0.005540 ( 0.005555)
完整腳本：https : //gist.github.com/jaredbeck/edc708df10fcc0267db80bf1c31c8298
轉載請註明出處，本文鏈接：https://www.uj5u.com/net/323498.html
上一篇：為什么我的合并排序實作很慢？