Question

我有这个哈希：

HASH = {
  'x' => { :amount => 0 },
  'c' => { :amount => 5 },
  'q' => { :amount => 10 },
  'y' => { :amount => 20 },
  'n' => { :amount => 50 }    
}

如何从散列中获取下一个最高amount的密钥？

例如，如果我提供x，则应返回c。如果没有更高的金额，则应返回金额最低的密钥。这意味着当我提供n时，会返回x。

有人可以帮忙吗？

Answer 1

我使用这样的东西：

def next_higher(key)
  amount = HASH[key][:amount]
  sorted = HASH.sort_by { |_, v| v[:amount] }
  sorted.find(sorted.method(:first)) { |_, v| v[:amount] > amount }.first
end

next_higher "x" #=> "c"
next_higher "n" #=> "x"

Answer 2

我做这样的事情：

def find_next_by_amount(hash, key)
  sorted = hash.sort_by { |_, v| v[:amount] }
  index_of_next = sorted.index { |k, _| k == key }.next
  sorted.fetch(index_of_next, sorted.first).first
end

find_next_by_amount(HASH, 'x')
# => "c"

find_next_by_amount(HASH, 'n')
# => "x"

Answer 3

类似的东西：

def next(key)
  amount = HASH[key][:amount]
  kv_pairs = HASH.select{ |k, v| v[:amount] > amount }
  result = kv_pairs.empty? ? HASH.first.first : kv_pairs.min_by{ |k, v| v}.first      
end

我好奇，你为什么要这样的东西？也许对底层任务有更好的解决方案。

编辑：意识到哈希不必按数量排序，适用于未分类哈希的代码。

Answer 4

一种方式：

A = HASH.sort_by { |_,h| h[:amount] }.map(&:first)
  #=> ['x', 'c', 'q', 'y', 'n']

（如果HASH的密钥已经按正确顺序排列，那么这只是A = HASH.keys。）

def next_one(x)
  A[(A.index(x)+1)%A.size]
end

next_one 'x' #=> 'c'
next_one 'q' #=> 'y'
next_one 'n' #=> 'x'

或者，您可以创建哈希而不是方法：

e = A.cycle
  #=> #<Enumerator: ["x", "c", "q", "y", "n"]:cycle> 
g = A.size.times.with_object({}) { |_,g| g.update(e.next=>e.peek) }
  #=> {"x"=>"c", "c"=>"q", "q"=>"y", "y"=>"n", "n"=>"x"}

如何从哈希中获取下一个哈希元素？

4 个答案: