设置具有相同的价值，但不同的密钥

Question

我在我的应用程序中的建设，我需要这样的哈希几个哈希参数：

{ 1 => [6,2,2], 2 => [7,4,5], (3..7) => [7,2,1] }

所以我想有钥匙3相同的值， 4，5，6和7.
当然上面的例子不起作用，因为Ruby是智能的，并设置散列键为给定：它将范围设置为键:)所以我只能访问我的价值为my_hash[(3..7)]和my_hash[3]，my_hash[4]等没有。
当然，我可以在哈希之外进行检查或构建来完成我所需要的操作，但是我很好奇，如果可以在不使用哈希声明之外的任何循环的情况下设置像这样的哈希？如果不是，最优雅的是什么？谢谢！

Answer 1

这有什么特别的错吗？

myhash = { 1 => [6,2,2], 2 => [7,4,5] } 
(3..7).each { |k| myhash[k] = [7,2,1] } 

Answer 2

我不认为有一种方法，使用文字哈希语法设置多个按键，或没有一些反复，但这里有反复做短的路：

irb(main):007:0> h = { 1 => [6,2,2], 2 => [7,4,5] }; (3..7).each {|n| h[n] = [7,2,1]}; h 
=> {1=>[6, 2, 2], 2=>[7, 4, 5], 3=>[7, 2, 1], 4=>[7, 2, 1], 5=>[7, 2, 1], 6=>[7, 2, 1], 7=>[7, 2, 1]} 

（注意尾随; h只是上面显示的目的）

Answer 3

你可以继承Hash，使其更容易构建这样的哈希值：

class RangedHash < Hash 
    def []=(key, val) 
    if key.is_a? Range 
     key.each do |k| 
     super k, val 
     end 
    else 
     super key, val 
    end 
    end 
end 

它与常规散列相同，除非使用Range键时，它会在Range中的每个点处设置给定值。

irb(main):014:0> h = RangedHash.new 
=> {} 
irb(main):015:0> h[(1..5)] = 42 
=> 42 
irb(main):016:0> h[1] 
=> 42 
irb(main):017:0> h[5] 
=> 42 
irb(main):018:0> h['hello'] = 24 
=> 24 
irb(main):019:0> h['hello'] 
=> 24 

Answer 4

直接修补哈希，但在其他方面相同的思路Luke's...

class Hash 
    alias_method :orig_assign, '[]=' 
    def []= k, v 
    if k.is_a? Range 
     k.each { |i| orig_assign i, v } 
     v 
    else 
     orig_assign k, v 
    end 
    end 
end 

t = {} 
t[:what] = :ever 
t[3..7] = 123 
p t # => {5=>123, 6=>123, 7=>123, 3=>123, 4=>123, :what=>:ever} 

Answer 5

下面是一些方法：

h = { 1 => [6,2,2], 2 => [7,4,5], (3..7) => [7,2,1] } 

def my_hash(h,y) 
    h.keys.each do |x| 
    if (x.instance_of? Range) and (x.include? y) then 
     return p h[x] 
    end 
    end 
p h[y] 
end 

my_hash(h,2) 
my_hash(h,3) 
my_hash(h,1) 
my_hash(h,10) 
my_hash(h,5) 
my_hash(h,(3..7)) 

输出：

[7, 4, 5] 
[7, 2, 1] 
[6, 2, 2] 
nil 
[7, 2, 1] 
[7, 2, 1] 

Answer 6

我不喜欢为范围内的每个可能条目创建单独的键/值对。它根本无法扩展，特别是对于广泛的范围。考虑这个小范围：

'a' .. 'zz' 

这将导致702个额外的键。尝试('a'..'zz').to_a的乐趣。前进。我会等。

而不是创建密钥，拦截查找。重用RangedHash类名称：

class RangedHash < Hash 
    def [](key) 
    return self.fetch(key) if self.key? key 

    self.keys.select{ |k| k.is_a? Range }.each do |r_k| 
     return self.fetch(r_k) if r_k === key 
    end 

    nil 
    end 
end 

foo = RangedHash.new 
foo[1] = [6,2,2] 
foo[2] = [7,4,5] 
foo[3..7] = [7,2,1] 

此时foo样子：用于测试的方法

{1=>[6, 2, 2], 2=>[7, 4, 5], 3..7=>[7, 2, 1]} 

：

require 'pp' 
3.upto(7) do |i| 
    pp foo[i] 
end 

，输出：

[7, 2, 1] 
[7, 2, 1] 
[7, 2, 1] 
[7, 2, 1] 
[7, 2, 1] 

对于任何价值i在一个范围内，输出与该范围相关的值。超出范围但仍在散列中定义的值正常工作，对散列中不存在的键返回nil也是如此。而且，它保持尽可能小的散列。

这个问题或任何问题的解决方案的缺点是范围可能重叠导致冲突的关键。在大多数提议的解决方案中，键会彼此跺脚，这可能最终会返回错误的值。这种方法不会这样做，因为它会直接冲突来覆盖范围键。

要解决这个问题，需要确定是否允许重叠，如果是，是否可以返回找到的第一个，或者是否存在确定“最佳拟合”的逻辑，即最小范围完全适合或者其他一些标准。或者，如果价值相同，应该重叠加入一个更大的范围？这是一个蠕虫的罐头。