Con esta nueva metodología de organizar un programa buscamos dividir un problema en subproblemas y plantear algoritmos en Ruby que los resuelvan.
Vimos que un método lo definimos mediante un nombre y que puede recibir datos por medio de sus parámetros.
Los parámetros son la forma para que un métodos reciba datos para ser procesados. Ahora veremos otra característica de los métodos que es la de devolver un dato a quien invocó al método (recordemos que a un método lo podemos llamar desde el bloque principal de nuestro programa o desde otro método que desarrollemos)
Confeccionar un método que le enviemos como parámetro el valor del lado de un cuadrado y nos retorne su superficie.
def retornar_superficie(lado)
lado * lado
end
# bloque principal del programa
print "Ingrese el valor del lado del cuafrado:"
va = gets.to_i
superficie = retornar_superficie va
puts "La superficie del cuadrado es #{superficie}"
El método retornar_superficie recibe un parámetro llamado lado.
El algoritmo para obtener la superficie de un cuadrado consiste en multiplicar el valor de su lado por si mismo. No es necesario asignar el producto de lado * lado a una variable local. En Ruby el resultado de la última línea del método se retorna a quien llamó el método.
def retornar_superficie(lado)
lado * lado
end
Hay un cambio importante cuando llamamos o invocamos a un método que devuelve un dato:
superficie = retornar_superficie va
Es decir el valor devuelto por el método retornar_superficie se almacena en la variable superficie.
Es un error lógico llamar al método retornar_superficie y no asignar el valor a una variable:
retornar_superficie va
El dato devuelto se pierde (en nuestro caso el producto de lado * lado)
Si podemos utilizar el valor devuelto para pasarlo a otro método:
puts "La superficie del cuadrado es #{retornar_superficie va}"
El método retornar_superficie devuelve un entero y se lo pasamos al método puts para que lo muestre.
Confeccionar un método que le enviemos como parámetro un String y nos retorne la cantidad de caracteres que tiene. En el bloque principal solicitar la carga de dos nombres por teclado y llamar al método dos veces. Imprimir en el bloque principal cual de las dos palabras tiene más caracteres.
def largo(cadena)
cadena.length
end
# bloque principal
print "Ingrese primer nombre:"
nombre1 = gets.chomp
print "Ingrese segundo nombre:"
nombre2 = gets.chomp
la1 = largo nombre1
la2 = largo nombre2
if la1==la2
puts "Los nombres: #{nombre1},#{nombre2} tienen la misma cantidad de caracteres"
elsif la1>la2
puts "#{nombre1} es mas largo"
else
puts "#{nombre2} es mas largo"
end
Hemos definido un método llamado largo que recibe un parámetro llamado cadena y retorna la cantidad de caracteres que tiene dicha cadena (utilizamos el método length para obtener la cantidad de caracteres del String)
Desde el bloque principal de nuestro programa llamamos al método largo pasando primero un String y guardando en una variable el entero devuelto:
la1 = largo nombre1
En forma similar calculamos el largo del segundo nombre:
la2 = largo nombre2
Solo nos queda analizar cual de las dos variables tiene un valor mayor para indicar cual tiene más caracteres:
if la1==la2
puts "Los nombres: #{nombre1},#{nombre2} tienen la misma cantidad de caracteres"
elsif la1>la2
puts "#{nombre1} es mas largo"
else
puts "#{nombre2} es mas largo"
end
Confeccionar un método que le enviemos como parámetros dos enteros y nos retorne el mayor.
def retornar_mayor(v1, v2)
if v1 > v2
return v1
end
return v2
end
# bloque principal
print "Ingrese el primer valor:"
valor1 = gets.to_i
print "Ingrese el segundo valor:"
valor2 = gets.to_i
puts retornar_mayor(valor1, valor2)
Tenemos un método que recibe dos parámetros y debe retornar el mayor de ellos.
En Ruby si queremos que finalice el método y retorne inmediatamente un valor podemos utilizar la palabra clave return y el valor a retornar:
def retornar_mayor(v1, v2)
if v1 > v2
return v1
end
return v2
end
Cuando un método encuentra la palabra return no sigue ejecutando el resto del método sino que sale a la línea del programa desde donde llamamos a dicho método.
Si queremos podemos implementarlo sin utilizar return definiendo una variable local:
def retornar_mayor(v1, v2)
if v1 > v2
mayor = v1
else
mayor = v2
end
mayor
end
def retornar_superficie(lado1, lado2)En el bloque principal del programa cargar los lados de dos rectángulos y luego mostrar cual de los dos tiene una superficie mayor.
ejercicio108.rb
def retornar_promedio(v1, v2, v3)
(v1 + v2 + v3) / 3
end
# bloque principal
print "Ingrese primer valor:"
valor1 = gets.to_i
print "Ingrese segundo valor:"
valor2 = gets.to_i
print "Ingrese tercer valor:"
valor3 = gets.to_i
puts "Valor promedio de los tres numeros #{retornar_promedio(valor1,valor2,valor3)}"
ejercicio109.rb
def retornar_perimetro(lado)
lado * 4
end
# bloque principal
print "Lado del cuadrado:"
lado = gets.to_i
puts "El perimetro es: #{retornar_perimetro(lado)}"
ejercicio110.rb
def retornar_superficie(lado1, lado2)
lado1 * lado2
end
# bloque principal
puts "Primer rectangulo"
print "Ingrese lado menor del rectangulo:"
lado1 = gets.to_i
print "Ingrese lado mayor del rectangulo:"
lado2 = gets.to_i
puts "Segundo rectangulo"
print "Ingrese lado menor del rectangulo:"
lado3 = gets.to_i
print "Ingrese lado mayor del rectangulo:"
lado4 = gets.to_i
if retornar_superficie(lado1, lado2) == retornar_superficie(lado3,lado4)
puts "Los dos rectangulos tiene la misma superficie"
elsif retornar_superficie(lado1, lado2) > retornar_superficie(lado3, lado4)
puts "El primer rectangulo tiene una superficie mayor"
else
puts "El segundo rectangulo tiene una superficie mayor"
end
ejercicio111.rb
def cantidad_vocal_a(palabra)
cant=0
palabra.each_char do |letra|
if letra == "a" || letra == "A"
cant = cant + 1
end
end
cant
end
# bloque principal
print "Ingrese una palabra:"
palabra = gets.chomp
puts "La palabra #{palabra} tiene #{cantidad_vocal_a(palabra)} letras a o A"