Hemos avanzado y visto que un método puede recibir como parámetros tipos de datos simples como enteros, flotantes etc. y estructuras de datos tipo Array y Hash.
Lo nuevo en este concepto es que un método también puede retornar una estructura de datos tipo Array o Hash.
Confeccionar un método que cargue por teclado un Array de 5 enteros y lo retorne. Un segundo método debe recibir un Array y mostrar todos los valores mayores a 10. Desde el bloque principal del programa llamar a ambos métodos.
def cargar()
arreglo = []
for x in 1..5
print "Ingrese valor:"
valor = gets.to_i
arreglo << valor
end
return arreglo
end
def imprimir_mayor10(arreglo)
print "Elementos del arreglo mayores a 10:"
arreglo.each do |elemento|
if elemento > 10
print elemento, "-"
end
end
end
# bloque principal del programa
arreglo = cargar
imprimir_mayor10 arreglo
Recordemos que el programa empieza a ejecutarse desde el bloque principal y no se ejecutan cada método en forma lineal. Lo primero que hacemos en el bloque principal del programa es llamar al método cargar y se lo asignamos a una variable que recibirá el arreglo:
arreglo = cargar
En el método cargar definimos una variable local de tipo Array donde procedemos a insertar componentes por teclado. Al final del método mediante un return retornamos el arreglo para que lo reciba quien llamó al método:
def cargar
arreglo = []
for x in 1..5
print "Ingrese valor:"
valor = gets.to_i
arreglo << valor
end
return arreglo
end
En el segundo método se muestran todas las componentes que tienen un valor mayor a 10:
def imprimir_mayor10(arreglo)
print "Elementos del arreglo mayores a 10:"
arreglo.each do |elemento|
if elemento > 10
print elemento, "-"
end
end
end
Confeccionar un método que cargue por teclado un arreglo de 5 enteros y lo retorne. Un segundo método debe recibir un arreglo y retornar el mayor y el menor valor del mismo. Desde el bloque principal del programa llamar a ambos métodos e imprimir el mayor y el menor valor del arreglo.
def cargar()
arreglo = []
for x in 1..5
print "Ingrese valor:"
valor = gets.to_i
arreglo << valor
end
return arreglo
end
def retornar_mayormenor(arreglo)
ma = arreglo[0]
me = arreglo[0]
arreglo.each do |elemento|
if elemento > ma
ma = elemento
elsif elemento < me
me = elemento
end
end
return [ma, me]
end
# bloque principal del programa
arreglo = cargar
rango = retornar_mayormenor arreglo
puts "Mayor elemento del arreglo: #{rango[0]}"
puts "Menor elemento del arreglo: #{rango[1]}"
Lo interesante que tenemos que sacar de este ejemplo es que cuando tenemos que retornar varios valores podemos utilizar un Array. El método retornar_mayormenor debe devolver dos enteros, y la forma de hacerlo en Ruby es mediante un Array.
En el método retornar_mayormenor definimos dos variables locales donde almacenamos el primer elemento del arreglo que recibimos como parámetro:
def retornar_mayormenor(arreglo) ma = arreglo[0] me = arreglo[0]
Luego mediante la llamada al método each analizamos cada elemento y verificamos si hay alguno que sea mayor al que hemos considerado mayor hasta ese momento, lo mismo con el menor:
arreglo.each do |elemento|
if elemento > ma
ma = elemento
elsif elemento < me
me = elemento
end
end
Cuando sale del each ya tenemos almacenadas en las variables ma y me el valor mayor y el valor menor del arreglo.
La sintaxis para devolver ambos datos es crear una Array e indicando en cada elemento la variable respectiva:
return [ma, me]
Ahora cuando llamamos a este método desde el bloque principal del programa sabemos que nos retorna un Array y que el primer elemento representa el mayor del Array y el segundo elemento representa el menor del Array:
rango = retornar_mayormenor arreglo
puts "Mayor elemento del arreglo: #{rango[0]}"
puts "Menor elemento del arreglo: #{rango[1]}"
ejercicio120.rb
def cargar
empleados = Hash.new
for x in 1..5
print "Ingrese el nombre del empleado:"
nombre = gets.chomp
print "Ingrese su sueldo:"
sueldo = gets.to_f
empleados[nombre] = sueldo
end
return empleados
end
def imprimir(empleados)
empleados.each do |nombre, sueldo|
puts "Nombre: #{nombre} sueldo=#{sueldo}"
end
end
def sueldos_mayor_4000(empleados)
puts "Empleados con sueldo superior a 4000."
empleados.each do |nombre, sueldo|
if sueldo > 4000
puts "Nombre: #{nombre} sueldo=#{sueldo}"
end
end
end
def promedio_sueldos(empleados)
suma = 0
empleados.each do |nombre, sueldo|
suma = suma + sueldo
end
suma / empleados.length
end
def sueldos_inferior_promedio(empleados, pro)
puts "Empleados con sueldo inferior al promedio."
empleados.each do |nombre, sueldo|
if sueldo < pro
puts "Nombre: #{nombre} sueldo=#{sueldo}"
end
end
end
# bloque principal del programa
empleados = cargar
imprimir empleados
sueldos_mayor_4000 empleados
pro = promedio_sueldos empleados
puts "Promedio de los sueldos #{pro}"
sueldos_inferior_promedio empleados, pro
ejercicio121.rb
def cargar
articulos = Hash.new
for x in 1..5
print "Ingrese la descripción del artículo:"
descripcion = gets.chomp
print "Ingrese el precio:"
precio = gets.to_f
articulos[descripcion] = precio
end
return articulos
end
def imprimir(articulos)
puts "Listado completo de artículos"
articulos.each do |descripcion, precio|
puts "Descripción: #{descripcion} precio=#{precio}"
end
end
def articulo_precio_mayor(articulos)
mayor = 0
nom = ""
articulos.each do |descripcion, precio|
if precio > mayor
mayor = precio
nom = descripcion
end
end
puts "Artículo con un precio mayor: #{nom}"
end
def precio_menor(articulos)
print "Ingrese un importe:"
importe = gets.to_f
puts "Listado de artículos con un precio menor al ingresado"
articulos.each do |descripcion, precio|
if precio < importe
puts "Descripción: #{descripcion} precio=#{precio}"
end
end
end
# bloque principal del programa
articulos = cargar
imprimir articulos
articulo_precio_mayor articulos
precio_menor articulos
ejercicio122.rb
def cargar
arreglo=[]
for x in 1..10
print "Ingrese valor:"
valor = gets.to_i
arreglo << valor
end
return arreglo
end
def generar(arreglo)
arreglo1 = []
arreglo2 = []
arreglo.each do |elemento|
if elemento > 0
arreglo1 << elemento
elsif elemento < 0
arreglo2 << elemento
end
end
return [arreglo1, arreglo2]
end
def imprimir(arreglo)
arreglo.each do |elemento|
print elemento," "
end
print "\n"
end
# bloque principal del programa
arreglo = cargar
arreglos = generar(arreglo)
puts "Arreglo generado con valores positivos"
imprimir(arreglos[0])
puts "Arreglo generado con valores negativos"
imprimir(arreglos[1])