结构成员中具有哈希的结构数组的最大值

Question

有没有其他方法可以迭代并将数据放入临时数组中，以获得该数据结构中id和最大值的对：

Results_struct = Struct.new(:comp_class, :usage, :competitors)
Competitor_struct = Struct.new(:name, :id, :user_id, :gear, :run,
                           :run_points, :strike, :strike_points,
                           :total)
advanced_comps = Results_struct.new(:advanced, true, [])
intermediate_comps = Results_struct.new(:intermediate, true, [])
comp_el1 = Competitor_struct.new('John D.', '1', '1', nil, [], nil, [], nil, [], nil, nil)
comp_el1.run << {:id => '10', :result => 50, :points => 0}
comp_el1.run << {:id => '11', :result => 100, :points => 0}
comp_el2 = Competitor_struct.new('Jake F.', '2', '2', nil, [], nil, [], nil, [], nil, nil)
comp_el2.run << {:id => '10', :result => 70, :points => 0}
comp_el2.run << {:id => '11', :result => 70, :points => 0}
advanced_comps.competitors << comp_el1
advanced_comps.competitors << comp_el2
# Some other actions

我想买

[{:id => '10', :result => 70}, {:id => '11', :result => 100}]

我看了map和select，但没有找到将其用于此目的的方法。

任何帮助都将不胜感激。

Answer 1

非常简单，您只需要循环每个竞争对手的每次跑步。

我的建议是在循环期间临时转换数据结构，以便于操作：一个散列，其中每个条目都是id，内容是结果。

result=advanced_comps.competitors.inject({}) do |elem,comp|
  comp.run.each do |run| 
     elem[run[:id]]=[elem[run[:id]].to_f,run[:result]].max
  end elem
end

所以结果会包含这样的东西：

=> {"10"=>70, "11"=>100.0}

然后，如果你只想回到你的初始结构：

result.map{|k,v|{:id=>k,:result=>v}}
=> [{:id=>"10", :result=>70}, {:id=>"11", :result=>100.0}]

Answer 2

我真的不理解你的问题，但我会尝试一下。

让我们首先定义一个Struct对象：

MyClass = Struct.new :id, :result
  #=> MyClass

我们有：

MyClass.class
  #=> Class
MyClass.instance_methods(false)
  #=> [:id, :id=, :result, :result=]
my_class = MyClass.new(1,2)
my_class.id
  #=> 1
my_class.result
  #=> 2
my_class.id = "cat"
  #=> "cat"
my_class.id
  #=> "cat"

到目前为止，我们所做的只是创建一个类，其中包含两个实例变量的访问器和一个简单的initialize方法，与完全相同

class MyClass
  attr_accessor :id, :result
  def initialize(id, result)
    @id = id
    @result = result
  end
end
MyClass.instance_methods(false)
  #=> [:id, :id=, :result, :result=]

在这一点上，我们可以忘记我们是如何创建这个类的。我们现在可以重新打开它并添加方法来改进它的功能。

让我们添加实例方法hash，从两个实例变量的值创建一个散列：

class MyClass
  def hash
    { :id => @id, :result => @result }
  end
end
MyClass.instance_methods(false)
  #=> [:id, :id=, :result, :result=, :hash]

另外，我们也可以在创建类MyClass时使用Struct:：new的形式来实现这一点，它采用一个块：

MyClass = Struct.new(:id, :result) do
   def hash
    { :id => @id, :result => @result }
  end
end
MyClass.instance_methods(false)
  #=> [:id, :id=, :result, :result=, :hash]

我们现在可以创建一个数组，其中包含与类MyClass:的实例相关联的哈希

a = [[MyClass.new('10', 100).hash, MyClass.new('20', 10).hash],
     [MyClass.new('10', 200).hash, MyClass.new('20',  5).hash]]
  #=> [[{:id=>"10", :result=>100}, {:id=>"20", :result=>10}],
  #    [{:id=>"10", :result=>200}, {:id=>"20", :result=>5}]]

我不明白你想要在数据结构中获得最大值是什么意思，但一旦你有了数组a，就可以很容易地提取你想要的任何内容。例如，您可以用通常的方式从这个数组中提取元素：

[a[1][0], a[0][1]]
  #=> [{:id=>"10", :result=>200}, {:id=>"20", :result=>10}]

类似地，如果对于a的每个元素，您想要密钥:result具有最大值的散列，则可以执行以下操作：

a.map { |b| b.max_by { |h| h[:result] } }
  #=> [{:id=>"10", :result=>100}, {:id=>"10", :result=>200}]

如果这不能回答你的问题，请告诉我。