Estructura de datos tipo Arreglo (Array)

Hasta ahora hemos trabajado con variables que permiten almacenar un único valor:

edad = 32
altura = 1.92
nombre = "juan"

En Ruby existe la estructura de datos tipo Array que permite almacenar una colección de datos y luego acceder por medio de un subíndice a cualquiera de sus componentes.

Creación de arreglos (Array) por asignación

Para crear un arreglo por asignación debemos indicar sus elementos encerrados entre corchetes y separados por coma.

arreglo1 = [10, 5, 3]                       # arreglo de enteros
arreglo2 = [1.78, 2.66, 1.55, 89,4]         # arreglo de valores flotantes
arreglo3 = ["lunes", "martes", "miercoles"] # arreglo de String
arreglo4 = ["juan", 45, 1.92]               # arreglo con elementos de distinto tipo

Si queremos imprimir un elemento en particular del arreglo debemos indicar entre corchetes cual elemento acceder:

arreglo1 = [10, 5, 3]                       # arreglo de enteros
puts arreglo1[0]                            # se imprime un 10

El primer elemento de un arreglo se encuentra en el subíndice cero.

Si llamamos a puts o print sin indicar un subíndice se muestra el arreglo en forma completo:

arreglo1 = [10, 5, 3]                       # arreglo de enteros
puts arreglo1

Si queremos conocer la cantidad de elementos de un arreglo podemos llamar al método length:

arreglo1 = [10, 5, 3]                       # arreglo de enteros
puts arreglo1.length                        # se imprime un 3

Problema 1:

Definir un arreglo que almacene 5 enteros. Sumar todos sus elementos y mostrar dicha suma.

Programa: ejercicio056.rb

arreglo = [10, 7, 3, 7, 2]
suma = 0
x = 0
while x < arreglo.length
  suma = suma + arreglo[x]
  x = x + 1
end
print "Los elementos del arreglo son:", arreglo, "\n"
print "La suma de todos sus elementos es:", suma

Si ejecutamos este programa tenemos la siguiente salida por pantalla:

Primero definimos un arreglo por asignación con 5 elementos:

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

Definimos un acumulador para sumar los elementos del arreglo y un contador para indicar que posición del arreglo accedemos:

suma = 0
x = 0

Mediante un ciclo while recorremos y sumamos cada elementos del arreglo:

while x < arreglo.length
  suma = suma + arreglo[x]
  x = x + 1
end

Mostramos los datos almacenados en el arreglo:

print "Los elementos del arreglo son:", arreglo, "\n"
print(lista)

Finalmente mostramos el acumulador:

print "La suma de todos sus elementos es:", suma

Problema 2:

Definir un arreglo por asignación que almacene los nombres de los primeros cuatro meses de año. Mostrar el primer y último elemento del arreglo.

Programa: ejercicio057.rb

meses = ["enero", "febrero", "marzo", "abril"]
puts meses[0]  # se muestra enero
puts meses[3]  # se muestra abril

Como queremos imprimir solo al primer y último elemento del arreglo indicamos entre corchetes la posición del elemento que queremos rescatar.

Si llamamos a puts y pasamos solo el nombre del arreglo luego se nos muestra todos los elementos:

  puts meses  # se muestra: enero, febrero, marzo, abril

Una característica importante en Ruby es que podemos disponer subíndices negativos en un arreglo, en dicho caso estamos indicando una posición recorriendo el Array desde el final:

puts meses[-1] # se imprime abril
puts meses[-2] # se imprime marzo

Problema 3:

Definir un arreglo por asignación que almacene en la primer componente el nombre de un alumno y en las dos siguientes sus notas. Imprimir luego el nombre y el promedio de las dos notas.

Programa: ejercicio058.rb

alumno = ["rodriguez ana", 7, 9]
puts "Nombre del alumno: #{alumno[0]}"
promedio = (alumno[1] + alumno[2]) / 2
puts "Promedio de sus dos notas:#{promedio}"

Como vemos en este problema los elementos de un arreglo pueden ser de distinto tipo, aquí tenemos el primer elemento de tipo String y los dos siguientes de tipo entero.

Podemos utilizar el concepto de interpolación de String que vimos anteriormente para mostrar tanto el nombre del alumno como el promedio de notas:

puts "Nombre del alumno: #{alumno[0]}"
promedio = (alumno[1] + alumno[2]) / 2
puts "Promedio de sus dos notas:#{promedio}"

Problemas propuestos

Definir por asignación un arreglo con 8 elementos enteros. Contar cuantos de dichos valores almacenan un valor superior a 100.
Definir un arreglo por asignación con 5 enteros. Mostrar por pantalla solo los elementos con valor iguales o superiores a 7.
Definir un arreglo que almacene por asignación los nombres de 5 personas. Contar cuantos de esos nombres tienen 5 o más caracteres.

Solución

ejercicio059.rb

arreglo = [1000, 6000, 400, 23, 130, 400, 60, 2000]
cantidad = 0
x = 0
while x < arreglo.length
  if arreglo[x] > 100
    cantidad = cantidad + 1
  end
  x = x + 1  
end 
print "El arreglo esta constituido por los elementos:", arreglo, "\n"
print "La cantidad de valores mayores a 100 en el arreglo son:", cantidad




ejercicio060.rb

arreglo = [8, 1, 9, 2, 10]
puts "Elementos del arreglo con valores iguales o superiores a 7"
x=0
while x < arreglo.length
  if arreglo[x] >= 7
    puts arreglo[x]
  end
  x = x + 1
end




ejercicio061.rb

nombres = ["juan", "ana", "marcos", "carlos", "luis"]
cantidad=0
x=0
while x < nombres.length
  if nombres[x].length >= 5
    cantidad = cantidad + 1
  end
  x = x + 1
end
puts "Todos los nombres son #{nombres}"
puts "Cantidad de nombres con 5 o mas caracteres: #{cantidad}"

Retornar

12 - Estructura de datos tipo Arreglo (Array)