将散列转换为嵌套散列

假设有一个像

{ 
    [:a, :b, :c] => 1, 
    [:a, :b, :d] => 2, 
    [:a, :e] => 3, 
    [:f] => 4, 
}

每个键的排列是什么把它转换成一个嵌套的散列像

{ 
    :a => { 
     :b => {:c => 1, :d => 2}, 
     :e => 3, 
    }, 
    :f => 4, 
}

来源

2011-12-06 sawa

什么“递归”有关，这是明明白白的嵌套。 –

@dominikh特定的哈希可能不是递归的，但是无论使用哪种算法，它都是递归的。但我认为你说的话是有道理的。我编辑它。 – sawa

到目前为止您尝试过什么？关于您尝试解决方案的具体内容不起作用？ – maerics

这里最好的办法是一个迭代求解，递归一个散列作为一个练习留给读者：

def convert(h={}) 
    ret = {} 
    h.each do |k,v| 
    node = ret 
    k[0..-2].each {|x| node[x]||={}; node=node[x]} 
    node[k[-1]] = v 
    end 
    ret 
end 

convert(your_hash) # => {:f=>4, :a=>{:b=>{:c=>1, :d=>2}, :e=>3}}

来源

2011-12-06 18:48:20 maerics

谢谢。你的答案比递归地做得更好。太好了。 – sawa

为什么默认为空哈希？注意改变为'h.each_with_object（{}）do |（k，v），ret |'你可以放下第一行和最后一行（尽管我不确定是否有'each_with_object'（v1.9 +）可用当你回答这个问题时）。当然你也可以使用'reduce'。 –

已经有一个很好的答案，但我在这工作递归解决方案，所以在这里它是：

def to_nest(hash) 
    {}.tap do |nest| 
    hash.each_pair do |key, value| 
     nodes = key.dup 
     node = nodes.shift 
     if nodes.empty? 
     nest[node] = value 
     else 
     nest[node] ||= {} 
     nest[node].merge!({nodes => value}) 
     end 
    end 
    nest.each_pair do |key, value| 
     nest[key] = to_nest(value) if value.kind_of?(Hash) 
    end 
    end 
end

来源

2011-12-06 19:19:57

功能递归算法：

require 'facets' 

class Hash 
    def nestify 
    map_by { |ks, v| [ks.first, [ks.drop(1), v]] }.mash do |key, pairs| 
     [key, pairs.first[0].empty? ? pairs.first[1] : Hash[pairs].nestify] 
    end 
    end 
end 

p {[:a, :b, :c]=>1, [:a, :b, :d]=>2, [:a, :e]=>3, [:f]=>4}.nestify 
# {:a=>{:b=>{:c=>1, :d=>2}, :e=>3}, :f=>4}

来源

2011-12-06 19:32:31 tokland

另一种方式：

def convert(h) 
    h.each_with_object({}) { |(a,n),f| f.update({ a.first=>(a.size==1 ? n : 
    convert({ a[1..-1]=>n })) }) { |_,ov,nv| ov.merge(nv) } } 
end

试试：

h = { 
    [:a, :b, :c] => 1, 
    [:a, :b, :d] => 2, 
    [:a, :e] => 3, 
    [:f] => 4, 
} 

convert(h) #=> {:a=>{:b=>{:d=>2}, :e=>3}, 
      # :f=>4}

来源

2014-05-26 06:24:19

对于混合哈希/数组嵌套结构可以使用th是。（修改为阵列）

def unflatten(h={}) 
    ret = {} 
    h.each do |k,v| 
    node = ret 
    keys = k.split('.').collect { |x| x.to_i.to_s == x ? x.to_i : x } 
    keys.each_cons(2) do |x, next_d| 
     if(next_d.is_a? Fixnum) 
     node[x] ||= [] 
     node=node[x] 
     else 
     node[x] ||={} 
     node=node[x] 
     end 
    end                                                                   
    node[keys[-1]] = v 
    end 
    ret 
end

提供您使用下面的flattening。（圆点键代替阵列独立字符串[分割上，如果你需要。]）

def flatten_hash(hash) 
    hash.each_with_object({}) do |(k, v), h| 
    if v.is_a? Hash 
     flatten_hash(v).map do |h_k, h_v| 
     h["#{k}.#{h_k}"] = h_v 
     end 
    elsif v.is_a? Array 
     flatten_array(v).map do |h_k,h_v| 
     h["#{k}.#{h_k}"] = h_v 
     end 
    else 
     h[k] = v 
    end 
    end 
end 


def flatten_array(array) 
    array.each_with_object({}).with_index do |(v,h),i| 
    pp v,h,i 
    if v.is_a? Hash 
     flatten_hash(v).map do |h_k, h_v| 
     h["#{i}.#{h_k}"] = h_v 
     end 
    elsif v.is_a? Array 
     flatten_array(v).map do |h_k,h_v| 
     h["#{i}.#{h_k}"] = h_v 
     end 
    end 
    end 
end

来源

2015-12-18 11:46:40

使用DeepEnumerable：

require DeepEnumerable 

h = {[:a, :b, :c]=>1, [:a, :b, :d]=>2, [:a, :e]=>3, [:f]=>4} 

h.inject({}){|hash, kv| hash.deep_set(*kv)}

来源

2015-12-18 20:42:36 user12341234

将散列转换为嵌套散列

回答

相关问题