Ruby哈希：从排序的值中获取一组键_Ruby_Hash

Ruby哈希：从排序的值中获取一组键

ruby hash

Ruby哈希：从排序的值中获取一组键,ruby,hash,Ruby,Hash,大家好，我已经使自己成为一个相当复杂的（至少对我来说）结构。我有一个散列，看起来像（示例）：（注意：它是一个散列，因此尚未排序）现在我想要的是：有一个从深度=0开始的循环，所有状态的集合深度为0或更小，循环的下一次迭代，具有一组深度为1或更小的所有状态，等等有什么好办法可以得到这样的建筑如果我的问题不清楚，请告诉我。要求“设置” require 'set' depths_with_states = [] max_level = states_with_depths.max_by

大家好，我已经使自己成为一个相当复杂的（至少对我来说）结构。我有一个散列，看起来像（示例）：

（注意：它是一个散列，因此尚未排序）

现在我想要的是：有一个从深度=0开始的循环，所有状态的集合深度为0或更小，循环的下一次迭代，具有一组深度为1或更小的所有状态，等等

有什么好办法可以得到这样的建筑

如果我的问题不清楚，请告诉我。

要求“设置”
require 'set'

depths_with_states = []

max_level = states_with_depths.max_by{|e|e[1]}[1]

states_with_depths.map{ |state, level|
  (level..max_level).each{ |i|
    depths_with_states[i] ||= Set.new  # ...or just array
    depths_with_states[i] << state
  }
}

depths_with_states.each{ |states|
  # do whatever you want to do ;)
}

深度与状态=[]
max|u level=具有深度的状态。max|u由{e | e[1]}[1]
具有深度的状态。映射{状态，级别|
（级别..最大级别）。每个{124; i|
深度_与_状态[i]| |=Set.new#…或仅数组
具有状态[i]的深度需要“设置”
深度与状态=[]
max|u level=具有深度的状态。max|u由{e | e[1]}[1]
具有深度的状态。映射{状态，级别|
（级别..最大级别）。每个{124; i|
深度_与_状态[i]| |=Set.new#…或仅数组
深度与状态[i]您可以使用group\u by
值：
>> states_with_depths.group_by { |k,v| v }
 #=> {0=>[["S0", 0]], 1=>[["S1", 1]], 2=>[["S2", 2], ["S3", 2], ["S4", 2]], 3=>[["S5", 3]]}

这也可以缩短为：
states_with_depths.group_by(&:last)

要使用此功能，您可以执行以下操作：
states_with_depths.group_by(&:last).each do |depth, arrs| 
  puts "Values with depth #{depth}: #{arrs.map(&:first)}"                                                                                                                        
end

哪些产出：
Values with depth 0: ["S0"]
Values with depth 1: ["S1"]
Values with depth 2: ["S2", "S3", "S4"]
Values with depth 3: ["S5"]

您只需将group_by
与以下值一起使用即可：
>> states_with_depths.group_by { |k,v| v }
 #=> {0=>[["S0", 0]], 1=>[["S1", 1]], 2=>[["S2", 2], ["S3", 2], ["S4", 2]], 3=>[["S5", 3]]}

这也可以缩短为：
states_with_depths.group_by(&:last)

要使用此功能，您可以执行以下操作：
states_with_depths.group_by(&:last).each do |depth, arrs| 
  puts "Values with depth #{depth}: #{arrs.map(&:first)}"                                                                                                                        
end

哪些产出：
Values with depth 0: ["S0"]
Values with depth 1: ["S1"]
Values with depth 2: ["S2", "S3", "S4"]
Values with depth 3: ["S5"]

下面是一个适用于Ruby 1.8.7之前版本的变体（当添加了Enumerable#groupby
时）：
states_by_depth=Hash.new{h，depth{h[depth]=[]
用深度表示。每个{状态，深度{124;用深度表示{0=>[“S0”]，1=>[“S1”]，2=>[“S3”，“S4”，“S2”]，3=>[“S5”]}
min_depth=按_depth.keys.min表示的状态
max_depth=按深度.keys.max表示状态
最小深度至（最大深度）do深度|
下一步除非状态=状态乘以深度[深度]
放置“深度：#{Depth}”
州。每个{州}放置“.{州}”
结束
#=>深度：0
#=>…S0
#=>深度：1
#=>…S1
#=>深度：2
#=>…S3
#=>…S4
#=>…S2
#=>深度：3
#=>…S5
这里有一个适用于Ruby 1.8.7之前版本的变体（当添加了Enumerable#group_by
时）：
states_by_depth=Hash.new{h，depth{h[depth]=[]
用深度表示。每个{状态，深度{124;用深度表示{0=>[“S0”]，1=>[“S1”]，2=>[“S3”，“S4”，“S2”]，3=>[“S5”]}
min_depth=按_depth.keys.min表示的状态
max_depth=按深度.keys.max表示状态
最小深度至（最大深度）do深度|
下一步除非状态=状态乘以深度[深度]
放置“深度：#{Depth}”
州。每个{州}放置“.{州}”
结束
#=>深度：0
#=>…S0
#=>深度：1
#=>…S1
#=>深度：2
#=>…S3
#=>…S4
#=>…S2
#=>深度：3
#=>…S5
谢谢，我测试了它，效果很好！我坚持使用J-.-L的解决方案，因为它的结果更接近我需要的注意：我无法编辑您的评论，但在（&:first）}”之后有一个额外的“}”
是的，谢谢。我从{}重新编写了它
block do ado…end
one因为这里更容易阅读，然后忘记了一个大括号。顺便说一句：这个用深度表示u。group by（&:last）.map{d，arr | arr.map（&:first）}
还应该提供您需要的内容。：-）谢谢，我测试了它，效果很好！我坚持使用J-.-L的解决方案，因为它的结果更接近我需要的注意：我无法编辑您的评论，但在（&:first）}”之后有一个额外的“}”
是的，谢谢。我从{}重新编写了它
block do ado…end
one因为这里更容易阅读，然后忘记了一个大括号。顺便说一句：这个用深度表示u。group by（&:last）。map{d，arr | arr.map（&:first）}
也应该提供您需要的东西。-）代码中有一个错误：do（0..level）。每个{| i | | | |
导致深度(u states[i]具有深度为i+而非0的所有状态集..代码中有一个错误：执行（0..level）。每个{| i | | |
导致深度(u states[i]具有深度为i+而非0..i的所有状态集