Namespaces
Variants

std::experimental::ranges:: is_permutation

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

Table des matières

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)
génère la prochaine permutation lexicographique supérieure d'une plage d'éléments
(modèle de fonction)
génère la prochaine permutation lexicographique inférieure d'une plage d'éléments
(modèle de fonction)