Comment trouver le deuxième nombre minimum sans utiliser de tableaux ou de boucles ?

Question

J'ai essayé d'écrire un programme qui reçoit de l'utilisateur 5 entiers et d'imprimer le deuxième nombre minimum.
Voici un échantillon de ce que j'ai essayé :

#include <iostream>
using namespace std;
int main () {
int a,b,c,d,e;
cin>>a>>b>>c>>d>>e;
if (a>b && a<c && a<d && a<e)
    cout<<a<<endl;
if (b>a && b<c && b<d && b<e)
    cout<<b<<endl;
if (c>a && c<b && c<d && c<e)
    cout<<c<<endl;
if (d>a && d<b && d<c && d<e)
    cout <<d<<endl;
if (e>a && e<b && e<c && e<d)
cout <<e<<endl;
return 0;

}

Quand j'entre 1 2 3 4 5 il imprime le deuxième minimum, mais quand je saisis
5 4 3 2 1 Rien ne s'imprime à l'écran. Qu'est-ce qui ne va pas dans ce cas ? Existe-t-il une autre façon d'écrire mon programme ?

Answer 1

Mise à jour Dans cette solution, j'utilise le min fonction :

#include <iostream>
using namespace std;

int minDifferentFromFirstMin(int x, int y, int firstMin) {
    if(x < y) {
        if(x != firstMin) {
            return x;
        }
        else {
            return y;
         }
    }

    if(y < x) {
        if(y != firstMin) {
            return y;
        }
        else {
            return x;
         }
    }
    //if x & y are equals, return one of them
    return x;
}

int main () {
 int a,b,c,d,e;
 int iter11, iter12, iter13;
 int iter21, iter22, iter23;
 int firstMinimum, secondMinimum;
 cin>>a>>b>>c>>d>>e;

 //iteration 1: find the first minimum
 iter11 = min(a, b);
 iter12 = min(c, d);
 iter13 = min(iter11, iter12);
 firstMinimum = min(iter13, e);

 //iteration 2: find the second minimum
 iter21 = minDifferentFromFirstMin(a, b, firstMinimum);
 iter22 = minDifferentFromFirstMin(c, d, firstMinimum);
 iter23 = minDifferentFromFirstMin(iter21, iter22, firstMinimum);
 secondMinimum = minDifferentFromFirstMin(iter23, e, firstMinimum);

 cout<<secondMinimum<<endl;
}

Answer 2

Une approche consiste à trouver d'abord le nombre minimum, min et ensuite trouver la plus petite valeur qui n'est pas min . Pour ce faire, il faut d'abord trouver la valeur minimale :

int min = std::min(a, std::min(b, std::min(c, std::min(d, e))));

Maintenant nous devons refaire la même chose, mais en ignorant min . Nous pouvons le faire en utilisant une fonction appelée triMin qui prend 3 valeurs et rejette toute valeur qui est le minimum :

int triMin(int currentMin, int left, int right)
{
    if(currentMin == left) return right;
    if(currentMin == right) return left;

    return std::min(left, right);
}

Vous pouvez maintenant les combiner pour obtenir la réponse :

int a = 5, b = 4, c = 3, d = 2, e = 1;

int min = std::min(a, std::min(b, std::min(c, std::min(d, e))));
int min2 = triMin(min, a, triMin(min, b, triMin(min, c, triMin(min, d, e))));

std::cout << "Second min = " << min2 << std::endl;

Cette impression 2

Answer 3

Cette tâche peut être accomplie en utilisant un seul passage algorithme. Il n'est pas nécessaire d'utiliser des collections (tableaux, ensembles ou autres).
Cet algorithme en un seul passage est économe en mémoire - il ne nécessite pas de stocker tous les éléments dans la collection (et de gaspiller de la mémoire) et fonctionnera même avec un grand nombre d'éléments lorsque les autres solutions échouent faute de mémoire.
L'idée générale de cet algorithme est la suivante :

• prenez chaque numéro dans l'ordre
• vous avez besoin de deux variables pour stocker minimum y second minimum de tous les numéros déjà vus.
• quand vous obtenez le numéro vous devez le tester avec du courant minumum pour savoir si c'est un nouveau nombre minimum.
  • si c'est le cas, enregistrez-le comme minimum stocker l'ancien minimum dans second minimum numéro
• sinon, vérifiez si elle est inférieure à second minimum numéro.
  • si c'est le cas, enregistrez-le comme second minimum numéro.
• maintenant second minimum Le numéro contient la réponse à tous les numéros déjà vus.
• répéter pendant qu'il y a des numéros qui n'ont pas été vus.

Après avoir étudié tous les numéros second minimum contiennent la réponse.
Voici l'implémentation avec c++17 ( lien vers wandbox ):

#include <iostream>
#include <optional>

int main()
{
    int a, b, c, d, e;
    std::cin >> a >> b >> c >> d >> e;

    // you can find second minimal number while going through each number once
    auto find_current_answer = [minimum = std::optional<int>{}, next_to_minimum = std::optional<int>{}](int next) mutable {
        // when receiving next number
        // 1. check if it is new minimum
        if (!minimum || minimum > next) {
            // move values like this: next_to_minimum <- minimum <- next
            next_to_minimum = std::exchange(minimum, next);
        }
        // 2. else check if it is new next_to_minimum
        else if (!next_to_minimum || next_to_minimum > next) {
            next_to_minimum = next;
        }
        // 3. return current answer
        return next_to_minimum;
    };

    // repeat as much as you like
    find_current_answer(a);
    find_current_answer(b);
    find_current_answer(c);
    find_current_answer(d);
    // store answer that is interesting to you
    auto result = find_current_answer(e);

    // if it has value - it is the answer
    if (result) {
        std::cout << "Answer: " << *result << '\n';
    }
    else {
        std::cout << "Not enough numbers!\n";
    }
}