13 - Arreglos: carga por teclado de sus elementos

Un arreglo en Ruby es una estructura dinámica (es decir puede ir agregando y eliminando elementos durante la ejecución del programa)

Hemos visto que podemos definir un arreglo por asignación indicando entre corchetes los valores a almacenar:

arreglo = [10, 20, 40]

Un arreglo luego de definida podemos agregarle nuevos elementos a la colección. La primera forma que veremos para que nuestro arreglo crezca es utilizar el operador <<:

arreglo = [10, 20, 30]
puts arreglo.length    # imprime un 3
arreglo << 100
puts arreglo.length    # imprime un 4
puts arreglo[0]        # imprime un 10
puts arreglo[3]        # imprime un 100

Definimos un arreglo con tres elementos:

arreglo = [10, 20, 30]

Imprimimos la cantidad de elementos que tiene el arreglo, en nuestro caso lo definimos con 3:

puts arreglo.length    # imprime un 3

Agregamos una nuevo elemento al final del arreglo:

arreglo << 100

Si llamamos nuevamente al método length ahora retorna un 4:

puts arreglo.length    # imprime un 4

Imprimimos ahora el primer y cuarto elemento del arreglo (recordar que se numeran a partir de cero):

puts arreglo[0]        # imprime un 10
puts arreglo[3]        # imprime un 100

Problema 1:

Definir arreglo vacío y luego solicitar la carga de 5 enteros por teclado y añadirlos al arreglo. Imprimir luego el arreglo completo.

Programa: ejercicio062.rb

#definimos una arreglo vacío
arreglo = []
x = 0
while x < 5
  print "Ingrese un valor entero:"
  valor = gets.to_i
  arreglo << valor
  x = x + 1
end
print arreglo

El algoritmo propuesto crea primero un arreglo vacío (debemos asignar los corchetes de apertura y cerrado sin contenido):

arreglo = []

Luego mediante un while solicitamos en forma sucesiva la carga de un entero por teclado y procedemos a agregarlo al final del arreglo:

x = 0
while x < 5
  print "Ingrese un valor entero:"
  valor = gets.to_i
  arreglo << valor
  x = x + 1
end

Finalmente mostramos los elementos del arreglo en forma completo:

print arreglo

Problema 2:

Realizar la carga de valores enteros por teclado, almacenarlos en un arreglo. Finalizar la carga de enteros al ingresar el cero. Mostrar finalmente el tamaño del arreglo y sus elementos.

Programa: ejercicio063.rb

arreglo = []
loop do
  print "Ingresar valor (0 para finalizar):"
  valor = gets.to_i
  if valor == 0
    break
  end
  arreglo << valor
end
puts "Tamano del arreglo: #{arreglo.length}"
puts "Elementos del arreglo #{arreglo}"

En este problema el arreglo crecerá hasta que el operador ingrese el valor cero.

Dentro del ciclo loop do procedemos a cargar un valor entero. Si se ingresa un cero cortamos el ciclo repetitivo sino procedemos a añadirlo al arreglo mediante el operador << :

loop do
  print "Ingresar valor (0 para finalizar):"
  valor = gets.to_i
  if valor == 0
    break
  end
  arreglo << valor
end

Cuando salimos del ciclo repetitivo procedemos a obtener el tamaño del arreglo y mostrar sus elementos:

puts "Tamano del arreglo: #{arreglo.length}"
puts "Elementos del arreglo #{arreglo}"

Acotaciones

En Ruby hay actividades que se pueden realizar de muchas formas. El agregado de un elemento a un arreglo además de utilizar el operador << se puede hacer llamando al método push:

#definimos una arreglo vacío
arreglo = []
x = 0
while x < 5
  print "Ingrese un valor entero:"
  valor = gets.to_i
  arreglo.push(valor)
  x = x + 1
end
print arreglo

Problemas propuestos

  • Almacenar en un arreglo los sueldos (valores flotantes) de 5 operarios. Imprimir el arreglo y el promedio de sueldos.
  • Cargar por teclado y almacenar en un arreglo las alturas de 5 personas (valores flotantes)
    Obtener el promedio de las mismas. Contar cuántas personas son más altas que el promedio y cuántas más bajas.
  • Una empresa tiene dos turnos (mañana y tarde) en los que trabajan 8 empleados (4 por la mañana y 4 por la tarde) Confeccionar un programa que permita almacenar los sueldos de los empleados agrupados en dos arreglos.
    Imprimir los dos arreglos de sueldos.
Solución 
ejercicio064.rb

sueldos = []
suma=0
x = 0
while x < 5
  print "Ingrese el sueldo del operario:"
  valor = gets.to_f
  sueldos << valor
  suma = suma + valor
  x = x + 1
end
puts "Listado de sueldos: #{sueldos}"
promedio = suma / 5
puts "Promedio de sueldos #{promedio}"




ejercicio065.rb

alturas = []
suma = 0
x = 0
while x < 5
  print"Ingrese la altura:"
  valor = gets.to_f
  alturas << valor
  suma = suma + valor
  x = x + 1
end
puts "Las alturas ingresadas son #{alturas}"
promedio = suma / 5
puts "El promedio de las alturas es #{promedio}"
altas = 0
bajas = 0
x = 0
while x < 5
  if alturas[x] > promedio
       altas = altas + 1
  else
    if alturas[x]<promedio
      bajas = bajas + 1
    end
  end
  x = x + 1
end
puts "La cantidad de personas mas bajas al promedio es #{bajas}"
puts "La cantidad de personas mas altas al promedio es #{altas}"




ejercicio066.rb

sueldos_man = []
puts "Sueldos turno manana"
x = 0
while x < 4
  print"Ingrese sueldo:"
  valor = gets.to_f
  sueldos_man << valor
  x = x + 1
end
sueldos_tar = []
puts "Sueldos turno tarde"
x = 0
while x < 4
  print"Ingrese sueldo:"
  valor = gets.to_f
  sueldos_tar << valor
  x = x + 1
end
puts "Turno mañana #{sueldos_man}"
puts "Turno tarde #{sueldos_tar}"
Retornar