std::experimental::ranges::is_permutation

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Experimentell

Technische Spezifikation

Dateisystembibliothek (Filesystem TS)

Grundlagen der Bibliothek (Library Fundamentals TS)

Grundlagen der Bibliothek 2 (Library Fundamentals TS v2)

Grundlagen der Bibliothek 3 (Library Fundamentals TS v3)

Erweiterungen für Parallelität (Parallelism TS)

Erweiterungen für Parallelität 2 (Parallelism TS v2)

Erweiterungen für Nebenläufigkeit (Concurrency TS)

Erweiterungen für Nebenläufigkeit 2 (Concurrency TS v2)

Konzepte (Concepts TS)

Bereiche (Ranges TS)

Reflektion (Reflection TS)

Mathematische Spezialfunktionen (Special Functions TR)

Experimentell Nicht-TS

Pattern Matching

Lineare Algebra

std::execution

Verträge

2D-Grafik

 

Bereiche (Ranges)

Konzepte

Allgemeine Hilfsmittel

Iteratoren

Bereiche (Ranges)

Algorithmen

 

Algorithmen-Bibliothek

Nicht-modifizierende Sequenzoperationen
all_ofany_ofnone_of countcount_if	findfind_iffind_if_not find_end find_first_of	adjacent_find search search_n mismatch	equal for_each lexicographical_compare
Modifizierende Sequenzoperationen
copycopy_if copy_n copy_backward move move_backward	fill fill_n generate generate_n swap_ranges shuffle transform	removeremove_if replacereplace_if reverse rotate unique	remove_copyremove_copy_if replace_copyreplace_copy_if reverse_copy rotate_copy unique_copy
Partitionierungsoperationen
is_partitioned partition_point	partition partition_copy	stable_partition
Sortieroperationen
is_sorted is_sorted_until	sort stable_sort	partial_sort partial_sort_copy	nth_element
Binäre Suchoperationen
lower_bound	upper_bound	binary_search	equal_range
Mengenoperationen (auf sortierten Bereichen)
merge inplace_merge	includes	set_difference set_intersection	set_symmetric_difference set_union
Heapoperationen
is_heap is_heap_until	make_heap sort_heap	push_heap pop_heap
Minimum/Maximum-Operationen
max max_element	min min_element	minmax minmax_element
Permutationen
is_permutation	next_permutation	prev_permutation

 

Definiert in Header <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) (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, wenn es eine Permutation der Elemente im Bereich [first1, last1) gibt, die den Bereich gleich [first2, last2) macht, und false andernfalls.

2) Ähnlich 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ürden.

3) Ähnlich wie (1), außer dass first2 als durch std::decay_t<I2> first2 = std::forward<I2>(first2_); definiert wird und last2 gleich first2 + (last1 - first1) ist.

4) Dasselbe wie (3), verwendet aber r1 als ersten Quellbereich, als ob ranges::begin(r1) als first1 und ranges::end(r1) als last1 verwendet würden.

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

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

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, wenn der Bereich [first1, last1) eine Permutation des Bereichs [first2, last2) ist.

Komplexität

Höchstens O(N²) Anwendungen des Prädikats und jeder Projektion, oder exakt 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.

Siehe auch

is_permutation (C++11)	bestimmt, ob eine Sequenz eine Permutation einer anderen Sequenz ist (Funktionsvorlage)
next_permutation	erzeugt die nächstgrößere lexikographische Permutation eines Bereichs von Elementen (Funktionsvorlage)
prev_permutation	erzeugt die nächstkleinere lexikographische Permutation eines Bereichs von Elementen (Funktionsvorlage)