Mayores y menores de un conjunto de números en Python

Más ejercicios resueltos

Si deseas revisar más ejercicios resueltos, haz click en el siguiente botón. 

A continuación presentamos 2 alternativas de solución al problema de encontrar los mayores y menores números en un conjunto de números naturales en Python. Si deseas ver el enunciado del problema, haz click en el siguiente enlace. Si deseas entender el diseño algorítmico detrás de las soluciones presentadas, le invitamos a visitar el siguiente enlace.

Lectura de un número

Para la lectura de datos en Python usaremos la función \texttt{input}. Usaremos la variable \texttt{n} para leer el valor de un número del conjunto que se solicitará. Usamos la función \texttt{int} para transformar la cadena de caracteres en un entero. 

n=int(input("Ingrese número: ")) 

Control de flujo para la lectura de varios números

Para leer el conjunto de números usaremos una estructura iterativa con entrada controlada. En Python se implementa mediante la instrucción \texttt{while}. Se utilizará un control por centinela usando la condición \texttt{n>=0}. Esto hará que se repita la iteración mientras el valor de \texttt{n} sea mayor o igual que cero. Como se hace un control en la entrada, la variable \texttt{n} debe ser inicializada con un valor diferente al centinela para que se realice la iteración por lo menos una vez. En este ejercicio, la hemos inicializado con \texttt{0}.

Noten en el fragmento de código siguiente que la lectura de datos se ha colocado dentro de la iteración. Esto es importante hacerlo pues sino no podríamos leer varios números. Además, dentro de la iteración se ha colocado una selectiva simple para filtrar valores válidos y dejar de lado al centinela. Esto pues el centinela será leído y verificado en la salida. 

n=0
while n >= 0:
    n=int(input("Ingrese número: "))
    if n >= 0:         

Numeración de los números leídos

Dado que uno de los algoritmos a usar se basa en la identificación del primer número leído, vamos a proceder a identificarlos. Usaremos la variable \texttt{i} para dicho fin. Inicializamos la variable \texttt{i} con el valor de \texttt{0} y la incrementaremos apenas se verifique que el valor leído es un número «válido», es decir no es un centinela. Para el incremento usamos la operación de asignación \texttt{+=}. \texttt{i+=1} equivale a \texttt{i=i+1}.

i=0
n=0
while n >= 0:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n >= 0:
        i+=1 

Inicialización del mayor

El valor del número con mayor valor lo almacenaremos en la variable \texttt{mayor\_magnitud}. El valor inicial que le asignaremos a esta variable será el primer número leído. Para esto usamos la variable \texttt{i} descrita previamente en la condición de una selectiva doble. Para saber si es el primer número usaremos la condición \texttt{i==1}.

i=0
n=0
while n >= 0:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n >= 0:
        i+=1
        if i == 1:
            mayor_magnitud = n
        else:
            if n > mayor_magnitud:
                mayor_magnitud = n 

Actualización del mayor

En este paso realizaremos la actualización de la variable \texttt{mayor\_magnitud}. La actualizamos con el valor de \texttt{n} si es que se cumple que \texttt{n>mayor\_magnitud}. Esta operación es excluyente con la inicialización. La inicialización se hace cuando se lee el primer número, la actualización se evalúa desde el segundo número en adelante.

i=0
n=0
while n >= 0:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n >= 0:
        i+=1
        if i == 1:
            mayor_magnitud = n
        else:
            if n > mayor_magnitud:
                mayor_magnitud = n
 

Inicialización del menor

El valor del número con menor valor lo almacenaremos en la variable \texttt{menor\_magnitud}. El valor inicial que le asignaremos a esta variable será el primer número leído. En este caso en particular, hemos usado la asignación múltiple. Esto permite asignar un mismo valor a varias variables en una sola instrucción. La instrucción \texttt{mayor\_magnitud = menor\_magnitud = n}, asigna el valor de la varible \texttt{n} tanto a \texttt{mayor\_magnitud} como a \texttt{menor\_magnitud}.

i=0
n=0
while n >= 0:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n >= 0:
        i+=1
        if i == 1:
            mayor_magnitud = menor_magnitud = n
        else:
            if n > mayor_magnitud:
                mayor_magnitud = n 

Actualización del menor

Ahora procederemos a realizar la actualización de la variable \texttt{menor\_magnitud}. La actualizamos con el valor de \texttt{n} si es que se cumple que \texttt{n<menor\_magnitud}. Para esto usamos otra selectiva simple.

i=0
n=0
while n >= 0:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n >= 0:
        i+=1
        if i == 1:
            mayor_magnitud = menor_magnitud = n
        else:
            if n > mayor_magnitud:
                mayor_magnitud = n
            if n < menor_magnitud:
                menor_magnitud = n
 

Verificación de ingreso de números

Antes de realizar la impresión de los resultados encontrados, debemos verificar si el usuario ha ingresado números. Para esto nos valemos nuevamente de la variable \texttt{i}. Si \texttt{i} contiene el valor de \texttt{0}, significa que no se han leído números «válidos».

i=0
n=0
while n >= 0:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n >= 0:
        i+=1
        if i == 1:
            mayor_magnitud = menor_magnitud = n
        else:
            if n > mayor_magnitud:
                mayor_magnitud = n
            if n < menor_magnitud:
                menor_magnitud = n
if i == 0:
    print("No se ha ingresado ningún número");
else:
 

Impresión del mayor y del menor

Finalmente se procede a la impresión de los valores hallados. Esto lo haremos si y solo si, la variable \texttt{i} es mayor que cero.

i=0
n=0
while n >= 0:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n >= 0:
        i+=1
        if i == 1:
            mayor_magnitud = menor_magnitud = n
        else:
            if n > mayor_magnitud:
                mayor_magnitud = n
            if n < menor_magnitud:
                menor_magnitud = n
if i == 0:
    print("No se ha ingresado ningún número");
else:
    print("El número con mayor magnitud es: {:d}".format(mayor_magnitud))
    print("El número con menor magnitud es: {:d}".format(menor_magnitud)) 

Versión usando break

Cuando utilizamos un ciclo iterativo controlado por un centinela, comúnmente se suele utilizar la instrucción de ruptura de ciclo \texttt{break} para facilitar la lectura del código. 

¿Qué cambios se han realizado? Bueno, en lugar de colocar todo el código dentro de un bloque de una selectiva simple, este se coloca fuera del \texttt{if}. Se usa la selectiva simple para romper el flujo haciendo un \texttt{break}. El \texttt{break} hace que la instrucción iterativa termine. Esta será la forma de salir de la iteración, cuando \texttt{n<0}, se ejecuta el \texttt{break}. Además, dado que solo se saldrá por la ruptura del ciclo, deja de tener relevancia la condición de la iterativa, por este motivo dejamos el control en la salida como \texttt{while (True)}. Es decir, un ciclo infinito.

¿Te parece más fácil de leer esta versión? o ¿crees que la versión anterior es más fácil de entender?

i=0
while True:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n < 0:
        break
    i+=1
    if i == 1:
        mayor_magnitud = menor_magnitud = n
    else:
        if n > mayor_magnitud:
            mayor_magnitud = n
        if n < menor_magnitud:
            menor_magnitud = n
if i == 0:
    print("No se ha ingresado ningún número");
else:
    print("El número con mayor magnitud es: {:d}".format(mayor_magnitud))
    print("El número con menor magnitud es: {:d}".format(menor_magnitud)) 

Versión inicializando máximos y mínimos

Veremos ahora otra versión del mismo algoritmo. En la versión presentada anteriormente, las variables \texttt{mayor\_magnitud} y \texttt{menor\_magnitud} han sido inicializadas con el primer número leído. En la versión que presentamos en esta sección hemos realizado un cambio en la inicialización. Se está inicializando las variables \texttt{mayor\_magnitud} y \texttt{menor\_magnitud} antes de realizar la iteración.

¿Con qué valor inicializamos estas variables?  \texttt{mayor\_magnitud} vamos a inicializarlo con el menor entero posible, mientras que \texttt{menor\_magnitud} vamos a inicializarlo con el mayor entero posible. De esta forma se garantiza que cuando se haga la comparación, en la primera iteración se tendrá el valor requerido. 

En Pyton, el menor valor entero posible lo obtenemos con la constante \texttt{-inf}. El mayor entero posible lo obtenemos con la constante \texttt{inf}.  Ambas constantes se encuentran definidos dentro de la librería \texttt{math}.

import math
i=0
mayor_magnitud = -math.inf
menor_magnitud = math.inf
while True:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n < 0:
        break
    i+=1
    if n > mayor_magnitud:
        mayor_magnitud = n
    if n < menor_magnitud:
         menor_magnitud = n
if i == 0:
    print("No se ha ingresado ningún número");
else:
    print("El número con mayor magnitud es: {:d}".format(mayor_magnitud))
    print("El número con menor magnitud es: {:d}".format(menor_magnitud)) 

Resolución de problemas: caso dos mayores y dos menores

Control de flujo para la lectura de varios números

Procederemos ahora a resolver a encontrar los dos mayores y los dos menores números de la lista. Iniciamos con el control de flujo para la lectura de varios números. Esta parte es exactamente igual al caso anterior.

while True:
    n=int(input("Ingrese número: "))
    if n < 0:
        break 

Numeración de los números leídos

La numeración de los números leídos sigue la misma lógica presentada en el ejercicio anterior. Seguiremos usando la variable \texttt{i} para lograr dicho objetivo.

i=0
while True:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n < 0:
        break
    i+=1 

Inicialización del primer mayor

Procederemos ahora con la inicialización de las variables. La lógica a usar será similar al caso anterior con la diferencia que ahora tendremos dos variables, una para el número con mayor magnitud y otra para el segundo número con mayor magnitud. 

Usaremos la variable \texttt{mayor\_magnitud1} para almacenar el mayor número de todos los de la lista. Inicializamos este variable con el primer número leído. Como hicimos en el programa anterior, usamos una instrucción selectiva verificando la condición \texttt{i=1}.

i=0
while True:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n < 0:
        break
    i+=1
    if i == 1:
        mayor_magnitud1 = n
    else: 

 

Inicialización del segundo mayor

Procederemos ahora a inicializar el segundo mayor. Usaremos la variable \texttt{mayor\_magnitud2} para almacenar el segundo mayor número de todos los de la lista.

La inicialización no es tan sencilla como en el caso del primer mayor porque pueden existir dos situaciones:

  1.  Que el segundo número sea mayor que el primero leído. En este caso, la variable \texttt{mayor\_magnitud2} se inicializa con el valor de \texttt{mayor\_magnitud1} pues por la condición antes descrita este es el segundo mayor. La variable \texttt{mayor\_magnitud1} se actualiza con el valor del número \texttt{n} que se acaba de leer para que siempre contenga el mayor de todos. 
  2. Que el segundo número sea menor o igual que el primero leído. Este caso es más simple de tratar, basta con inicializar \texttt{mayor\_magnitud2} con el valor de \texttt{n}. Es el segundo número y si no es mayor que el primero, entonces no queda otra que sea el segundo mayor.
i=0
while True:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n < 0:
        break
    i+=1
    if i == 1:
        mayor_magnitud1 = n
    else:
        if i == 2:
            if n > mayor_magnitud1:
                mayor_magnitud2 = mayor_magnitud1
                mayor_magnitud1 = n
            else:
                mayor_magnitud2 = n 

Actualización de mayores

Procedemos ahora a mantener actualizados los dos mayores conforme se vayan leyendo los números. A partir del tercer número leído en adelante, verificamos si el número leído es mayor que alguno de los anteriores para proceder con la respectiva actualización. Deberemos hacer una actualización si es que el número leído \texttt{n} es mayor que los dos mayores conocidos. Para esto usamos la condición \texttt{n>mayor\_magnitud1\ or\ n>mayor\_magnitud2}. Si esta condición se cumple, deberemos actualizar una o las dos variables.

Si el valor leído es mayor que \texttt{mayor\_magnitud1}, en este caso debemos actualizar \texttt{mayor\_magnitud2} con el valor de \texttt{mayor\_magnitud1} y \texttt{mayor\_magnitud1} con el valor de \texttt{n}. Si el valor leído solo es mayor que \texttt{mayor\_magnitud2}, en este caso debemos actualizar únicamente \texttt{mayor\_magnitud2} con \texttt{n}.

La lógica a usar en esta actualización es la misma usada que en la inicialización del segundo mayor, por lo que la lógica descrita anteriormente se puede expresar como sigue:

i=0
while True:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n < 0:
        break
    i+=1
    if i == 1:
        mayor_magnitud1 = n
    else:
        if i == 2 or n > mayor_magnitud1 or n > mayor_magnitud2:
            if n > mayor_magnitud1:
                mayor_magnitud2 = mayor_magnitud1
                mayor_magnitud1 = n
            else:
                mayor_magnitud2 = n 

Inicialización del primer menor

El valor del número con menor valor lo almacenaremos en la variable \texttt{menor\_magnitud1}. El valor inicial que le asignaremos a esta variable será el primer número leído. En este caso en particular, hemos usado nuevamente la asignación múltiple

i=0
while True:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n < 0:
        break
    i+=1
    if i == 1:
        mayor_magnitud1 = menor_magnitud1 = n
    else:
        if i == 2 or n > mayor_magnitud1 or n > mayor_magnitud2:
            if n > mayor_magnitud1:
                mayor_magnitud2 = mayor_magnitud1
                mayor_magnitud1 = n
            else:
                mayor_magnitud2 = n 

Inicialización del segundo menor

Procederemos ahora a inicializar el segundo menor. Usaremos la variable \texttt{menor\_magnitud2} para almacenar el segundo menor número de todos los de la lista.

La inicialización no es tan sencilla como en el caso del primer mayor porque pueden existir dos situaciones:

  1.  Que el segundo número sea menor que el primero leído. En este caso, la variable \texttt{menor\_magnitud2} se inicializa con el valor de \texttt{menor\_magnitud1} pues por la condición antes descrita este es el segundo mayor. La variable \texttt{menor\_magnitud1} se actualiza con el valor del número \texttt{n} que se acaba de leer para que siempre contenga el mayor de todos. 
  2. Que el segundo número sea mayor o igual que el primero leído. Este caso es más simple de tratar, basta con inicializar \texttt{menor\_magnitud2} con el valor de \texttt{n}. Es el segundo número y si no es menor que el primero, entonces no queda otra que sea el segundo mayor.
i=0
while True:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n < 0:
        break
    i+=1
    if i == 1:
        mayor_magnitud1 = menor_magnitud1 = n
    else:
        if i == 2 or n > mayor_magnitud1 or n > mayor_magnitud2:
            if n > mayor_magnitud1:
                mayor_magnitud2 = mayor_magnitud1
                mayor_magnitud1 = n
            else:
                mayor_magnitud2 = n
        if i == 2:
            if n < menor_magnitud1:
                menor_magnitud2 = menor_magnitud1
                menor_magnitud1 = n
            else:
                 menor_magnitud2 = n 

Actualización de menores

Procedemos ahora a mantener actualizados los dos menores conforme se vayan leyendo los números. A partir del tercer número leído en adelante, verificamos si el número leído es menor que alguno de los anteriores para proceder con la respectiva actualización. Deberemos hacer una actualización si es que el número leído \texttt{n} es menor que los dos menores conocidos. Para esto usamos la condición \texttt{n<menor\_magnitud1\ or\ n<menor\_magnitud2}. Si esta condición se cumple, deberemos actualizar una o las dos variables.

Si el valor leído es menor que \texttt{menor\_magnitud1}, en este caso debemos actualizar \texttt{menor\_magnitud2} con el valor de \texttt{menor\_magnitud1} y \texttt{menor\_magnitud1} con el valor de \texttt{n}. Si el valor leído solo es mayor que \texttt{menor\_magnitud2}, en este caso debemos actualizar únicamente \texttt{menor\_magnitud2} con \texttt{n}.

La lógica a usar en esta actualización es la misma usada que en la inicialización del segundo menor, por lo que la lógica descrita anteriormente se puede expresar como sigue:

i=0
while True:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n < 0:
        break
    i+=1
    if i == 1:
        mayor_magnitud1 = menor_magnitud1 = n
    else:
        if i == 2 or n > mayor_magnitud1 or n > mayor_magnitud2:
            if n > mayor_magnitud1:
                mayor_magnitud2 = mayor_magnitud1
                mayor_magnitud1 = n
            else:
                mayor_magnitud2 = n
        if i == 2 or n < menor_magnitud1 or n < menor_magnitud2:
            if n < menor_magnitud1:
                menor_magnitud2 = menor_magnitud1
                menor_magnitud1 = n
            else:
                 menor_magnitud2 = n 

Verificación de ingreso de números

Antes de realizar la impresión de los resultados encontrados, debemos verificar si el usuario ha ingresado números. Para esto nos valemos nuevamente de la variable \texttt{i}. Si \texttt{i} contiene el valor de \texttt{0}, significa que no se han leído números «válidos».

i=0
while True:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n < 0:
        break
    i+=1
    if i == 1:
        mayor_magnitud1 = menor_magnitud1 = n
    else:
        if i == 2 or n > mayor_magnitud1 or n > mayor_magnitud2:
            if n > mayor_magnitud1:
                mayor_magnitud2 = mayor_magnitud1
                mayor_magnitud1 = n
            else:
                mayor_magnitud2 = n
        if i == 2 or n < menor_magnitud1 or n < menor_magnitud2:
            if n < menor_magnitud1:
                menor_magnitud2 = menor_magnitud1
                menor_magnitud1 = n
            else:
                 menor_magnitud2 = n
if i == 0:
    print("No se ha ingresado ningún número");
else: 

 

Impresión de los mayores y de los menores

Finalmente se procede a la impresión de los valores hallados. Esto lo haremos si y solo si, la variable \texttt{i} es mayor que cero. Pero a diferencia del ejercicio anterior, puede darse el caso que existe un solo mayor o un solo menor. Esto se va dar cuando el usuario ha ingresado un único valor.

Por este motivo, antes de imprimir el segundo mayor o el segundo menor, debemos de verificar si es que se han leído por lo menos dos número. Esto lo verificamos fácilmente con la condición \texttt{i>=2}.

i=0
while True:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n < 0:
        break
    i+=1
    if i == 1:
        mayor_magnitud1 = menor_magnitud1 = n
    else:
        if i == 2 or n > mayor_magnitud1 or n > mayor_magnitud2:
            if n > mayor_magnitud1:
                mayor_magnitud2 = mayor_magnitud1
                mayor_magnitud1 = n
            else:
                mayor_magnitud2 = n
        if i == 2 or n < menor_magnitud1 or n < menor_magnitud2:
            if n < menor_magnitud1:
                menor_magnitud2 = menor_magnitud1
                menor_magnitud1 = n
            else:
                 menor_magnitud2 = n
if i == 0:
    print("No se ha ingresado ningún número");
else:
    print("El 1er número con mayor magnitud es: {:d}".format(mayor_magnitud1))
    if i >1:
        print("El 2do número con mayor magnitud es: {:d}".format(mayor_magnitud2))    
    print("El 1er número con menor magnitud es: {:d}".format(menor_magnitud1))
    if i >1:
        print("El 2do número con menor magnitud es: {:d}".format(menor_magnitud2)) 

Versión inicializando máximos y mínimos

Este problema también se puede resolver inicializando las variables de los mayores y menores con los valores mínimos y máximos respectivamente. Recuerde que en Pyton, el menor valor entero posible lo obtenemos con la constante \texttt{-inf}. El mayor entero posible lo obtenemos con la constante \texttt{inf}.  Ambas constantes se encuentran definidos dentro de la librería \texttt{math}.

import math
i=0
mayor_magnitud1 = mayor_magnitud2 = -math.inf
menor_magnitud1 = menor_magnitud2 = math.inf
while True:
    n=int(input("Ingrese número {:d}: ".format(i+1)))
    if n < 0:
        break
    i+=1
    if i == 2 or n > mayor_magnitud1 or n > mayor_magnitud2:
        if n > mayor_magnitud1:
            mayor_magnitud2 = mayor_magnitud1
            mayor_magnitud1 = n
        else:
            mayor_magnitud2 = n
    if i == 2 or n < menor_magnitud1 or n < menor_magnitud2:
        if n < menor_magnitud1:
            menor_magnitud2 = menor_magnitud1
            menor_magnitud1 = n
        else:
            menor_magnitud2 = n
if i == 0:
    print("No se ha ingresado ningún número");
else:
    print("El 1er número con mayor magnitud es: {:d}".format(mayor_magnitud1))
    if i >1:
        print("El 2do número con mayor magnitud es: {:d}".format(mayor_magnitud2))    
    print("El 1er número con menor magnitud es: {:d}".format(menor_magnitud1))
    if i >1:
        print("El 2do número con menor magnitud es: {:d}".format(menor_magnitud2)) 

Conclusión

Hemos presentado en este artículo, propuestas de solución para la determinación de los mayores y menores números de un conjunto de números naturales. Se ha utilizado para el control de flujo la estructura iterativa y muchas decisiones usando estructuras selectivas. Podrá descargar la solución propuesta en el repositorio GitHub de iterando++ a través del siguiente enlace

Hemos preparado otros artículos adicionales en donde describimos al detalle la implementación de este problema en PSeInt y otros lenguajes de programación. Te invitamos a leer los siguientes artículos de iterando++

Si te interesa profundizar más en el desarrollo en Python, los dos mejores libros que se han escrito son Learning Python de Mark Lutz y Python Crash Course de Eric Matthes.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *