Namespaces
Variants

    std::experimental::ranges:: is_permutation

    From es.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
    Definido en el encabezado <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 >
    requiere 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 >
    requiere 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)
    (obsoleto)
    template < ForwardRange R1, class I2, class Pred = ranges:: equal_to <> ,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    requiere 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)
    (obsoleto)
    1) Devuelve true si existe una permutación de los elementos en el rango [ first1 , last1 ) que hace que el rango sea igual a [ first2 , last2 ) , y false en caso contrario.
    2) Igual que (1) , pero utiliza r1 como el primer rango fuente y r2 como el segundo rango fuente, como si se usara ranges:: begin ( r1 ) como first1 , ranges:: end ( r1 ) como last1 , ranges:: begin ( r2 ) como first2 , y ranges:: end ( r2 ) como last2 .
    3) Igual que (1) , excepto que first2 se define como si fuera std:: decay_t < I2 > first2 = std:: forward < I2 > ( first2_ ) ; y last2 es first2 + ( last1 - first1 ) .
    4) Igual que (3) , pero utiliza r1 como el primer rango fuente, como si se usara ranges:: begin ( r1 ) como first1 y ranges:: end ( r1 ) como last1 .

    Dos rangos se consideran iguales si tienen el mismo número de elementos y, para cada iterador i en el rango [ first1 , last1 ) , ranges:: invoke ( pred, ranges:: invoke ( proj1, * i ) , ranges:: invoke ( proj2, * ( first2 + ( i - first1 ) ) ) ) es true .

    No obstante las declaraciones representadas anteriormente, el número real y el orden de los parámetros de plantilla para las declaraciones de algoritmos no está especificado. Por lo tanto, si se utilizan argumentos de plantilla explícitos al invocar un algoritmo, el programa probablemente no sea portable.

    Contenidos

    Parámetros

    first1, last1 - el primer rango de los elementos
    r1 - el primer rango de los elementos
    first2, last2 - el segundo rango de los elementos
    r2 - el segundo rango de los elementos
    first2_ - el inicio del segundo rango de los elementos
    pred - predicado para aplicar a los elementos proyectados
    proj1 - proyección para aplicar a los elementos en el primer rango
    proj2 - proyección para aplicar a los elementos en el segundo rango

    Valor de retorno

    true si el rango [ first1 , last1 ) es una permutación del rango [ first2 , last2 ) .

    Complejidad

    A lo sumo O(N 2 ) aplicaciones del predicado y cada proyección, o exactamente N si las secuencias ya son iguales, donde N = last1 - first1 .

    Sin embargo, si SizedSentinel < S1, I1 > && SizedSentinel < S2, I2 > se satisface y last1 - first1 ! = last2 - first2 , no se realizan aplicaciones del predicado ni de las proyecciones.

    Ejemplo

    Esta sección está incompleta
    Razón: sin ejemplo

    Véase también

    (C++11)
    		 determina si una secuencia es una permutación de otra secuencia
    (plantilla de función & objeto función de algoritmo)
    (C++20)
    		genera la siguiente permutación lexicográfica mayor de un rango de elementos
    (plantilla de función)
    		genera la siguiente permutación lexicográfica menor de un rango de elementos
    (plantilla de función)