Forum Programmation.c++ Fonction standard : vérifier si des entiers sont consécutif.

Posté par  (site web personnel) . Licence CC By‑SA.
Étiquettes :
-1
20
déc.
2021

Bonjour,
je cherche à savoir si il existe une fonction standard qui vérifie que les int d'un conteneur sont consécutif ? J'ai cherché mais pas trouver (peut être mal cherché…)
En attendant j'utilise ce bout de code qui marche, à la condition que les entiers soient non signés.

const std::vector vector_{1,5,3,9,8,2,4,6,7};
const auto count_ = vector_.size();
const auto min_max = std::minmax_element(vector_.begin(), vector_.end());
if ((*min_max.second - *min_max.first) + 1 != count_) {
    return false;
} else {
    return true;
}

Merci.

  • # Commentaire supprimé

    Posté par  . Évalué à 3.

    Ce commentaire a été supprimé par l’équipe de modération.

  • # adjacent_difference dans algorithm

    Posté par  (site web personnel) . Évalué à 4.

    https://en.cppreference.com/w/cpp/algorithm/adjacent_difference permet de calculer la différence entre les éléments consécutifs d'un vecteur.
    Si au moins un élément du vecteur ne vaut pas 1, alors les éléments ne sont pas consécutifs.

  • # trier ou ne pas trier

    Posté par  . Évalué à 1.

    Tu ne précises pas si la liste doit être ordonnée ou s'ils doivent être consécutifs après ordonnancement.
    Ils sont consécutifs si et seulement si ils sont triés (ou après les avoir triés) et l'écart entre les extrêmes est le nombre d'éléments.

    bool consecutive =  vector_.empty()
                 || (   std::is_sorted(vector_.begin(), vector_.end())
                     && vector_.size() == vector_.back()-vector_.front()+1u);

    Dans le second cas, le plus simple me semble être de les trier

    std::sort(vector_.begin(), vector_.end());
bool consecutive =  vector_.empty()
                 || vector_.size() == vector_.back()-vector_.front()+1u;

    Mais si tu les présuppose uniques, ta solution est plutôt bonne et marche aussi pour des entiers signés en forçant une comparaison non signée : (*min_max.second - *min_max.first) + 1u != count_).

  • # pistes

    Posté par  (site web personnel, Mastodon) . Évalué à 2.

    J'ai cherché mais pas trouver (peut être mal cherché…)

    https://www.techiedelight.com/check-array-formed-consecutive-integers/ propose 2 méthodes ;
    https://www.geeksforgeeks.org/check-if-array-elements-are-consecutive/ propose 3 approches ;
    https://tutorialspoint.dev/data-structure/stack-data-structure/check-if-stack-elements-are-pairwise-consecutive si on veut utiliser une pile ;

    etc. Par contre pas de fonction standard qui fasse le job à ma connaissance.

    “It is seldom that liberty of any kind is lost all at once.” ― David Hume

  • # Réponse

    Posté par  (site web personnel) . Évalué à 1. Dernière modification le 21 décembre 2021 à 17:57.

    attention, ce code n'est pas fonctionnel dans tous les cas. Il fonctionne uniquement s'il n'y a pas de répétition.

    Je m'en fou je n'ai pas de répétition :D
    Je fait le malin mais en fait je n'ai pas du tout pensé à ça, mais dans mon cas de figure chaque entier est unique dans la liste donc ça va.

    -> dalfab
    Non la liste n'a pas besoins d'être ordonné et elle ne l'est pas forcément (même si en pratique elle doit souvent l'être).
    En fait ma liste contient certains index d'une autre liste (en fonction d'une condition bien sûr) ensuite ce que je veut savoir c'est si ces fameux index sont consécutif ou non.
    Après ça, la liste n'est plus utilisée.

    -> Gil cot
    Dans les exemples plusieurs ressemblent à ce que j'ai fait.

    Après mon code fonctionne (dans mon cas de figure, pas de nombre négatif et pas de répétition) mais une fonction standard aurait été plus concis.

    Merci à vous.

    Dévellopeur QElectroTech

    • [^] # Re: Réponse

      Posté par  . Évalué à 1. Dernière modification le 22 décembre 2021 à 10:45.

      Si la fonction correspondant à ton cas existait, elle devrait s'appeler "vérifier_si_les_éléments_potentielement_non_ordonnés_et_tous_différents_constituent_une_séquence_d_éléments_successifs", non cette fonction n'existe pas et serait finalement plus longue à écrire que ton code ;-)

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.