Ordenar Array con Ruby

Este pequeño programa de 56 líneas de código ordena listas de mayor a menor o de menor a mayor, según la opción que elija el usuario. Una Array en Ruby es un contenedor de elementos no ordenados de tamaño flexible que puede tener cualquier tipo de datos, puede expandirse o reducirse en tiempo de ejecución cuando se agregan o se eliminan elementos.

Código fuente

#!/usr/bin/env ruby

arrs = []
tmp = 0

def ordenarMayor(arrs, cantidad)
  cantidad.times { |x|
    cantidad.times { |y|
      if arrs[x] > arrs[y]
        tmp = arrs[x]
        arrs[x] = arrs[y]
        arrs[y] = tmp
      end
    }
  }
  arrs
end

def ordenarMenor(arrs, cantidad)
  cantidad.times { |x|
    cantidad.times { |y|
      if arrs[x] < arrs[y]
        tmp = arrs[y]
        arrs[y] = arrs[x]
        arrs[x] = tmp
      end
    }
  }
  arrs
end

print "Ingrese la cantidad de valores a ordenar: "
cantidad = gets().to_i

1.step cantidad do |n|
  print "Ingrese el numero #{n}: "
  numero = gets().to_i
  arrs << numero
end

puts "\n" + """Selecciones una de las siguientes opciones 
#----------------------------------------#
1) Ordenar de menor a mayor
2) Ordenar de mayor a menor
#----------------------------------------#"""
print "Opcion: "
opt = gets().to_i

case opt
when 1
  arrs_orden = ordenarMenor(arrs, cantidad)
when 2
  arrs_orden = ordenarMayor(arrs, cantidad)
end

puts "\nArray ordenado: #{arrs_orden}"

Shebang #!/usr/bin/env ruby:

Los caracteres #! son conocidos como Shebang y son muy famosos en los sistemas tipo UNIX ya que permite ejecutar programas que requieren un intérprete, directamente sobre la línea de comandos sin necesidad de escribir el nombre del intérprete; por ejemplo, ./OrdenarListas.rb en lugar de $ruby OrdenarListas.rb.

Creando Array

arrs = Array.new

Este array va a contener los elemento que el usuario mismo ingrese para luego ser ordenados. Así de sencillo se crea un Array en Ruby, usando la clase Array y llamando al método new.

Creando variable auxiliar

tmp = 0

Esta variable se convertirá en auxiliar al momento de ordenar los elementos del array sosteniendo de forma temporal cada elemento y devolviéndole el elemento al array en otra posición.

Función ordenarMayor

def ordenarMayor(arrs, cantidad)
  cantidad.times { |x|
    cantidad.times { |y|
      if arrs[x] > arrs[y]
        tmp = arrs[x]
        arrs[x] = arrs[y]
        arrs[y] = tmp
      end
    }
  }
  arrs
end

La función ordenarMayor se encarga de ordenar el array de mayor a menor y devolver el resultado del proceso, recibe 2 argumentos, el primero es el array que deseamos ordenar y el segundo es la cantidad de elementos de dicho array.

Métodos .times {}, iterando n veces.

cantidad.times { |x|
  cantidad.times { |y|
    if arrs[x] > arrs[y]
      tmp = arrs[x]
      arrs[x] = arrs[y]
      arrs[y] = tmp
    end
  }
}

El bucle .times {} externo va a iterar N cantidad de veces empezando desde cero hasta el valor de la variable cantidad, pero sin incluir el último valor. El bucle .times {} interno va a realizar la misma iteración del bucle externo, pero se repite por cada elemento en la posición x; por ejemplo, si hay 5 elemento en la lista, el bucle interno va a iterar 5 veces por cada elemento elemento en el índice x, para un total de 25 iteraciones.

Sentencia if, comparando elementos

if arrs[x] > arrs[y]
    tmp = arrs[x]
    arrs[x] = arrs[y]
    arrs[y] = tmp
end

Esta sentencia if va a evaluar si cada uno de los elementos del array ubicado en el índice x es mayor que los elementos del array ubicado en el índice y, por eso el bucle interno va a iterar N cantidad de veces por cada elemento en el índice x (como se explicó anteriormente) con la intención de evaluar si es mayor al elemento en el índice y. Si la condición es true, se realizan una serie de asignaciones que se explican a continuación:

* tmp = listNum[x]: el elemento en el índice x es asignado a la variable tmp.

* listNum[x] = listNum[y]: el elemento ubicado en el índice y es asignado asignado en el índice x.

* listNum[y] = tmp: el elemento que había sido asignado a la variable tmp es asignado en el índice y.

Este pequeño proceso cambia de posición a los elementos, moviendo de índices a cada uno, para dejar a los números mayores al principio del array y dejado de últimas a los números menores.

Devolviendo el resultado

En la línea #11 la función ordenarMayor devuelve como resultado el Array ordenado, en Ruby no es obligatorio usar la sentencia return cuando devolvemos algún resultado tipo en las funciones.

Función ordenarMenor

def ordenarMenor(arrs, cantidad)
  cantidad.times { |x|
    cantidad.times { |y|
      if arrs[x] < arrs[y]
        tmp = arrs[y]
        arrs[y] = arrs[x]
        arrs[x] = tmp
      end
    }
  }
  arrs
end

Esta función tiene exactamente la misma estructura que la función ordenarMayor y de hecho funciona de la misma forma, solo hay un par de diferencias entre ambas que se encuentra en la sentencia if:

* La sentencia if de la función ordenarMayor evalúa si los elementos ubicados en el índice x son mayores que los elementos ubicados en el índice y; mientras que en la función ordenarMenor se evalúa si los elementos en el índice x son menores que los elementos en el índice y.

* En la función ordenarMayor la variable tmp toma el valor que hay en el índice x del array; mientra que en la función ordenarMenor la variable tmp toma el valor que hay en el índice y.

* En la función ordenarMayor el índice x del array toma el valor del índice y del array; mientras que en la función ordenarMenor el índice y toma el valor del índice x.

* En la función ordenarMayor el índice y del array toma el valor de la variable tmp; mientras que en la función ordenarMenor el índice x toma el valor de la variable tmp.

Solicitando cantidad y leyendo cantidad

print "Ingrese la cantidad de valores a ordenar: "
cantidad = gets().to_i

Le solicitamos al usuario que ingrese la cantidad de valores que desea ordenar usando la función print y luego leemos dicho valor usando el método gets() seguida por método .to_i para realizar la conversión a número entero.

Método .step {}, agregando elementos al Array

1.step cantidad do |n|
  print "Ingrese el numero #{n}: "
  numero = gets().to_i
  arrs << numero
end

Con el método .step vamos a ir iterando desde 1 hasta cantidad, mientras que le solicitamos al usuario que ingrese un número y le indicamos con la expresión #{n} el número del valor que está ingresando; por ejemplo, “Ingrese el número #4: “. Leemos el valor usando el método gets() seguida por método .to_i para realizar la conversión a número entero y lo almacenamos en la variable numero; por ultimo añadimos el valor al Array usando el operador de inserción “<<“.

Seleccionando opción y obteniendo el resultado

puts "\n" + """Selecciones una de las siguientes opciones 
#----------------------------------------#
1) Ordenar de menor a mayor
2) Ordenar de mayor a menor
#----------------------------------------#"""
print "Opcion: "
opt = gets().to_i

case opt
when 1
  arrs_orden = ordenarMenor(arrs, cantidad)
when 2
  arrs_orden = ordenarMayor(arrs, cantidad)
end

La función puts imprime un mensaje multilínea, al inicio aparece el carácter “\n” para dar un salto de línea antes de imprimir el mensaje. El resultado es el siguiente:

Selecciones una de las siguientes opciones 
#----------------------------------------#
1) Ordenar de menor a mayor
2) Ordenar de mayor a menor
#----------------------------------------#

Un pequeño menú que le indica al usuario que seleccione alguna de las dos opciones presentes, ingresar el número 1 si desea ordenar el array de menor a mayor o el número 2 si lo desea ordenar de mayor a menor.

Leyendo opción

print "Opcion: "
opt = gets().to_i

La función print solo imprime la palabra “Opción: “. Leemos la opción seleccionada usando el método gets(), después lo convertimos a tipo entero usando el método .to_i y lo almacenamos en la variable opt. La sentencia case evalúa el valor de la variable opt y la compara con sus 2 opciones en las sentencias when, sí coincide con alguna, llama a la función correspondiente con sus argumentos y almacena el resultado devuelto en la variable arrs_orden.

Mostrando resultado

puts "\nArray ordenado: #{arrs_orden}"

Por último mostramos el resultado, al Array ordenado según la opción seleccionada por el usuario. En Ruby no es necesario iterar sobre los arrays para mostrar su contenido, se pueden imprimir como cualquier otro valor.

Ejecutando el programa

Al ejecutar el programa nos da un resultado similar al siguiente:

[fixedtorres@linuxero]$ ./OrdenaArray.rb
Ingrese la cantidad de valores a ordenar: 5
Ingrese el numero 1: 123
Ingrese el numero 2: 328
Ingrese el numero 3: 19
Ingrese el numero 4: 48
Ingrese el numero 5: 27

Selecciones una de las siguientes opciones 
#----------------------------------------#
1) Ordenar de menor a mayor
2) Ordenar de mayor a menor
#----------------------------------------#
Opcion: 1

Array ordenado: [19, 27, 48, 123, 328]
[fixedtorres@linuxero]$