std::is_permutation(3)

NAME
std::is_permutation - std::is_permutation

Synopsis
   Defined in header <algorithm>
   template< class ForwardIt1, class ForwardIt2
   > (since
                        C++11)
   bool is_permutation( ForwardIt1 first1, (until
   ForwardIt1 last1, C++20)
   ForwardIt2 first2 );
   template< class ForwardIt1, class ForwardIt2
   >
                        (since
   constexpr bool is_permutation( ForwardIt1 C++20)
   first1, ForwardIt1 last1,
   ForwardIt2 first2 );
   template< class ForwardIt1, class
   ForwardIt2, class BinaryPredicate > (since
                        C++11)
   bool is_permutation( ForwardIt1 first1, (until
   ForwardIt1 last1, C++20)
   ForwardIt2 first2, BinaryPredicate p );
   template< class ForwardIt1, class
   ForwardIt2, class BinaryPredicate >
                        (since
   constexpr bool is_permutation( ForwardIt1 C++20)
   first1, ForwardIt1 last1,
   ForwardIt2 first2, BinaryPredicate p );
   template< class ForwardIt1, class ForwardIt2 (1)
   > (since
                        C++14)
   bool is_permutation( ForwardIt1 first1, (until
   ForwardIt1 last1, C++20)
   ForwardIt2 first2, ForwardIt2 last2 );
   template< class ForwardIt1, class ForwardIt2 (2)
   >
                        (since
   constexpr bool is_permutation( ForwardIt1 C++20)
   first1, ForwardIt1 last1,
   ForwardIt2 first2, ForwardIt2 last2 );
   template< class ForwardIt1, class (3)
   ForwardIt2, class BinaryPredicate >
                        (since
   bool is_permutation( ForwardIt1 first1, C++14)
   ForwardIt1 last1, (until
   ForwardIt2 first2, ForwardIt2 last2, C++20)
   BinaryPredicate p ); (4)
   template< class ForwardIt1, class
   ForwardIt2, class BinaryPredicate >
   constexpr bool is_permutation( ForwardIt1 (since
   first1, ForwardIt1 last1, C++20)
   ForwardIt2 first2, ForwardIt2 last2,
   BinaryPredicate p );
   Returns true if there exists a permutation of the elements in the range [first1,
   last1) that makes that range equal to the range [first2,last2), where last2 denotes
   first2 + (last1 - first1) if it was not given.
   1,3) Elements are compared using operator==. The behavior is undefined if it is not
   an equivalence relation.
   2,4) Elements are compared using the given binary predicate p. The behavior is
   undefined if it is not an equivalence relation.

Parameters
   first1, last1 - the range of elements to compare
   first2, last2 - the second range to compare
                   binary predicate which returns true if the elements should be
                   treated as equal.
                   The signature of the predicate function should be equivalent to the
                   following:
   p -
                   bool pred(const Type &a, const Type &b);
                   Type should be the value type of both ForwardIt1 and ForwardIt2. The
                   signature does not need to have const &, but the function must not
                   modify the objects passed to it.

Type requirements
   -
   ForwardIt1, ForwardIt2 must meet the requirements of LegacyForwardIterator.
   -
   ForwardIt1, ForwardIt2 must have the same value type.

Return value
   true if the range [first1, last1) is a permutation of the range [first2, last2).

Complexity
   At most \(\scriptsize \mathcal{O}(N^2)\)O(N^2) applications of the predicate, or
   exactly \(\scriptsize N\)N if the sequences are already equal, where \(\scriptsize
   N\)N is std::distance(first1, last1).
   However if ForwardIt1 and ForwardIt2 meet the requirements of
   LegacyRandomAccessIterator and std::distance(first1, last1) != std::distance(first2,
   last2) no applications of the predicate are made.

Note
   The std::is_permutation can be used in testing, namely to check the correctness of
   rearranging algorithms (e.g. sorting, shuffling, partitioning). If x is an original
   range and y is a permuted range then std::is_permutation(x, y) == true means that y
   consist of "the same" elements, maybe staying at other positions.

Possible implementation
   template<class ForwardIt1, class ForwardIt2>
   bool is_permutation(ForwardIt1 first, ForwardIt1 last,
                       ForwardIt2 d_first)
   {
       // skip common prefix
       std::tie(first, d_first) = std::mismatch(first, last, d_first);
       // iterate over the rest, counting how many times each element
       // from [first, last) appears in [d_first, d_last)
       if (first != last) {
           ForwardIt2 d_last = std::next(d_first, std::distance(first, last));
           for (ForwardIt1 i = first; i != last; ++i) {
               if (i != std::find(first, i, *i)) continue; // this *i has been checked
               auto m = std::count(d_first, d_last, *i);
               if (m==0 || std::count(i, last, *i) != m) {
                   return false;
               }
           }
       }
       return true;
   }

Example
// Run this code
 #include <iostream>
 #include <algorithm>
 template<typename Os, typename V>
 Os& operator<< (Os& os, V const& v) {
     os << "{ ";
     for (auto const& e : v) os << e << ' ';
     return os << "}";
 }
 int main()
 {
     static constexpr auto v1 = {1,2,3,4,5};
     static constexpr auto v2 = {3,5,4,1,2};
     static constexpr auto v3 = {3,5,4,1,1};
     std::cout << v2 << " is a permutation of " << v1 << ": " << std::boolalpha
               << std::is_permutation(v1.begin(), v1.end(), v2.begin()) << '\n'
               << v3 << " is a permutation of " << v1 << ": " << std::boolalpha
               << std::is_permutation(v1.begin(), v1.end(), v3.begin()) << '\n';
 }

Output:
 { 3 5 4 1 2 } is a permutation of { 1 2 3 4 5 }: true
 { 3 5 4 1 1 } is a permutation of { 1 2 3 4 5 }: false

See also
                        generates the next greater lexicographic permutation of a
   next_permutation range of elements
                        (function template)
                        generates the next smaller lexicographic permutation of a
   prev_permutation range of elements
                        (function template)
   equivalence_relation specifies that a relation imposes an equivalence relation
   (C++20) (concept)
   ranges::is_permutation determines if a sequence is a permutation of another sequence
   (C++20) (niebloid)