Mayores y menores de un conjunto de números en ANSI C

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 ANSI C. 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

La lectura de datos en ANSI C la realizaremos con la función \texttt{scanf}. Recuerde que para poder usar esta función, se debe incluir el archivo de cabecera \texttt{stdio.h} (Standard Input Output). Usaremos la variable \texttt{n} para leer el valor de un número del conjunto que se solicitará.

#include <stdio.h>

int main() {
    int n;
    
    printf("Ingrese número: ");
    scanf("%d", &n);
    return 0;
} 

Control de flujo para la lectura de varios números

Para leer el conjunto de números usaremos una estructura iterativa con salida controlada. En ANSI C se implementa mediante la instrucción \texttt{do-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.

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. 

#include <stdio.h>

int main() {
    int n;
    do {
        printf("Ingrese número: ");
        scanf("%d", &n);

        if (n >= 0) {            
            
        }
    }    while (n >= 0);    
    return 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 incremento \texttt{++}. \texttt{i++} equivale a \texttt{i=i+1}.

#include <stdio.h>

int main() {
    int n, i = 0;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);

        if (n >= 0) {
            i++;
            
        }
    }    while (n >= 0);    
    return 0;
} 

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}.

#include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);

        if (n >= 0) {
            i++;
            if (i == 1)
                mayor_magnitud = n;
            else {
                             
            }
        }
    }    while (n >= 0);    
    return 0;
} 

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.

#include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);

        if (n >= 0) {
            i++;
            if (i == 1)
                mayor_magnitud = n;
            else {
                if (n > mayor_magnitud)
                    mayor_magnitud = n;                
            }
        }
    }    while (n >= 0);    
    return 0;
} 

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}.

#include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud, menor_magnitud;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);

        if (n >= 0) {
            i++;
            if (i == 1)
                mayor_magnitud = menor_magnitud = n;
            else {
                if (n > mayor_magnitud)
                    mayor_magnitud = n;                
            }
        }
    }    while (n >= 0);    
    return 0;
} 

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.

#include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud, menor_magnitud;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);

        if (n >= 0) {
            i++;
            if (i == 1)
                mayor_magnitud = menor_magnitud = n;
            else {
                if (n > mayor_magnitud)
                    mayor_magnitud = n;
                if (n < menor_magnitud)
                    menor_magnitud = n;
            }
        }
    }    while (n >= 0);    
    return 0;
} 

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».

#include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud, menor_magnitud;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);

        if (n >= 0) {
            i++;
            if (i == 1)
                mayor_magnitud = menor_magnitud = n;
            else {
                if (n > mayor_magnitud)
                    mayor_magnitud = n;
                if (n < menor_magnitud)
                    menor_magnitud = n;
            }
        }
    }    while (n >= 0);
    if (i == 0)
        printf("No se ha ingresado ningún número\n");
    else {
        
    }
    return 0;
} 

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.

#include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud, menor_magnitud;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);

        if (n >= 0) {
            i++;
            if (i == 1)
                mayor_magnitud = menor_magnitud = n;
            else {
                if (n > mayor_magnitud)
                    mayor_magnitud = n;
                if (n < menor_magnitud)
                    menor_magnitud = n;
            }
        }
    }    while (n >= 0);
    if (i == 0)
        printf("No se ha ingresado ningún número\n");
    else {
        printf("El número con mayor magnitud es: %d\n", mayor_magnitud);
        printf("El número con menor magnitud es: %d\n", menor_magnitud);
    }
    return 0;
} 

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 (1)}. 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?

#include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud, menor_magnitud;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);

        if (n < 0)
            break;
        i++;
        if (i == 1)
            mayor_magnitud = menor_magnitud = n;
        else {
            if (n > mayor_magnitud)
                mayor_magnitud = n;
            if (n < menor_magnitud)
                menor_magnitud = n;
        }
    } while (1);
    if (i == 0)
        printf("No se ha ingresado ningún número\n");
    else {
        printf("El número con mayor magnitud es: %d\n", mayor_magnitud);
        printf("El número con menor magnitud es: %d\n", menor_magnitud);
    }
    return 0;
} 

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 ANSI C, el menor valor entero posible lo obtenemos con la constante simbólica \texttt{INT\_MIN}. El mayor entero posible lo obtenemos con la constante simbólica \texttt{INT\_MAX}.  Ambas constantes simbólicas se encuentran declaradas dentro del archivo de cabecera \texttt{limits.h}.

#include <stdio.h>
#include <limits.h>

int main() {
    int n, i = 0;
    int mayor_magnitud = INT_MIN;
    int menor_magnitud = INT_MAX;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);

        if (n < 0)
            break;
        i++;
        if (n > mayor_magnitud)
            mayor_magnitud = n;
        if (n < menor_magnitud)
            menor_magnitud = n;
    } while (1);
    if (i == 0)
        printf("No se ha ingresado ningún número\n");
    else {
        printf("El número con mayor magnitud es: %d\n", mayor_magnitud);
        printf("El número con menor magnitud es: %d\n", menor_magnitud);
    }
    return 0;
} 

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.

#include <stdio.h>

int main() {
    int n;
    do {
        printf("Ingrese número: ");
        scanf("%d", &n);
        
        if (n < 0)
            break;
        
    } while (1);    
    return 0;
} 

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.

#include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud1;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);
        
        if (n ﹤ 0)
            break;
        i++;
        if (i == 1)
            mayor_magnitud1 = n;
        else {
            
        }
    } while (1);    
    return 0;
} 

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}.

#include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud1;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);
        
        if (n < 0)
            break;
        i++;
        if (i == 1)
            mayor_magnitud1 = n;
        else {
            
        }
    } while (1);    
    return 0;
} 

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.
 
#include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud1, mayor_magnitud2;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);
        
        if (n < 0)
            break;
        i++;
        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;            
        }
    } while (1);    
    return 0;
} 

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\ ||\ 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:

#include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud1, mayor_magnitud2;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);
        
        if (n < 0)
            break;
        i++;
        if (i == 1)
            mayor_magnitud1 = n;
        else {
            if (i == 2 || n > mayor_magnitud1 || n > mayor_magnitud2)
                if (n > mayor_magnitud1) {
                    mayor_magnitud2 = mayor_magnitud1;
                    mayor_magnitud1 = n;
                } else
                    mayor_magnitud2 = n;            
        }
    } while (1);    
    return 0;
} 

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

#include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud1, mayor_magnitud2, menor_magnitud1;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);
        
        if (n < 0)
            break;
        i++;
        if (i == 1)
            mayor_magnitud1 = menor_magnitud1 = n;
        else {
            if (i == 2 || n > mayor_magnitud1 || n > mayor_magnitud2)
                if (n > mayor_magnitud1) {
                    mayor_magnitud2 = mayor_magnitud1;
                    mayor_magnitud1 = n;
                } else
                    mayor_magnitud2 = n;            
        }
    } while (1);    
    return 0;
} 

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.
#include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud1, mayor_magnitud2, menor_magnitud1, menor_magnitud2;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);
        
        if (n < 0)
            break;
        i++;
        if (i == 1)
            mayor_magnitud1 = menor_magnitud1 = n;
        else {
            if (i == 2 || n > mayor_magnitud1 || 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;
        }
    } while (1);    
    return 0;
} 

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\ ||\ 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:

#include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud1, mayor_magnitud2, menor_magnitud1, menor_magnitud2;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);
        
        if (n < 0)
            break;
        i++;
        if (i == 1)
            mayor_magnitud1 = menor_magnitud1 = n;
        else {
            if (i == 2 || n > mayor_magnitud1 || n > mayor_magnitud2)
                if (n > mayor_magnitud1) {
                    mayor_magnitud2 = mayor_magnitud1;
                    mayor_magnitud1 = n;
                } else
                    mayor_magnitud2 = n;
            if (i == 2 || n < menor_magnitud1 || n < menor_magnitud2)
                if (n ﹤ menor_magnitud1) {
                    menor_magnitud2 = menor_magnitud1;
                    menor_magnitud1 = n;
                } else
                    menor_magnitud2 = n;
        }
    } while (1);    
    return 0;
}
 

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».

 #include <stdio.h>

int main() {
    int n, i = 0, mayor_magnitud1, mayor_magnitud2, menor_magnitud1, menor_magnitud2;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);
        
        if (n < 0)
            break;
        i++;
        if (i == 1)
            mayor_magnitud1 = menor_magnitud1 = n;
        else {
            if (i == 2 || n > mayor_magnitud1 || n > mayor_magnitud2)
                if (n > mayor_magnitud1) {
                    mayor_magnitud2 = mayor_magnitud1;
                    mayor_magnitud1 = n;
                } else
                    mayor_magnitud2 = n;
            if (i == 2 || n < menor_magnitud1 || n < menor_magnitud2)
                if (n ﹤ menor_magnitud1) {
                    menor_magnitud2 = menor_magnitud1;
                    menor_magnitud1 = n;
                } else
                    menor_magnitud2 = n;
        }
    } while (1);
    if (i == 0)
        printf("No se ha ingresado ningún número\n");
    else {

    }
    return 0;
} 

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}.

 #include <stdio.h> 

int main() {
    int n, i = 0, mayor_magnitud1, mayor_magnitud2, menor_magnitud1, menor_magnitud2;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);
        
        if (n < 0)
            break;
        i++;
        if (i == 1)
            mayor_magnitud1 = menor_magnitud1 = n;
        else {
            if (i == 2 || n > mayor_magnitud1 || n > mayor_magnitud2)
                if (n > mayor_magnitud1) {
                    mayor_magnitud2 = mayor_magnitud1;
                    mayor_magnitud1 = n;
                } else
                    mayor_magnitud2 = n;
            if (i == 2 || n < menor_magnitud1 || n < menor_magnitud2)
                if (n < menor_magnitud1) {
                    menor_magnitud2 = menor_magnitud1;
                    menor_magnitud1 = n;
                } else
                    menor_magnitud2 = n;
        }
    } while (1);
    if (i == 0)
        printf("No se ha ingresado ningún número\n");
    else {
        printf("El 1er número con mayor magnitud es: %d\n", mayor_magnitud1);
        if (i > 1)
            printf("El 2do número con mayor magnitud es: %d\n", mayor_magnitud2);
        printf("El 1er número con menor magnitud es: %d\n", menor_magnitud1);
        if (i > 1)
            printf("El 2do número con menor magnitud es: %d\n", menor_magnitud2);
    }
    return 0;
} 

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 ANSI C, el menor valor entero posible lo obtenemos con la constante simbólica \texttt{INT\_MIN}. El mayor entero posible lo obtenemos con la constante simbólica \texttt{INT\_MAX}.  Ambas constantes simbólicas se encuentran declaradas dentro del archivo de cabecera \texttt{limits.h}.

#include <stdio.h>
#include <limits.h>

int main() {
    int n, i = 0, mayor_magnitud1, mayor_magnitud2, menor_magnitud1, menor_magnitud2;
    mayor_magnitud1 = mayor_magnitud2 = INT_MIN;
    menor_magnitud1 = menor_magnitud2 = INT_MAX;
    do {
        printf("Ingrese número %d: ", i + 1);
        scanf("%d", &n);

        if (n < 0)
            break;
        i++;
        if (n > mayor_magnitud1 || n > mayor_magnitud2)
            if (n > mayor_magnitud1) {
                mayor_magnitud2 = mayor_magnitud1;
                mayor_magnitud1 = n;
            } else
                mayor_magnitud2 = n;
        if (n < menor_magnitud1 || n < menor_magnitud2)
            if (n < menor_magnitud1) {
                menor_magnitud2 = menor_magnitud1;
                menor_magnitud1 = n;
            } else
                menor_magnitud2 = n;
    } while (1);
    if (i == 0)
        printf("No se ha ingresado ningún número\n");
    else {
        printf("El 1er número con mayor magnitud es: %d\n", mayor_magnitud1);
        if (i > 1)
            printf("El 2do número con mayor magnitud es: %d\n", mayor_magnitud2);
        printf("El 1er número con menor magnitud es: %d\n", menor_magnitud1);
        if (i > 1)
            printf("El 2do número con menor magnitud es: %d\n", menor_magnitud2);
    }
    return 0;
} 

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 quieres profundizar en el lenguaje ANSI C, no hay mejor libro que C Programming Language de Brian Kernighan  y Dennis Ritchie. Es un libro clásico escrito por el creador del lenguaje C. Uno de los libros favoritos de los que inician en ANSI C es  C Programming Absolute Beginner’s Guide de Greg Perry y Dean Miller.

Deja una respuesta

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