Question

我有一个所有可能等级的参考哈希，如下所示：

hash = {
  bronze: 0,
  silver: 1,
  gold: 2,
  platinum: 3,
  diamond: 4
}

我得到一个给定的等级，以及一系列其他现有等级，我需要确定是否有邻居＆＃39;存在给定的等级。我试着举个例子：

given_rank = 'gold'  
existing_ranks =  ['silver', 'platinum']

这应该返回true - 银直接位于黄金之下，铂位于正上方 - 两个邻居都存在。

given_rank = 'gold'  
existing_ranks =  ['silver', 'diamond']

这应该返回false - 上方缺少铂金

这就是我现在所拥有的：

user_rank = hash[given_rank]
higher = hash.invert[user_rank + 1]
lower = hash.invert[user_rank - 1]

if existing_ranks.include?(higher) && existing_ranks.include?(lower)
  # do something
else
  # do another thing
end

有没有更有效/更有效/红宝石的方法来解决这个问题？

Answer 1

使用连续索引之间的平凡数学关系，您可以写：

n1, n2 = hash.values_at(*existing_ranks)
are_neighbors = (n1 - n2).abs == 2 && hash[given_rank] == (n1 + n2) / 2

Answer 2

一些建议：为你的队伍使用符号代替字符串。

hash = {
  bronze: 0,
  silver: 1,
  gold: 2,
  platinum: 3,
  diamond: 4
}
given_rank = :gold
existing_ranks =  [:silver, :platinum]

is_neighbor = existing_ranks.map{ |rank| (hash[rank] - hash[given_rank]).abs }.uniq == [1]

如果你的两个现有的所有人都是你给定等级的邻居，那么你现在有is_neighbor == true

Answer 3

def correct_ordering?(hash, existing_ranks, given_rank)
  hash.values_at(*existing_ranks).sort == [hash[given_rank]-1, hash[given_rank]+1]
end

existing_ranks = [:silver, :platinum]

correct_ordering?(hash, existing_ranks, :gold)    #=> true
correct_ordering?(hash, existing_ranks, :diamond) #=> false

Answer 4

如果在哈希中找不到密钥，则结果为nil。只需删除nil即可获得有效的邻居

hash = {
  bronze: 0,
  silver: 1,
  gold: 2,
  platinum: 3,
  diamond: 4
}

given_rank = 'gold'
existing_ranks =  ['silver', 'platinum']

ranks = hash.invert
r = hash[given_rank.to_sym]
# compact method deletes nil values:
p existing_ranks.map(&:to_sym) == [ranks[r-1], ranks[r+1]].compact # => true

确定邻居是否存在？

4 个答案: