Namespaces
Variants

    std::experimental::ranges:: is_permutation

    From de.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
    **Änderungen:** - "deprecated" wurde zu "veraltet" übersetzt (das einzige zu übersetzende Textstück außerhalb der Code-Blöcke) - Alle HTML-Tags, Attribute und Code-Blöcke wurden unverändert beibehalten - C++-spezifische Begriffe wurden nicht übersetzt - Die ursprüngliche Formatierung wurde vollständig erhalten (Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags und Attribute unverändert bleiben müssen und die Zelleninhalte leer sind. Daher ist keine Übersetzung erforderlich.)
    template < ForwardIterator I1, Sentinel < I1 > S1, ForwardIterator I2, Sentinel < I2 > S2,

    class Pred = ranges:: equal_to <> ,
    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    erfordert 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 >
    erfordert 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 >
    erfordert ForwardIterator < std:: decay_t < I2 >> && ! Range < I2 > &&
    IndirektVergleichbar < 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)
    (veraltet)
    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)
    (veraltet)
    1) Gibt true zurück, falls eine Permutation der Elemente im Bereich [ first1 , last1 ) existiert, die den Bereich gleich [ first2 , last2 ) macht, andernfalls false .
    2) Gleich wie (1) , verwendet jedoch r1 als ersten Quellbereich und r2 als zweiten Quellbereich, als ob ranges:: begin ( r1 ) als first1 , ranges:: end ( r1 ) als last1 , ranges:: begin ( r2 ) als first2 , und ranges:: end ( r2 ) als last2 verwendet würde.
    3) Gleich wie (1) , außer dass first2 definiert ist als ob durch std:: decay_t < I2 > first2 = std:: forward < I2 > ( first2_ ) ; und last2 ist first2 + ( last1 - first1 ) .
    4) Gleich wie (3) , verwendet jedoch r1 als ersten Quellbereich, als ob ranges:: begin ( r1 ) als first1 und ranges:: end ( r1 ) als last1 verwendet würde.

    Zwei Bereiche werden als gleich betrachtet, wenn sie die gleiche Anzahl an Elementen haben und für jeden Iterator i im Bereich [ first1 , last1 ) , ranges:: invoke ( pred, ranges:: invoke ( proj1, * i ) , ranges:: invoke ( proj2, * ( first2 + ( i - first1 ) ) ) ) gleich true ist.

    Ungeachtet der oben dargestellten Deklarationen sind die tatsächliche Anzahl und Reihenfolge der Template-Parameter für Algorithmusdeklarationen nicht spezifiziert. Daher ist das Programm wahrscheinlich nicht portabel, wenn explizite Template-Argumente beim Aufruf eines Algorithmus verwendet werden.

    Inhalt

    Parameter

    first1, last1 - der erste Bereich der Elemente
    r1 - der erste Bereich der Elemente
    first2, last2 - der zweite Bereich der Elemente
    r2 - der zweite Bereich der Elemente
    first2_ - der Anfang des zweiten Bereichs der Elemente
    pred - Prädikat, das auf die projizierten Elemente angewendet wird
    proj1 - Projektion, die auf die Elemente im ersten Bereich angewendet wird
    proj2 - Projektion, die auf die Elemente im zweiten Bereich angewendet wird

    Rückgabewert

    true falls der Bereich [ first1 , last1 ) eine Permutation des Bereichs [ first2 , last2 ) ist.

    Komplexität

    Höchstens O(N 2 ) Anwendungen des Prädikats und jeder Projektion, oder genau N wenn die Sequenzen bereits gleich sind, wobei N = last1 - first1 .

    Wenn jedoch SizedSentinel < S1, I1 > && SizedSentinel < S2, I2 > erfüllt ist und last1 - first1 ! = last2 - first2 , werden keine Anwendungen des Prädikats und der Projektionen durchgeführt.

    Beispiel

    Dieser Abschnitt ist unvollständig
    Grund: Kein Beispiel

    Siehe auch

    (C++11)
    		 bestimmt, ob eine Sequenz eine Permutation einer anderen Sequenz ist
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		erzeugt die nächstgrößere lexikografische Permutation einer Elementfolge
    (Funktionsschablone)
    		erzeugt die nächstkleinere lexikografische Permutation einer Elementfolge
    (Funktionsschablone)