Addition of hash(Ruby)[finish]

枫起

标题

添加一个哈希相加的方法。（Ruby）

---

描述

如题所见，提个醒，是要增加方法，不要实例操作……

---

要求

提供异常报告解决方案，对于相同的key就取自身的。

---

参考答案

游客，如果您要查看本帖隐藏内容请回复

---

display line

fux2

1. class Hash
   
2.   def +(exhash)
   
3.     return unless exhash.is_a?(Hash)
   
4.     shash = self.dup
   
5.     exhash.each_key {|k| shash[k]||=exhash[k]}
   
6.     shash
   
7.   end
   
8. end

复制代码

忧雪の伤

fux2 发表于 2011-7-30 22:11

提供异常报告解决方案

=> false

对于相同的key就取自身的

=> false
other : 那个，直接赋值岂不是指针相同。

px.凤翔九天

1. h1,h2={1=>2,3=>4},{5=>6,7=>8}
   
2. def hash_add(hash1,hash2)
   
3.   unless hash1.is_a?(Hash) and hash2.is_a?(Hash)
   
4.     return "这货不是Hash，拉出去处理了！"
   
5.   end
   
6.   hash3={}
   
7.   hash1.each{|key,value| key_add,value_add=key,value
   
8.   hash2.each{|key2,value2|
   
9.   key_add+=key2 unless key2==key
   
10.   value_add+=value2 unless value2==value
    
11.   }
    
12.   hash3[key_add]=value_add}
    
13.   return hash3
    
14. end
    
15. p hash_add(h1,h2)

复制代码

貌似

提供异常报告解决方案

贯彻不够......不过结果应该对吧.....
P.S. 对于没有定义在Hash中表示悔改......

0.0这个加法吗....................囧，彻底理解错了嗷..............

fux2

忧雪の伤 发表于 2011-7-30 22:14
=> false

=> false

你没试过就知道:对于相同的key就取自身的 == false?

枫起

最初的思路是：先将hash表B进行迭代，然后输入到A里面，最后判断A里面是否有相同的，如果有就删除重复的。
但是后来发现不知道怎么输入到A里面。。。接着查镐头书的时候查到了“merge!”方法。它简直就是为这个问题量身打造的，merge!的定义：合并A与B两个数组，最后删除重复的。

有点不服气的感觉啊。。。毕竟是直接查到了方法- -

另外因为小LOLI不让给实例。。。所以就拿a = hash.new意思了一下。。。本来是有非常有趣的hash表的。。。TAT

我有此次事件知道了。。。必须多写代码。。。多熟悉方法啊。。。这玩意不懂方法没法做啊。。。

1. 
   
2. a = {}
   
3. b = {}
   
4. a['q'] = 1
   
5. a['w'] = 2
   
6. b['e'] = 3
   
7. b['q'] = 1
   
8. begin
   
9.   a.merge!(b)
   
10.   print a
    
11. rescue TypeError
    
12.   print "Error for hash type"
    
13. end
    

复制代码

写过了版本。。。真心表示很蛋疼。。。很纠结。。。
最后在月妹妹的帮助下。。。帮我在我的错误版本的基础上修改了下。。。虽然不能算是自己做的。。。但是也算是长知识了。。。

1. 
   
2. a = {'q'=>1,'w'=>2,'e'=>3}
   
3. b = {'w'=>2,'r'=>4,'t'=>5}
   
4. c = {}
   
5. class Hash
   
6.   def hashadd(h1,h2)
   
7.     raise TypeError  unless h1.is_a?(Hash) and h2.is_a?(Hash)
   
8.     h = {}
   
9.     h1.each {
   
10.         | key,value |
    
11.         h[key] = value unless h.has_key?(key)
    
12.     }
    
13.     h2.each {
    
14.         | key,value |
    
15.         h[key] = value unless h.has_key?(key)
    
16.     }
    
17.     return h
    
18.    end
    
19.   end
    
20. c = c.hashadd(a,b)
    
21. p c
    

复制代码

DeathKing

之前的方法跟fux给撞上了……所以换了种，不过慢了许多~

1. class Hash
   
2.         def hplus( hash )
   
3.                 raise TypeError unless hash.is_a?( Hash )
   
4.                 nhash = {}
   
5.                 keys  = self.keys | hash.keys
   
6.                 keys.each do |k|
   
7.                         nhash[k] = self[k] || hash[k]
   
8.                 end
   
9.                 return nhash
   
10.         end
    
11. end
    

复制代码

测试代码：

1. # test
   
2. # except { 1=>2, 2=>4, 3=>4, 5=>6, 7=>8}
   
3. 
   
4. a = {1=>2, 3=>4, 5=>6}
   
5. b = {1=>3, 2=>4, 3=>4, 7=>8}
   
6. puts a.hplus(b)
   
7. #=> {1=>2, 3=>4, 5=>6, 2=>4, 7=>8}

复制代码

Benchmark跑10,000次a.hplus(b)。

1. Rehearsal ------------------------------------
   
2.    0.156000   0.016000   0.172000 (  0.171875)
   
3. --------------------------- total: 0.172000sec
   
4. 
   
5.        user     system      total        real
   
6.    0.188000   0.000000   0.188000 (  0.203125)

复制代码

退屈￡无聊

1. class Hash
   
2.   def add(new)
   
3.     return unless new.is_a?(hash)
   
4.     new.each_key do |key|
   
5.       unless self[key].nil?
   
6.         #self[key] = [self[key], new[key]]
   
7.       else
   
8.         self[key] = new[key]
   
9.       end
   
10.     end
    
11.     return self
    
12.   end
    
13. end

复制代码