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
**Ä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.

Inhaltsverzeichnis

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
(Funktions-Template)
erzeugt die nächstgrößere lexikografische Permutation eines Elementbereichs
(Funktions-Template)
erzeugt die nächstkleinere lexikografische Permutation eines Elementbereichs
(Funktions-Template)