Repaso

  1. Complete el siguiente programa Ruby que resuelve el reto Dropbox conocido como "El Problema de la Dieta" (partes en subrayado):
     1  def solve(goal, values)
     2    x = values.____
     3  
     4    subsets = lambda do |k|
     5      return { _______ } if k < 0
     6      old_sums = subsets[___]
     7  
     8      new_sums = ___
     9  
    10      old_sums.keys.each do |p|
    11        c = p + ____
    12        new_sums[c] = _________________ if c <= goal
    13      end
    14  
    15      return old_sums._____(new_sums) 
    16    end
    17  
    18    z = subsets[values.________][goal] || []
    19    x.values_at(*z)
    20  end
    21  
    22  rdropbox = {
    23    'free-lunch'    =>  802,
    ..    .......................,
    34    'playing-drums'    =>  -295
    35  }.invert
    36  
    37  s = solve(0, rdropbox.keys)
    38  puts s.inspect
    39  puts rdropbox.values_at(*s).inspect
    
  2. Escriba los nombres de los métodos para listar los nombres (como cadenas) de ¿Cuales son métodos de instancia? ¿Cuáles de clase?

  3. El código que sigue implementa un motor para las expresiones regulares. Para simplificar las expresiones, se han definido algunos operadores. Siguen algunos ejemplos de uso:
      e = 'c'.re - +('d'.re | 'r'.re)   # /c(d|r)+/
      s = 'crddf'
      remaining = e[s]                  # s =~ /c(d|r)+/
      puts "/c(d|r)+/ '#{s}' Matched. Remaining = '#{remaining}'" if remaining
                                  # /c(d|r)+/ 'crddf' Matched. Remaining = 'f' 
      e = 'c'.re - ~('d'.re | 'r'.re)   # /c(d|r)*/
      s = 'cdrdrf'
      remaining = e[s]                  # s =~ /c(d|r)*/
      puts "/c(d|r)*/ '#{s}' Matched. Remaining = '#{remaining}'" if remaining
    
    Rellene el código que falta:
     1  class ____
     2  
     3    def -(right)  # concatenacion
     4      lambda { |x|  _ _ self[x] ___ right[_] }
     5    end
     6  
     7    def |(right)  # or
     8      lambda { |x|  self[x] __ _____[x] }
     9    end
    10  
    11    def epsilon   # palabra vacía
    12      lambda {|x| _ }
    13    end
    14  
    15    def ~         # cierre de Kleene *
    16      lambda { |x| (_____)[x] or self._______[x] }
    17    end
    18  
    19    def +@        # cierre positivo
    20      lambda { |x| (____________)[x] }
    21    end
    22  
    23  end # Proc
    24  
    25  class ______
    26    def re
    27      lambda { |x| x[0,self.______] == ____ and x[self.______..__] }
    28    end
    29  end
    
  4. ¿Que predicado debo de usar para saber si la llamada al método actual es seguida de un bloque?
  5. ¿Que hace el método send?¿Que argumentos lleva? ¿que retorna?
  6. ¿Cómo puedo llamar a un método privado en Ruby desde fuera de la clase?
  7. ¿Que visibilidad tiene define_method? ¿Cómo funciona? ¿Que argumentos recibe? ¿Que devuelve? ¿En que contexto espera ser evaluado?
  8. ¿Es posible definir en Ruby un método cuyo nombre no case con la expresión regular /^[a-z_]+\w*$/i?
  9. ¿Cuándo se ejecuta method_missing? ¿Que argumentos espera? ¿Que precauciones hay que tomar cuando se escribe uno?
  10. ¿Que se entiende por delegación?
     1  require 'delegate'
     2  class Set < DelegateClass(Array)
    
    ¿Que ocurre en la línea 2? ¿Que debe hacerse en el initialize para que el proceso de delegación funcione?
  11. ¿Cómo puedo recorrer los objetos (referencia) que estan vivos en un punto dado de la ejecución de un programa?
  12. ¿Como puedo obtener los nombres de los métodos de un objeto?
  13. ¿Como funciona el método de instancia index de un objeto de la clase Array?
  14. ¿Cómo puedo llamar a un método cuyo nombre esta almacenado en la variable x?
  15. ¿Cómo puedo saber cuantos argumentos espera un método cuyo nombre esta almacenado en la variable x?
  16. ¿Cuales son los pasos para sobreescribir un método mm de una clase o módulo MM por nuestro propio mm?

  17. Rellene las partes de código que faltan en esta clase que implementa una clase que da una funcionalidad parecida a la de la librería markby:
    class HTML
    
      attr_accessor :page
    
      def initialize(&block)
        @page = ____
        _____________ &block
      end
    
      def build_attr(attributes)
          return '' if attributes.nil? or  attributes._____?
          attributes.______(__) { |s,x| s += %{ ___________________ } } 
      end
    
      def method_missing(tag, *args)
        if block_given?
          @page.____ ______
          _____ 
          text = @page.________
        else
          text = args.__________ || "\n"
        end
        tagattr = build_attr(args.shift) 
        text = "______________________________________"
        @page[__].push ____
        text
      end
    
      def to_s
        @page.join("\n")
      end
    end
    
  18. Explique brevemente que hacen los siguientes comandos:
    1. git init
    2. git add
    3. git commit
    4. git clone ssh://..
    5. git status
    6. git diff oldref newref
    7. git push
    8. git pull
    1. ¿Que paquete hay que cargar require '_________' para elaborar una prueba?
    2. ¿De que clase debe heredar nuestra clase para que pueda ser usada en la implementación de pruebas Test::Unit?
    3. ¿Que patrón debe seguir el nombre de los métodos de prueba dentro de la clase de prueba?
    1. ¿Cómo se declara una tarea en Rake?
    2. ¿Cómo se declara que una tarea tiene dependencias?
    3. ¿Cómo se definen las acciones asociadas que componen una tarea?
    4. Cada tarea se define en un lugar del fichero Rakefile ¿cierto o falso?
    5. ¿Cómo se declara una tarea fichero? ¿Como se definen sus dependencias? ¿Cómo se declara una tarea directorio?
    6. ¿Que hace el método sh?
    7. ¿Como se llama la clase que nos facilita la tarea de ejecutar un conjunto de pruebas? ¿Que hacen los métodos libs y pattern del objeto t en el siguiente código?
      Rake::TestTask.new do |t|
        t.libs << "test"
        t.test_files = FileList['test/test*.rb']
        t.verbose = true
      end
      

Casiano Rodriguez León 2015-06-18