ruby day 2

i’m having trouble implementing the tree with nested hashes, partly because i don’t really understand the structure and syntax of ruby well. can anyone provide a solution for me to reverse engineer? doesn’t need any comments, i just need to see how it’s done… i’ve spent the last two days trying to figure it out, i’ve done the other exercises.

I found this bit tricky too, after a little fiddling around I came up with this which is pretty simple:

class Tree
  attr_accessor :children, :node_name

  def initialize(hash, name=nil)
    if name.nil?
        arr = hash.to_a
        init_tree(arr[0][1],arr[0][0])
    else
        init_tree(hash, name)
    end
  end

  def init_tree(hash, name)
    @node_name = name
    @children = hash.inject([]) do |arr, (a, b)|
        arr.push(Tree.new(b,a))
    end
  end

  def visit_all(&block)
    visit &block
    children.each {|c| c.visit_all &block}
  end

  def visit(&block)
    block.call self
  end
end

This is the first bit of ruby I’ve ever written so no idea if it’s in a ‘rubonic’ (if there is such a word!) style, or what was intended in the exercise (I flipped the constructor arguments around, and my gut feeling is that that is unnecessary).

Have fun
Finn

I have a slightly shorter implementation (but not necessarily better) of this problem but I am really curious what other ‘novices’ came up with:

class Tree
  attr_accessor :children, :node_name

  def initialize(tree={})  
    tree.each_pair do |node_name, children| 
      node_children = []

      children.each_pair do |child_name, grandchildren|      
        node_children.push(Tree.new({child_name => grandchildren}))
      end

      @node_name = node_name
      @children = node_children
    end
  end

  def visit_all(&block)
    visit &block
    children.each {|child| child.visit_all &block}
  end

  def visit(&block)
    block.call self
  end
end

my_tree = Tree.new( 
  {'grandpa' => { 'dad' => {'child 1' => {}, 'child 2' => {}}, 
                  'uncle' => {'child 3' => {}, 'child 4' => {}}
                }
  }
)

puts "Visiting a node" 
my_tree.visit {|node| puts node.node_name}
puts

puts "Visiting entire tree" 
my_tree.visit_all {|node| puts node.node_name}

I found the question a bit strange since it said ‘Let the initializer accept a nested structure with hashes and arrays.’ when only nested hashes are passed to the tree.

Kind regards,

Geert

I have another solution, that is more similar in spirit to the first one. Maybe it’s not the prettiest Ruby, but does the trick with only 4 lines of initialization:

  def initialize(node)
        @node_name = node.to_a[0][0]
        c = node.to_a[0][1]
        @children = []
        c.each {|k,v| @children.push Tree.new({k, v})}
  end

I also had to think pretty hard to get this one. I’m not sure it is fluent, but it did turn out short.

  def initialize(data)
    data.each do |k, v|
      @node_name = k
      @children = v.inject([]) {|a, (k, v)| a.push(Tree.new({k => v}))}
    end
  end

  def initialize(data)
    data.each do |k, v|
      @node_name = k
      @children = v.map {|(k, v)| Tree.new(k => v)}
    end
  end

Would possibly be a little more idiomatic.

Is the choice of each instead of map purposeful? Since we only care about the side effects, why would one choose one over the other?

I made an assumption that the top level hash has only one key, so I wrote it this way:

  def initialize(hash)
    @node_name = hash.keys.at(0)
    @children = hash[node_name].to_a.map { |(k, v)| 
      Tree.new({k => v}) 
    }
  end

I’ve tried a recursive solution, but it appears that when at the leaf node level (maybe because of the existance of more than one element) Ruby considers as an Array, not as a Hash. Any idea?

    def Tree.build_from_hash(elements={})

        elements.each do |parent, sons|
           childrens = sons.inject([]) { |array, son| array << build_from_hash(son) } unless sons.nil?
           childrens ||= []
           return new(parent, childrens)
        end
    end

I wanted a recursive solution as well but also wanted to guard against an input hash with more than one key at the root level.
Eventually came up with this solution which uses a class method to kick things off (I don’t know if I should consider this cheating):

class Tree 
    attr_accessor :children, :node_name

    def self.create(data={})
        root = Tree.new("root",data)
    end

    def initialize(name, childhash={})
        @node_name = name
        @children = []
        childhash.each { |aname,ahash| @children.push(Tree.new(aname,ahash)) }
    end

    def visit_all(&block)
        children.each {|c| c.visit_all &block}
        visit &block
    end

    def visit(&block)
        block.call(self)
    end
end

rt = Tree.create({'Ruby' => {'Reia'=>{}, 'MacRuby'=>{} } })

This is my version of the code. Perhaps someone will be helpful.

class Tree
  attr_accessor :node_name, :deep, :childrens

  def initialize(node_name, deep=0, childrens={})
    @node_name = node_name
    @deep = deep
    @childrens = childrens
  end

  def visit_all(&b)
    visit &b
    childrens.each do |node_name, childs|
      t = Tree.new(node_name, deep+2, childs)
      t.visit_all &b
    end
    nil
  end

  def visit(&b)
    b.call self
  end

end

t = Tree.new("Root", 0, {
    'grandpa' => {
          'dad' => {
              'child 1' => {},
              'child 2' => {}
          },
          'uncle' => {
              'child 3' => {},
              'child 4' => {} }
    }
  }
)

puts
puts "== Visiting node" 
puts t.visit { |node, deep| puts " #{' ' * node.deep }* #{node.node_name}"  }
puts
puts "== Visiting entire tree" 
puts t.visit_all { |node, deep| puts " #{' ' * node.deep }* #{node.node_name}"  }

Output is:

== Visiting node
 * Root

== Visiting entire tree
 * Root
   * grandpa
     * dad
       * child 1
       * child 2
     * uncle
       * child 3
       * child 4

Here’s the initialize method I came up with:

  def initialize(root)
    @node_name = root.keys[0]
    @children = []
    root[node_name].entries.each{ |kid| @children << Tree.new(Hash[*kid])}
  end

Here is my answer.

  def initialize(root_node)
    @node_name, child_nodes = root_node.first
    @children = []
    child_nodes.each{|key, value| @children << Tree.new({key => value})}
  end

and another solution

def initialize(family={})
    @children = []
    family.each do |k, v|
        @name = k
        v.each {|k, v| @children.push(Tree.new(k=>v))
    end
end