Ejercicios

  1. ¿Que resultados se obtienen en las siguientes operaciones?
    >> h = {:one => 1, :two => 2}
    => {:one=>1, :two=>2}
    >> h.index 1
    => 
    >> h.index 2
    => 
    >> h.key?(:a)
    => 
    >> h.key?(:one)
    => 
    >> h.has_key?(:one)
    => 
    >> h.include?(:one)
    => 
    >> h.member?(:one)
    => 
    >> h.value?(1)
    => 
    >> h.value?(3)
    => 
    >> h.has_value?(1)
    =>
    
  2. Es posible especificar un valor por defecto para un Hash. El método default retorna el valor por defecto.

    ¿Que resultados se obtienen en las siguientes operaciones?

    >> h = Hash.new("Go Fish")
    => {}
    >> h.default
    => 
    >> h["a"] = 100
    => 100
    >> h["b"] = 200
    => 
    >> h["a"]
    => 
    >> h["c"]
    => 
    >> h["c"].upcase! 
    => "GO FISH"
    >> h["c"]
    => 
    >> h["d"]
    => 
    >> h.keys
    =>
    
  3. Se puede pasar al constructor de la clase Hash un bloque de código que se encarga de computar el valor por defecto. Al bloque se le pasa el hash y la clave.

    ¿Que resultados se obtienen en las siguientes operaciones?

    >> h = Hash.new { |hash, key| hash[key] = "Go Fish: #{key}" }
    => {}
    >> h["c"]           
    => 
    >> h["d"]         
    => 
    >> h.keys          
    =>
    
  4. Este ejercicio muestra como un hash puede ser utilizado en ruby para memoizar un cálculo.

    ¿Que resultados se obtienen en las siguientes operaciones?

    >> fact = Hash.new { |h,k| if k > 1 then h[k] = k*h[k-1] else h[1] = 1 end }
    => {}
    >> fact[4]
    => 
    >> fact
    =>
    
  5. ¿Que resultados se obtienen en las siguientes operaciones (véase la entrada en la Wikipedia para Números de Fibonacci)?
    >> fib = Hash.new { |h,k| if k > 1 then h[k] = h[k-1]+h[k-2] end }
    => {}
    >> fib[0], fib[1] = 0, 1
    => [0, 1]
    >> fib[7]
    => 13
    >> fib
    => 
    >> fib.sort
    => 
    >> fib[12]
    => 144
    >> fib.sort
    => 
    >> fib.keys.sort { |a,b| a.to_s <=> b.to_s }.each { |k| puts "#{k} => #{fib[k]}" }
    
    
    
    
    
    
    
    
    
    
    
    
    
    =>
    
  6. ¿Que resultados se obtienen en las siguientes operaciones?
    >> h = {}
    => {}
    >> h[:a] = 1
    => 1
    >> h.store(:b, 2)
    => 
    >> h
    => 
    >> h.replace({1 => :a, 2 => :b})
    => {1=>:a, 2=>:b}
    >> h
    => 
    >> h.replace({1 => :a, 2 => :b, 3 => :c})
    =>
    
  7. ¿Que resultados se obtienen en las siguientes operaciones?
    >> 
    ?>   class Hash
    >>      def []= (*keys)
    >>        value = keys.pop
    >>        keys.each{|key| store(key, value) }
    >>      end 
    >>    end 
    => nil
    >>    hsh = {}
    => {}
    >>    hsh[:a, :b, :c] = 42
    => 42
    >>    hsh 
    => 
    >>    hsh[:a, :b] = "foo"
    => "foo"
    >>    hsh[:a].upcase!
    => 
    >>    hsh[:b]
    =>
    

  8. ¿Que resultados se obtienen en las siguientes operaciones?
    >> h = { :a => 1, :b => 2 }
    => {:b=>2, :a=>1}
    >> h.fetch(:a)
    => 1
    >> h.fetch(:c)
    IndexError: key not found
      from (irb):18:in `fetch'
      from (irb):18
      from :0
    >> h[:c]
    => 
    >> h.fetch(:c, 33)
    => 
    >> h
    => {:b=>2, :a=>1}
    >> h.fetch(:c) { |k| "#{k} oppps!" }
    =>
    

  9. ¿Que resultados se obtienen en las siguientes operaciones?
    >> h = { :a => 1, :b => 2, :c => 3 }
    => {:b=>2, :c=>3, :a=>1}
    >> h.values_at(:a, :b)
    => [1, 2]
    >> h.values_at(:d, :d, :a)
    => 
    >> h.values_at(:c)
    =>
    
  10. ¿Que resultados se obtienen en las siguientes operaciones?
    >> h = { :a => 1, :b => 2, :c => 3 }
    => {:b=>2, :c=>3, :a=>1}
    >> h.select { |k,v| v % 2 == 0 }
    => 
    >> h = { :a => 1, :b => 2}
    => {:b=>2, :a=>1}
    >> h.merge({:a => 3, :c => 3})
    => 
    >> h
    => 
    >> h.merge!({:a => 3, :c => 3})
    => 
    >> h
    =>
    
  11. ¿Que resultados se obtienen en las siguientes operaciones?
    >> h = { :a => 1, :b => 2}
    => {:b=>2, :a=>1}
    >> j = {:a => 3, :c => 3}
    => {:c=>3, :a=>3}
    >> h.merge(j) { |k,a,b| a}
    => 
    >> h.merge(j) { |k,a,b| (a+b)/2}
    =>
    
  12. La clase Hash dispone del método Hash[ [key =>|, value]* ] que crea un nuevo hash con los objetos específicados. Es equivalente a { key, value, ... }. Debe haber un número par de argumentos.

    ¿Que resultados se obtienen en las siguientes operaciones?

    >> a = [:a, 1, :b, 2, :c, 3]
    => [:a, 1, :b, 2, :c, 3]
    >> Hash[*a]
    => 
    >> b = [[:a, 1], [:b, 2], [:c, 3]]
    => [[:a, 1], [:b, 2], [:c, 3]]
    >> b.flatten
    => 
    >> Hash[*b.flatten]
    => 
    >> x = ["a" => 100, "b" => 200]
    => [{"a"=>100, "b"=>200}]
    >> h = Hash[*x]
    =>
    
  13. ¿Que resultados se obtienen en las siguientes operaciones?
    >> h = { :a => 1, :b => 2}
    => {:b=>2, :a=>1}
    >> Array[*h]
    => 
    >> Array[*h].flatten
    =>
    
  14. ¿Que resultados se obtienen en las siguientes operaciones?
    >> a = ('a'..'z').to_a
    => 
    >> a.map { |x| [ x,  nil ] }
    => 
    >> a.map { |x| [ x,  nil ] }.flatten
    => 
    >> Hash[* a.map { |x| [ x,  nil ] }.flatten]
    =>
    
  15. ¿Que resultados se obtienen en las siguientes operaciones?
    >> h = {:a => 1, :b =>2, :c => 3}
    => {:b=>2, :c=>3, :a=>1}
    >> h.invert
    => 
    >> h.to_s
    => 
    >> h.inspect
    =>
    

Casiano Rodriguez León 2015-06-18