Namespaces
Variants

    std::experimental::ranges:: is_permutation

    From fr.cppreference.net
    C++
    Experimental
    Ranges
    Algorithms library
    Non-modifying sequence operations
    Modifying sequence operations
    Partitioning operations
    Sorting operations
    Binary search operations
    Set operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    Permutations
    is_permutation
    **Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il contient des termes techniques spécifiques au C++ et se trouve dans des balises HTML de formatage de code. Seul le texte environnant a été traduit, mais dans ce cas précis, il n'y avait pas de texte en dehors des balises de code à traduire.
    Défini dans l'en-tête <experimental/ranges/algorithm>
    template < ForwardIterator I1, Sentinel < I1 > S1, ForwardIterator I2, Sentinel < I2 > S2,

    class Pred = ranges:: equal_to <> ,
    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    requires IndirectlyComparable < I1, I2, Pred, Proj1, Proj2 >
    bool is_permutation ( I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred { } ,

    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } ) ;
    		(1) (ranges TS)
    template < ForwardRange R1, ForwardRange R2, class Pred = ranges:: equal_to <> ,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    requires IndirectlyComparable < ranges:: iterator_t < R1 > , ranges:: iterator_t < R2 > ,
    Pred, Proj1, Proj2 >
    bool is_permutation ( R1 && r1, R2 && r2, Pred pred = Pred { } ,

    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } ) ;
    		(2) (ranges TS)
    template < ForwardIterator I1, Sentinel < I1 > S1, class I2,

    class Pred = ranges:: equal_to <> ,
    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    requires ForwardIterator < std:: decay_t < I2 >> && ! Range < I2 > &&
    IndirectlyComparable < I1, std:: decay_t < I2 > , Pred, Proj1, Proj2 >
    bool is_permutation ( I1 first1, S1 last1, I2 && first2_, Pred pred = Pred { } ,

    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } ) ;
    		(3) (ranges TS)
    (obsolète)
    template < ForwardRange R1, class I2, class Pred = ranges:: equal_to <> ,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    requires ForwardIterator < std:: decay_t < I2 >> && ! Range < I2 > &&
    IndirectlyComparable < ranges:: iterator_t < R1 > , std:: decay_t < I2 > , Pred, Proj1, Proj2 >
    bool is_permutation ( R1 && r1, I2 && first2_, Pred pred = Pred { } ,

    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } ) ;
    		(4) (ranges TS)
    (obsolète)
    1) Retourne true s'il existe une permutation des éléments dans l'intervalle [ first1 , last1 ) qui rend l'intervalle égal à [ first2 , last2 ) , et false sinon.
    2) Identique à (1) , mais utilise r1 comme première plage source et r2 comme deuxième plage source, comme si on utilisait ranges:: begin ( r1 ) comme first1 , ranges:: end ( r1 ) comme last1 , ranges:: begin ( r2 ) comme first2 , et ranges:: end ( r2 ) comme last2 .
    3) Identique à (1) , sauf que first2 est défini comme si par std:: decay_t < I2 > first2 = std:: forward < I2 > ( first2_ ) ; et last2 est first2 + ( last1 - first1 ) .
    4) Identique à (3) , mais utilise r1 comme première plage source, comme si on utilisait ranges:: begin ( r1 ) comme first1 et ranges:: end ( r1 ) comme last1 .

    Deux plages sont considérées égales si elles ont le même nombre d'éléments et si, pour chaque itérateur i dans la plage [ first1 , last1 ) , ranges:: invoke ( pred, ranges:: invoke ( proj1, * i ) , ranges:: invoke ( proj2, * ( first2 + ( i - first1 ) ) ) ) est true .

    Nonobstant les déclarations dépeintes ci-dessus, le nombre réel et l'ordre des paramètres de template pour les déclarations d'algorithmes ne sont pas spécifiés. Ainsi, si des arguments de template explicites sont utilisés lors de l'appel d'un algorithme, le programme est probablement non portable.

    Contenu

    Paramètres

    first1, last1 - la première plage des éléments
    r1 - la première plage des éléments
    first2, last2 - la deuxième plage des éléments
    r2 - la deuxième plage des éléments
    first2_ - le début de la deuxième plage des éléments
    pred - prédicat à appliquer aux éléments projetés
    proj1 - projection à appliquer aux éléments de la première plage
    proj2 - projection à appliquer aux éléments de la deuxième plage

    Valeur de retour

    true si la plage [ first1 , last1 ) est une permutation de la plage [ first2 , last2 ) .

    Complexité

    Au plus O(N 2 ) applications du prédicat et de chaque projection, ou exactement N si les séquences sont déjà égales, où N = last1 - first1 .

    Cependant si SizedSentinel < S1, I1 > && SizedSentinel < S2, I2 > est satisfait et last1 - first1 ! = last2 - first2 , aucune application du prédicat et des projections n'est effectuée.

    Exemple

    Cette section est incomplète
    Raison : aucun exemple

    Voir aussi

    (C++11)
    		 détermine si une séquence est une permutation d'une autre séquence
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)
    		génère la prochaine permutation lexicographique plus grande d'une plage d'éléments
    (modèle de fonction)
    		génère la prochaine permutation lexicographique plus petite d'une plage d'éléments
    (modèle de fonction)