DZone Snippets: dimension code

Extracting all subarray indices from a multi-dimensional array

ntk () — Sat, 22 Apr 2006 20:14:52 GMT

Note the use of Array#fetch to define return values for missing indices!
Example: ar = []; x = ar.fetch(5, []) returns an empty array for non-existing index 5.





class Array



   def subar_indices(ar=[], temp=[])

      temp = temp.dup

      self.each_with_index { |item, index| 

         if item.class == Array

            temp << index

            ar << temp

            ar = item.subar_indices(ar, temp)

         end

      }

      ar.uniq

   end





   def extract_subar_indices

      subarray_indices = self.subar_indices  # subarray_indices is a two-dimensional array

      # puts subarray_indices.inspect

      

      return subarray_indices if subarray_indices.empty?



      first_subar = subarray_indices.shift   # the first subarray contains all two-dimensional subarray indices                



      subarray_indices.each do |subar|

         subar_size = subar.size

         str = ""

         count = -1

         (subar_size - 1).times { count += 1; str << ".fetch(subar[#{count}], [])" }

         str << ".fetch(subar[#{count + 1}], {}"

         str = "self" << str

         if eval(str).class == Hash then subar.shift; redo end

      end



      first_subar.reverse.each do |item| subarray_indices.unshift([item]) end

      subarray_indices

   end



end





array = [1, 2, [3, 4, [5, 6]], 7, 8, [9]]



indices = array.extract_subar_indices



puts indices.inspect  # [[2], [5], [2, 2]]

Extracting all keys from a multi-dimensional hash

ntk () — Wed, 12 Apr 2006 20:29:09 GMT

Extract all complete key sequences from a multi-dimensional hash (with the last key not pointing to another hash; cf. h[1][2][3] vs h[1][2][3][4] below).





class Hash



   def extract_keys



      keys = []



      each_pair do |k1, v1|



         if v1.is_a?(Hash)



            v1.each_pair { |k2, v2|

               if !v2.is_a?(Hash) then keys << [k1, k2]; next end

            v2.each_pair { |k3, v3|

               if !v3.is_a?(Hash) then keys << [k1, k2, k3]; next end

            v3.each_pair { |k4, v4|

               if !v4.is_a?(Hash) then keys << [k1, k2, k3, k4]; next end

            v4.each_pair { |k5, v5|

               if !v5.is_a?(Hash) then keys << [k1, k2, k3, k4, k5]; next end

            v5.each_pair { |k6, v6|

               if !v6.is_a?(Hash) then keys << [k1, k2, k3, k4, k5, k6]; next end

               # add more v[n].each_pair ... loops to process more hash dimensions

            } } } } }      # "}" * 5



         else

            keys << [k1]

         end



      end

      

      keys



   end





   def all_values

      extract_keys.map do |subar|

         key = ""

         subar.size.times { |i| key << "[subar[#{i}]]" }

         hash_str = "self" << key << " rescue nil"   # example: "self[subar[0]][subar[1]][subar[2]][subar[3]] rescue nil"

         hash_value = eval(hash_str) 

      end

   end





#-------------------------





   # Find every path and it's value in a Hash, http://snippets.dzone.com/posts/show/3565

   # Author: Florian Aßmann



   def each_path

      raise ArgumentError unless block_given?

      self.class.each_path(self) { |path, object| yield(path, object) }

   end



   protected

   #def self.each_path(object, path = '', &block)

   def self.each_path(object, path = [], &block)   # alternative

      if object.is_a?(Hash)

         object.each do |key, value|

            #self.each_path(value, "#{ path }#{ key }/", &block)

            self.each_path(value, [path , key].flatten, &block)   # alternative

         end

      else 

         yield(path, object)

      end

   end 



end





h = {"a"=>"b", "c"=>"d", 1=>{2=>{"e"=>"f", 3=>{4=>"value"}}}} 



puts h[1][2].class          # Hash

puts h[1][2]["e"].class     # String



extracted_keys = h.extract_keys

puts extracted_keys.inspect         # [["a"], [1, 2, "e"], [1, 2, 3, 4], ["c"]]



puts h[1][2].has_key?("e")                 # true

puts extracted_keys.include?([1, 2, "e"])  # true





h = {700=>{4=>"value"}, "a"=>"b", 3=>{4=>"value"}, "c"=>"d", 1=>{2=>{"e"=>"f", 3=>{4=>"value"}, 300=>{4=>"value"}}}} 

p h

p h.extract_keys    #=> [["a"], [1, 2, "e"], [1, 2, 300, 4], [1, 2, 3, 4], ["c"], [700, 4], [3, 4]]

p h.all_values      #=> ["b", "f", "value", "value", "d", "value", "value"]





#-----------------





paths = []

complex_hash = Hash[

  :a => { :aa => '1', :ab => '2' },

  :b => { :ba => '3', :bb => '4' }

]

complex_hash.each_path { |path, value| paths << [ path, value ] }



p paths    # => [[[:b, :ba], "3"], [[:b, :bb], "4"], [[:a, :ab], "2"], [[:a, :aa], "1"]]

puts





h = {"a"=>"b", "c"=>"d", 1=>{2=>{"e"=>"f", 3=>{4=>"value"}}}} 

h = {"a"=>"b", "l" => lambda { |x| x+1 }, 1=>{2=>{"e"=>"f", 3=>{4=>"value"}}}} 

h = {700=>{4=>"value"}, "a"=>"b", nil => "NILVALUE", 3=>{4=>"value"}, "c"=>"d", 1=>{2=>{"e"=>"f", 3=>{4=>"value"}, 300=>{4=>"value"}}}} 



p h

p h.extract_keys



keys = []

h.each_path { |path, value| keys << path }

p keys   # complete key sequences (with last key not pointing to another hash)



paths = []

h.each_path { |path, value| paths << [ path, value ] }

p paths   # complete key sequences plus values



vals = []

h.each_path { |path, value| vals << value }

p vals   # all values of complete key sequences



p h.all_values   # same

Creating multi-dimensional hashes in Ruby

ntk () — Thu, 06 Apr 2006 16:09:52 GMT

The use of var = keys.shift (instead of var = keys_clone || keys.shift) will produce an alternative output!





class Hash

  def mdh(*mkeys)

     value = mkeys.pop

     count = 0

     mdhash = lambda { |*keys|

                   count += 1

                   keys_clone = keys.clone if count == 1 # keys_clone will return nil for count > 1 in Hash.new

                   Hash.new(var = keys_clone || keys.shift).update(var => mdhash[*keys] || value) unless keys.empty? 

                 }

     mdhash.call(*mkeys)

  end

end



h = Hash.new.mdh(1, 2, 3, 4, "value")



puts h.inspect  # {[1, 2, 3, 4]=>{1=>{2=>{3=>{4=>"value"}}}}}



k = [1, 2, 3, 4]

puts h.has_key?(k)

puts h[k][k[0]][k[1]][k[2]][k[3]]  # value

Creating multi-dimensional arrays in Ruby

ntk () — Sun, 02 Apr 2006 21:20:23 GMT

Based on a one-liner posted at:
http://aspn.activestate.com/ASPN/Mail/Message/ruby-talk/2852734





class Array



   def mda(*mds)



      count = -1



      mdarray = lambda { |*ds| 

        Array.new( ds.shift || 0 ).collect {

            x = mdarray[*ds] unless ds.empty?

            if x == nil then count += 1; x = self.at(count); end

            x

            }

      }



      mdarray.call(*mds)    



   end



end





ar1 = (1..24).to_a    # input data



ar2 = ar1.mda(1, 2, 3, 4)   # note: 1 x 2 x 3 x 4 = 24 

puts ar2.inspect



puts ar2[0..0][0..1][0..2][0..3].inspect    # returns entire ar2

puts ar2[0][1][2][0..3].inspect             # returns last subarray 

            



# extracting subarrays

ar = []

ar2.each { |a| a.each { |b| b.each { |c| ar << c if c.last > 6 } } }

puts ar.inspect





# extracting only the first subarray that meets the if-condition

ar = []

ar << catch(:val) { ar2.each { |a| a.each { |b| b.each { |c| throw(:val, c) if c.last > 6 }}} }

puts ar.inspect