Métodos: parámetros de tipo Array y Hash

Hemos visto que los métodos pueden recibir parámetros. La comunicación entre métodos se produce mediante el envío de datos a través de los parámetros y el valor que retorna el método.

Hasta ahora hemos resuelto problemas enviando dato simples como enteros, flotantes y cadenas de caracteres. En este concepto veremos que un método puede recibir tanto datos simples como estructuras de datos de tipo Array y Hash.

Problema 1:

Definir por asignación un arreglo de enteros en el bloque principal del programa. Elaborar tres métodos, el primero recibe el arreglo y retorna la suma de todos sus elementos, el segundo recibe el arreglo y retorna el mayor valor y el último recibe el arreglo y retorna el menor.

Programa: ejercicio112.rb

def sumarizar(arreglo)
  suma = 0
  arreglo.each { |elemento| suma = suma + elemento}
  suma
end

def mayor(arreglo)
  arreglo.max
end

def menor(arreglo)
  arreglo.min
end
 
# bloque principal del programa

arreglo = [10, 56, 23, 120, 94]
print "Arreglo completo:"
print arreglo, "\n"
puts "La suma de todos su elementos es #{sumarizar(arreglo)}"
puts "El mayor valor del arreglo es #{mayor(arreglo)}"
puts "El menor valor del arreglo es #{menor(arreglo)}"

El método sumarizar recibe un parámetro, dentro del mismo lo recorremos mediante la llamada a each y accedemos a sus elementos y los sumamos:

def sumarizar(arreglo)
  suma = 0
  arreglo.each { |elemento| suma = suma + elemento}
  suma
end

Desde el bloque principal de nuestro programa llamamos a sumarizar enviando el dato retornado al método puts para que lo muestre:

puts "La suma de todos su elementos es #{sumarizar(arreglo)}"

De forma similar definimos los otros dos métodos que también reciben el arreglo y luego llamando a los métodos max y min obtenemos el mayor y menor elemento del arreglo :

def mayor(arreglo)
  arreglo.max
end

def menor(arreglo)
  arreglo.min
end

Las llamadas a estos dos métodos desde el bloque principal es similar a cuando llamamos a sumarizar (como cada uno retorna un entero procedemos a llamarlos dentro del método puts):

puts "El mayor valor del arreglo es #{mayor(arreglo)}"
puts "El menor valor del arreglo es #{menor(arreglo)}"

El nombre del Array que definimos en el bloque principal del programa es "arreglo":

arreglo = [10, 56, 23, 120, 94]

No hay ningún problema de definir dicha variable con el mismo nombre que el parámetro del método.

Problema 2:

Definir en el bloque principal del programa un Array. Pasar a un método el arreglo y proceder a cargar por teclado 5 valores.
Definir otro método que reciba el arreglo y lo muestre por pantalla..

Programa: ejercicio113.rb

def cargar(arreglo)
  for x in 1..5
    print "Ingrese un valor:"
    valor = gets.to_i
    arreglo << valor
  end
end

def imprimir(arreglo)
  arreglo.each {|elemento| print elemento, "-"}
end

# bloque principal del programa

arreglo = []
cargar(arreglo)
imprimir(arreglo)

En el bloque principal de nuestro programa definimos un Array vacío:

arreglo = []

Llamamos seguidamente al método cargar y le pasamos el Array que acabamos de definir:

cargar(arreglo)

Cuando en el método cargar modificamos agregamos elementos lo que sucede es que se están agregando elementos en el Array definido en el bloque principal del programa:

def cargar(arreglo)
  for x in 1..5
    print "Ingrese un valor:"
    valor = gets.to_i
    arreglo << valor
  end
end

Finalmente desde el bloque principal llamamos al método imprimir y le pasamos el Array ya cargado para que lo muestre:

imprimir(arreglo)

Problema 3:

Definir en el bloque principal del programa un Hash. Pasar a un método el Hash y proceder a cargar como clave el nombre de un producto y como clave su precio.
Definir otro método que imprima todos los productos con un precio menor a un valor ingresado por teclado..

Programa: ejercicio114.rb

def cargar(productos)
  loop do
    print "Ingrese la descripción del producto:"
    descripcion = gets.chomp
    print "Ingrese el precio:"
    precio = gets.to_f
    productos[descripcion] = precio
    print "¿Desea ingresar otro producto [s/n]?"
    opcion = gets.chomp
    if opcion == "n"
      break
    end
  end  
end

def consultar(productos)
  print "Ingrese un precio límite:"
  preciocon = gets.to_f
  productos.each do |descripcion, precio|
    if precio < preciocon
      puts "Producto: #{descripcion} con un precio #{precio}"
    end
  end
end

# bloque principal del programa

productos = Hash.new
cargar productos
consultar productos

En el bloque principal definimos un Hash y se lo pasamos a los métodos cargar y consultar:

productos = Hash.new
cargar productos
consulta productos

Problemas propuestos

Crear un Array de enteros por asignación en el bloque principal del programa. Definir un método que reciba un Array y un entero como parámetros. Dentro del método mostrar cada elemento del Array multiplicado por el valor entero enviado.
```
arreglo = [3, 7, 8, 10, 2]
multiplicar arreglo, 3
```
Desarrollar un método que reciba un Array de String y nos retorne el que tiene más caracteres. Si hay más de uno con dicha cantidad de caracteres debe retornar el que tiene un valor de componente más baja.
En el bloque principal iniciamos por asignación el Array de String:
```
palabras = ["enero", "febrero", "marzo", "abril", "mayo", "junio"]
puts "Palabra con mas caracteres: #{mas_caracteres(palabras)}"
```
Definir un Array de enteros por asignación en el bloque principal. Llamar a un método que reciba el arreglo y nos retorne el producto de todos sus elementos. Mostrar dicho producto en el bloque principal de nuestro programa.

Solución

ejercicio115.rb

def multiplicar(arreglo, valor)
  arreglo.each {|elemento| puts "#{elemento} * #{valor} es #{elemento * valor}"}
end

# bloque principal del programa

arreglo = [3, 7, 8, 10, 2]
multiplicar arreglo, 3



ejercicio116.rb

def mas_caracteres(palabras)
  mayor = palabras.length
  pala = palabras[0]
  palabras.each do |pal| 
    if pal.length > mayor
      mayor = pal.length
      pala = pal
    end
  end
  return pala
end

# bloque principal del programa

palabras = ["enero", "febrero", "marzo", "abril", "mayo", "junio"]
puts "Palabra con mas caracteres: #{mas_caracteres(palabras)}"





ejercicio117.rb

def producto(arreglo)
  prod = 1
  arreglo.each{|elemento| prod = prod * elemento}
  return prod
end


# bloque principal del programa

arreglo = [10, 5, 2, 3]
puts "El producto de todos los elementos del arreglo es #{producto(arreglo)}"

Retornar