##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::is_permutation

From cppreference.com
< cpp‎ | algorithm

Defined in header `<algorithm>` |  |
template< class ForwardIt1, class ForwardIt2 > bool is_permutation( ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2 ); | (1) | (since C++11)
template< class ForwardIt1, class ForwardIt2, class BinaryPredicate > bool is_permutation( ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, BinaryPredicate p ); | (2) | (since C++11)
template< class ForwardIt1, class ForwardIt2 > bool is_permutation( ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2 ); | (3) | (since C++14)
template< class ForwardIt1, class ForwardIt2, class BinaryPredicate > bool is_permutation( ForwardIt1 first1, ForwardIt1 last2, ForwardIt2 first1, ForwardIt2 last2, BinaryPredicate p ); | (4) | (since C++14)

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. The overloads (1) and (3) use `operator==` for equality, whereas the overloads (2) and (4) use the binary predicate `p`.

### [edit] Parameters

first1, last2 | - | the range of elements to compare
first2, last2 | - | the second range to compare
p | - | 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: bool pred(const Type1 &a, const Type2 &b); The signature does not need to have const &, but the function must not modify the objects passed to it. The types Type1 and Type2 must be such that objects of types ForwardIt1 and ForwardIt2 can be dereferenced and then implicitly converted to Type1 and Type2 respectively. ​
Type requirements
- `ForwardIt1, ForwardIt2` must meet the requirements of `ForwardIterator`.

### [edit] Return value

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

### [edit] Complexity

At most O(N2) applications of the predicate, or exactly N if the sequences are already equal, where N=std::distance(first1, last1).

However if `ForwardIt1` and `ForwardIt2` meet the requirements of `RandomAccessIterator` and std::distance(first1, last1) != std::distance(first2, last2) no applications of the predicate are made.

### [edit] 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 = d_first;
           std::advance(d_last, std::distance(first, last));
           for (ForwardIt1 i = first; i != last; ++i) {
                if (i != std::find(first, i, *i)) continue; // already counted this *i

                auto m = std::count(d_first, d_last, *i);
                if (m==0 || std::count(i, last, *i) != m) {
                    return false;
                }
            }
        }
        return true;
    }

### [edit] Example

Run this code

    #include <algorithm>
    #include <vector>
    #include <iostream>
    int main()
    {
        std::vector<int> v1{1,2,3,4,5};
        std::vector<int> v2{3,5,4,1,2};
        std::cout << "3,5,4,1,2 is a permutation of 1,2,3,4,5? "
                  << std::boolalpha
                  << std::is_permutation(v1.begin(), v1.end(), v2.begin()) << '\n';

        std::vector<int> v3{3,5,4,1,1};
        std::cout << "3,5,4,1,1 is a permutation of 1,2,3,4,5? "
                  << 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

### [edit] See also

next_permutation | generates the next greater lexicographic permutation of a range of elements (function template) [edit]
prev_permutation | generates the next smaller lexicographic permutation of a range of elements (function template) [edit]

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/is_permutation&oldid=66103"