Question

我正在做一个挑战，要求一个方法来乘以一个数组的两个最大元素，并找到一个不到一秒的解决方案。

这是我目前在~1.6秒时所拥有的

def max_product(a)
  a.sort[-1] * a.sort[-2]
end

如何重写这个以加快速度呢？

Answer 1

private void listView1_MouseClick(object sender, MouseEventArgs e)
{
    // Get the information of an item that is located in a given point (mouse location in this case).
    ListViewHitTestInfo hit = listView1.HitTest(e.Location);
    // hit.Item: Gets the ListViewItem.
    // hit.SubItem: Get the ListViewItem.ListViewSubItem

    if (listView1.SelectedItems.Count > 0)
    {
        MessageBox.Show("You clicked " + hit.SubItem.Text);
    }
    else
    {
        MessageBox.Show("Please select an item");
    }
}

Enumerable#max被允许在Ruby v.2.2中有一个参数。 a = [3,4,2,5,2,6] def max_product(a) a.max(2).reduce(:*) end max_product(a) #=> 30，min和max_by也是如此。

请注意，min_by将受益于即将推出的Ruby v2.4中的性能改进。

让我们将其与仅排序和获取最后两个值进行比较，并使用自己的滚动进行比较，如@ZbyszekKr所示。

Enumerable#max

首先让我们使用def max_product_sort(a) a.sort.last(2).inject(:*) end def max_product_sort!(a) a.sort! a[-2] * a[-1] end def max_product_rolled(arr) m1 = arr.max max_loc = arr.index(m1) arr[max_loc] = arr[0,2].min - 1 m2 = arr.max arr[max_loc] = m1 # to avoid mutating arr m1 * m2 end gem进行比较。

fruity

接下来使用require 'fruity' arr = 1_000_000.times.map { rand 2_000_000 } arr1 = arr.dup arr2 = arr.dup arr3 = arr.dup arr4 = arr.dup compare( max_2: -> { max_product(arr1) }, rolled: -> { max_product_rolled(arr2) }, sort: -> { max_product_sort(arr3) }, sort!: -> { max_product_sort!(arr4) } ) Running each test once. Test will take about 8 seconds. sort! is faster than max_2 by 4x ± 0.1 max_2 is faster than rolled by 2x ± 0.1 rolled is faster than sort by 2.1x ± 0.1进行比较。

benchmark

最后，让我们尝试arr = 1_000_000.times.map { rand 2_000_000 } arr1 = arr.dup arr2 = arr.dup arr3 = arr.dup arr4 = arr.dup require 'benchmark' Benchmark.bm do |x| x.report("max_2") { max_product(arr1) } x.report("rolled") { max_product_rolled(arr2) } x.report("sort") { max_product_sort(arr3) } x.report("sort!") { max_product_sort!(arr4) } end user system total real max_2 0.060000 0.010000 0.070000 ( 0.066777) rolled 0.110000 0.000000 0.110000 ( 0.111191) sort 0.210000 0.000000 0.210000 ( 0.218155) sort! 0.210000 0.010000 0.220000 ( 0.214664)进行热身。我们不能在此测试中包含benchmark，因为数组将在预热中进行排序，使得它在测试中超快。

sort !

如您所见，arr = 1_000_000.times.map { rand 2_000_000 } arr1 = arr.dup arr2 = arr.dup arr3 = arr.dup Benchmark.bmbm do |x| x.report("max_2") { max_product(arr1) } x.report("rolled") { max_product_rolled(arr2) } x.report("sort") { max_product_sort(arr3) } end Rehearsal ------------------------------------------ max_2 0.060000 0.000000 0.060000 ( 0.066969) rolled 0.110000 0.000000 0.110000 ( 0.117527) sort 0.210000 0.020000 0.230000 ( 0.244783) --------------------------------- total: 0.400000sec user system total real max_2 0.050000 0.000000 0.050000 ( 0.059948) rolled 0.100000 0.000000 0.100000 ( 0.106099) sort 0.200000 0.000000 0.200000 ( 0.219202)结果与使用benchmark获得的结果不同fruity，sort!中的最后一个benchmark中的fruity 。我想我知道为什么sort!在fruity看起来很好。 fruity的{{3}}状态，“我们首先确定获得有意义的时钟测量所需的内部迭代次数......”我怀疑，对于sort!，这个初始步骤会发生变异{ {1}}，扭曲了随后报告的测试结果。

对于它的价值，arr4结果符合我的预期（benchmark除了sort稍快一点。

如何快速乘以两个最大的数组元素

1 个答案: