#include "algorithm.hpp"
#include <algorithm>
#include <iostream>
#include <vector>
#include <cctype>
#include <array>
#include <ctime>
#include <cstdlib>
#include <string>
#include <random>
#include <chrono>

// Blog: http://blog.csdn.net/fengbingchun/article/details/78034969

// reference: http://www.cplusplus.com/reference/algorithm/

namespace algorithm_ {

///////////////////////////////////////
static bool myfunction(int i, int j) { return (i == j); }
static bool comp_case_insensitive(char c1, char c2) { return (std::tolower(c1) == std::tolower(c2)); }
static bool IsOdd(int i) { return ((i % 2) == 1); }

int test_algorithm_find()
{
{
    int myints[] = { 5, 20, 5, 30, 30, 20, 10, 10, 20 };
    std::vector<int> myvector(myints, myints + 8);
    std::vector<int>::iterator it;

    // using default comparison:
    it = std::adjacent_find(myvector.begin(), myvector.end());

    if (it != myvector.end())
        std::cout << "the first pair of repeated elements are: " << *it << '\n'; // 30

    //using predicate comparison:
    it = std::adjacent_find(++it, myvector.end(), myfunction);

    if (it != myvector.end())
        std::cout << "the second pair of repeated elements are: " << *it << '\n'; // 10
}

{
    // using std::find with array and pointer:
    int myints[] = { 10, 20, 30, 40 };
    int * p;

    p = std::find(myints, myints + 4, 30);
    if (p != myints + 4)
        std::cout << "Element found in myints: " << *p << '\n'; // 30
    else
        std::cout << "Element not found in myints\n";

    // using std::find with vector and iterator:
    std::vector<int> myvector(myints, myints + 4);
    std::vector<int>::iterator it;

    it = std::find(myvector.begin(), myvector.end(), 30);
    if (it != myvector.end())
        std::cout << "Element found in myvector: " << *it << '\n'; // 30
    else
        std::cout << "Element not found in myvector\n";
}

{
    int myints[] = { 1, 2, 3, 4, 5, 1, 2, 3, 4, 5 };
    std::vector<int> haystack(myints, myints + 10);

    int needle1[] = { 1, 2, 3 };

    // using default comparison:
    std::vector<int>::iterator it;
    it = std::find_end(haystack.begin(), haystack.end(), needle1, needle1 + 3);

    if (it != haystack.end())
        std::cout << "needle1 last found at position " << (it - haystack.begin()) << '\n'; // 5

    int needle2[] = { 4, 5, 1 };

    // using predicate comparison:
    it = std::find_end(haystack.begin(), haystack.end(), needle2, needle2 + 3, myfunction);

    if (it != haystack.end())
        std::cout << "needle2 last found at position " << (it - haystack.begin()) << '\n'; // 3
}

{
    int mychars[] = { 'a', 'b', 'c', 'A', 'B', 'C' };
    std::vector<char> haystack(mychars, mychars + 6);
    std::vector<char>::iterator it;

    int needle[] = { 'A', 'B', 'C' };

    // using default comparison:
    it = find_first_of(haystack.begin(), haystack.end(), needle, needle + 3);

    if (it != haystack.end())
        std::cout << "The first match is: " << *it << '\n'; // A

    // using predicate comparison:
    it = find_first_of(haystack.begin(), haystack.end(), needle, needle + 3, comp_case_insensitive);

    if (it != haystack.end())
        std::cout << "The first match is: " << *it << '\n'; // a
}

{
    std::vector<int> myvector;

    myvector.push_back(10);
    myvector.push_back(25);
    myvector.push_back(40);
    myvector.push_back(55);

    std::vector<int>::iterator it = std::find_if(myvector.begin(), myvector.end(), IsOdd);
    std::cout << "The first odd value is " << *it << '\n'; // 25
}

{
    std::array<int, 5> foo = { 1, 2, 3, 4, 5 };

    std::array<int, 5>::iterator it = std::find_if_not(foo.begin(), foo.end(), [](int i){return i % 2; });
    std::cout << "The first even value is " << *it << '\n'; // 2
}

    return 0;
}

////////////////////////////////////////////
int test_algorithm_all_of()
{
{
    std::array<int, 8> foo = { 3, 5, 7, 11, 13, 17, 19, 23 };

    if (std::all_of(foo.begin(), foo.end(), [](int i){return i % 2; }))
        std::cout << "All the elements are odd numbers.\n"; // All the elements are odd numbers
}

{
    std::array<int, 7> foo = { 0, 1, -1, 3, -3, 5, -5 };

    if (std::any_of(foo.begin(), foo.end(), [](int i){return i<0; }))
        std::cout << "There are negative elements in the range.\n"; // There are negative elements in the range
}

{
    std::array<int, 8> foo = { 1, 2, 4, 8, 16, 32, 64, 128 };

    if (std::none_of(foo.begin(), foo.end(), [](int i){return i<0; }))
        std::cout << "There are no negative elements in the range.\n"; // There are no negative elements in the range
}

    return 0;
}

////////////////////////////////////////////////
static bool myfunction2(int i, int j) { return (i<j); }
static bool mypredicate(int i, int j) { return (i == j); }

int test_algorithm_search()
{
{
    int myints[] = { 1, 2, 3, 4, 5, 4, 3, 2, 1 };
    std::vector<int> v(myints, myints + 9);

    // using default comparison:
    std::sort(v.begin(), v.end());

    std::cout << "looking for a 3... ";
    if (std::binary_search(v.begin(), v.end(), 3)) std::cout << "found!\n"; // found!
    else std::cout << "not found.\n";

    // using myfunction as comp:
    std::sort(v.begin(), v.end(), myfunction2);

    std::cout << "looking for a 6... ";
    if (std::binary_search(v.begin(), v.end(), 6, myfunction2)) std::cout << "found!\n";
    else std::cout << "not found.\n"; // not found.
}

{
    std::vector<int> haystack;

    // set some values:        haystack: 10 20 30 40 50 60 70 80 90
    for (int i = 1; i<10; i++) haystack.push_back(i * 10);

    // using default comparison:
    int needle1[] = { 40, 50, 60, 70 };
    std::vector<int>::iterator it;
    it = std::search(haystack.begin(), haystack.end(), needle1, needle1 + 4);

    if (it != haystack.end())
        std::cout << "needle1 found at position " << (it - haystack.begin()) << '\n'; // 3
    else
        std::cout << "needle1 not found\n";

    // using predicate comparison:
    int needle2[] = { 20, 30, 50 };
    it = std::search(haystack.begin(), haystack.end(), needle2, needle2 + 3, mypredicate);

    if (it != haystack.end())
        std::cout << "needle2 found at position " << (it - haystack.begin()) << '\n';
    else
        std::cout << "needle2 not found\n"; // needle2 not found
}

{
    int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };
    std::vector<int> myvector(myints, myints + 8);

    std::vector<int>::iterator it;

    // using default comparison:
    it = std::search_n(myvector.begin(), myvector.end(), 2, 30);

    if (it != myvector.end())
        std::cout << "two 30s found at position " << (it - myvector.begin()) << '\n'; // 2
    else
        std::cout << "match not found\n";

    // using predicate comparison:
    it = std::search_n(myvector.begin(), myvector.end(), 2, 10, mypredicate);

    if (it != myvector.end())
        std::cout << "two 10s found at position " << int(it - myvector.begin()) << '\n'; // 5
    else
        std::cout << "match not found\n";
}

    return 0;
}

//////////////////////////////////////////////
int test_algorithm_copy()
{
{
    int myints[] = { 10, 20, 30, 40, 50, 60, 70 };
    std::vector<int> myvector(7);

    std::copy(myints, myints + 7, myvector.begin());

    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 10 20 30 40 50 60 70

    std::cout << '\n';
}

{
    std::vector<int> myvector;

    // set some values:
    for (int i = 1; i <= 5; i++)
        myvector.push_back(i * 10);          // myvector: 10 20 30 40 50

    myvector.resize(myvector.size() + 3);  // allocate space for 3 more elements

    std::copy_backward(myvector.begin(), myvector.begin() + 5, myvector.end());

    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 10 20 30 10 20 30 40 50
    std::cout << '\n';
}

{
    std::vector<int> foo = { 25, 15, 5, -5, -15 };
    std::vector<int> bar(foo.size());

    // copy only positive numbers:
    auto it = std::copy_if(foo.begin(), foo.end(), bar.begin(), [](int i){return !(i<0); });
    bar.resize(std::distance(bar.begin(), it));  // shrink container to new size

    std::cout << "bar contains:";
    for (int& x : bar) std::cout << ' ' << x; // 25 15 5
    std::cout << '\n';
}

{
    int myints[] = { 10, 20, 30, 40, 50, 60, 70 };
    std::vector<int> myvector;

    myvector.resize(7);   // allocate space for 7 elements

    std::copy_n(myints, 7, myvector.begin());

    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 10 20 30 40 50 60 70

    std::cout << '\n';
}

    return 0;
}

///////////////////////////////////////////////
int test_algorithm_count()
{
{
    // counting elements in array:
    int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };   // 8 elements
    int mycount = std::count(myints, myints + 8, 10);
    std::cout << "10 appears " << mycount << " times.\n"; // 3

    // counting elements in container:
    std::vector<int> myvector(myints, myints + 8);
    mycount = std::count(myvector.begin(), myvector.end(), 20);
    std::cout << "20 appears " << mycount << " times.\n"; // 3
}

{
    std::vector<int> myvector;
    for (int i = 1; i<10; i++) myvector.push_back(i); // myvector: 1 2 3 4 5 6 7 8 9

    int mycount = count_if(myvector.begin(), myvector.end(), IsOdd);
    std::cout << "myvector contains " << mycount << " odd values.\n"; // 5
}

    return 0;
}

//////////////////////////////////////////
static bool mygreater(int i, int j) { return (i>j); }

int test_algorithm_equal()
{
{
    int myints[] = { 20, 40, 60, 80, 100 };               // myints: 20 40 60 80 100
    std::vector<int>myvector(myints, myints + 5);       // myvector: 20 40 60 80 100

    // using default comparison:
    if (std::equal(myvector.begin(), myvector.end(), myints))
        std::cout << "The contents of both sequences are equal.\n"; // equal
    else
        std::cout << "The contents of both sequences differ.\n";

    myvector[3] = 81;                                 // myvector: 20 40 60 81 100

    // using predicate comparison:
    if (std::equal(myvector.begin(), myvector.end(), myints, mypredicate))
        std::cout << "The contents of both sequences are equal.\n";
    else
        std::cout << "The contents of both sequences differ.\n"; // differ
}

{
    int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };
    std::vector<int> v(myints, myints + 8);                         // 10 20 30 30 20 10 10 20
    std::pair<std::vector<int>::iterator, std::vector<int>::iterator> bounds;

    // using default comparison:
    std::sort(v.begin(), v.end());                              // 10 10 10 20 20 20 30 30
    bounds = std::equal_range(v.begin(), v.end(), 20);          //          ^        ^

    std::cout << "bounds at positions " << (bounds.first - v.begin()); // 3
    std::cout << " and " << (bounds.second - v.begin()) << '\n'; // 6

    // using "mygreater" as comp:
    std::sort(v.begin(), v.end(), mygreater);                     // 30 30 20 20 20 10 10 10
    bounds = std::equal_range(v.begin(), v.end(), 20, mygreater); //       ^        ^

    std::cout << "bounds at positions " << (bounds.first - v.begin()); // 2
    std::cout << " and " << (bounds.second - v.begin()) << '\n'; // 5
}

{
    int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };
    std::vector<int> v(myints, myints + 8);       // 10 20 30 30 20 10 10 20

    std::sort(v.begin(), v.end());                // 10 10 10 20 20 20 30 30

    std::vector<int>::iterator low, up;
    low = std::lower_bound(v.begin(), v.end(), 20);
    up = std::upper_bound(v.begin(), v.end(), 20);

    std::cout << "lower_bound at position " << (low - v.begin()) << '\n'; // 3
    std::cout << "upper_bound at position " << (up - v.begin()) << '\n'; // 6
}

    return 0;
}

//////////////////////////////////////////
int test_algorithm_fill()
{
{
    std::vector<int> myvector(8);                       // myvector: 0 0 0 0 0 0 0 0

    std::fill(myvector.begin(), myvector.begin() + 4, 5);   // myvector: 5 5 5 5 0 0 0 0
    std::fill(myvector.begin() + 3, myvector.end() - 2, 8);   // myvector: 5 5 5 8 8 8 0 0

    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 5 5 5 8 8 8 0 0
    std::cout << '\n';
}

{
    std::vector<int> myvector(8, 10);        // myvector: 10 10 10 10 10 10 10 10

    std::fill_n(myvector.begin(), 4, 20);     // myvector: 20 20 20 20 10 10 10 10
    std::fill_n(myvector.begin() + 3, 3, 33);   // myvector: 20 20 20 33 33 33 10 10

    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 20 20 20 33 33 33 10 10
    std::cout << '\n';
}

    return 0;
}

///////////////////////////////////////////
void myfunction3(int i) {  // function:
    std::cout << ' ' << i;
}

struct myclass {           // function object type:
    void operator() (int i) { std::cout << ' ' << i; }
} myobject;

int test_algorithm_for_each()
{
    std::vector<int> myvector;
    myvector.push_back(10);
    myvector.push_back(20);
    myvector.push_back(30);

    std::cout << "myvector contains:";
    for_each(myvector.begin(), myvector.end(), myfunction3); // 10 20 30
    std::cout << '\n';

    // or:
    std::cout << "myvector contains:";
    for_each(myvector.begin(), myvector.end(), myobject); // 10 20 30
    std::cout << '\n';

    return 0;
}

////////////////////////////////////////////////
// function generator:
int RandomNumber() { return (std::rand() % 100); }

// class generator:
struct c_unique {
    int current;
    c_unique() { current = 0; }
    int operator()() { return ++current; }
} UniqueNumber;

int current = 0;
int UniqueNumber2() { return ++current; }

int test_algorithm_generate()
{
{
    std::srand(unsigned(std::time(0)));

    std::vector<int> myvector(8);

    std::generate(myvector.begin(), myvector.end(), RandomNumber);

    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it;
    std::cout << '\n';

    std::generate(myvector.begin(), myvector.end(), UniqueNumber);

    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 1 2 3 4 5 6 7 8
    std::cout << '\n';
}

{
    int myarray[9];

    std::generate_n(myarray, 9, UniqueNumber2);

    std::cout << "myarray contains:";
    for (int i = 0; i<9; ++i)
        std::cout << ' ' << myarray[i]; // 1 2 3 4 5 6 7 8 9
    std::cout << '\n';
}

    return 0;
}

////////////////////////////////////////////////
int test_algorithm_includes()
{
    int container[] = { 5, 10, 15, 20, 25, 30, 35, 40, 45, 50 };
    int continent[] = { 40, 30, 20, 10 };

    std::sort(container, container + 10);
    std::sort(continent, continent + 4);

    // using default comparison:
    if (std::includes(container, container + 10, continent, continent + 4))
        std::cout << "container includes continent!\n"; // container includes continent

    // using myfunction as comp:
    if (std::includes(container, container + 10, continent, continent + 4, myfunction2))
        std::cout << "container includes continent!\n"; // container includes continent

    return 0;
}

///////////////////////////////////////////////////////////
int test_algorithm_merge()
{
{
    int first[] = { 5, 10, 15, 20, 25 };
    int second[] = { 50, 40, 30, 20, 10 };
    std::vector<int> v(10);
    std::vector<int>::iterator it;

    std::sort(first, first + 5);
    std::sort(second, second + 5);

    it = std::copy(first, first + 5, v.begin());
    std::copy(second, second + 5, it);

    std::inplace_merge(v.begin(), v.begin() + 5, v.end());

    std::cout << "The resulting vector contains:";
    for (it = v.begin(); it != v.end(); ++it)
        std::cout << ' ' << *it; // 5 10 10 15 20 20 25 30 40 50
    std::cout << '\n';
}

{
    int first[] = { 5, 10, 15, 20, 25 };
    int second[] = { 50, 40, 30, 20, 10 };
    std::vector<int> v(10);

    std::sort(first, first + 5);
    std::sort(second, second + 5);
    std::merge(first, first + 5, second, second + 5, v.begin());

    std::cout << "The resulting vector contains:";
    for (std::vector<int>::iterator it = v.begin(); it != v.end(); ++it)
        std::cout << ' ' << *it; // 5 10 10 15 20 20 25 30 40 50
    std::cout << '\n';
}

    return 0;
}

////////////////////////////////////////
int test_algorithm_heap()
{
{
    std::vector<int> foo{ 9, 5, 2, 6, 4, 1, 3, 8, 7 };

    if (!std::is_heap(foo.begin(), foo.end()))
        std::make_heap(foo.begin(), foo.end());

    std::cout << "Popping out elements:";
    while (!foo.empty()) {
        std::pop_heap(foo.begin(), foo.end());   // moves largest element to back
        std::cout << ' ' << foo.back();         // prints back // 9 8 7 6 5 4 3 2 1
        foo.pop_back();                         // pops element out of container
    }
    std::cout << '\n';
}

{
    std::vector<int> foo{ 2, 6, 9, 3, 8, 4, 5, 1, 7 };

    std::sort(foo.begin(), foo.end());
    std::reverse(foo.begin(), foo.end());

    auto last = std::is_heap_until(foo.begin(), foo.end());

    std::cout << "The " << (last - foo.begin()) << " first elements are a valid heap:"; // 9
    for (auto it = foo.begin(); it != last; ++it)
        std::cout << ' ' << *it; // 9 8 7 6 5 4 3 2 1
    std::cout << '\n';
}

{
    int myints[] = { 10, 20, 30, 5, 15 };
    std::vector<int> v(myints, myints + 5);

    std::make_heap(v.begin(), v.end());
    std::cout << "initial max heap   : " << v.front() << '\n'; // 30

    std::pop_heap(v.begin(), v.end()); v.pop_back();
    std::cout << "max heap after pop : " << v.front() << '\n'; // 20

    v.push_back(99); std::push_heap(v.begin(), v.end());
    std::cout << "max heap after push: " << v.front() << '\n'; // 99

    std::sort_heap(v.begin(), v.end());

    std::cout << "final sorted range :";
    for (unsigned i = 0; i<v.size(); i++)
        std::cout << ' ' << v[i]; // 5 10 15 20 99

    std::cout << '\n';
}

    return 0;
}

////////////////////////////////////////////
int test_algorithm_partition()
{
{
    std::array<int, 7> foo{ 1, 2, 3, 4, 5, 6, 7 };

    // print contents:
    std::cout << "foo:"; for (int& x : foo) std::cout << ' ' << x;
    if (std::is_partitioned(foo.begin(), foo.end(), IsOdd))
        std::cout << " (partitioned)\n";
    else
        std::cout << " (not partitioned)\n"; // not partitioned

    // partition array:
    std::partition(foo.begin(), foo.end(), IsOdd);

    // print contents again:
    std::cout << "foo:"; for (int& x : foo) std::cout << ' ' << x; // 1 7 3 5 4 6 2
    if (std::is_partitioned(foo.begin(), foo.end(), IsOdd))
        std::cout << " (partitioned)\n"; // partitioned
    else
        std::cout << " (not partitioned)\n";
}

{
    std::vector<int> myvector;

    // set some values:
    for (int i = 1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9

    std::vector<int>::iterator bound;
    bound = std::partition(myvector.begin(), myvector.end(), IsOdd);

    // print out content:
    std::cout << "odd elements:";
    for (std::vector<int>::iterator it = myvector.begin(); it != bound; ++it)
        std::cout << ' ' << *it; // 1 9 3 7 5
    std::cout << '\n';

    std::cout << "even elements:";
    for (std::vector<int>::iterator it = bound; it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 6 4 8 2
    std::cout << '\n';
}

{
    std::vector<int> foo{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    std::vector<int> odd, even;

    // resize vectors to proper size:
    unsigned n = std::count_if(foo.begin(), foo.end(), IsOdd);
    odd.resize(n); even.resize(foo.size() - n);

    // partition:
    std::partition_copy(foo.begin(), foo.end(), odd.begin(), even.begin(), IsOdd);

    // print contents:
    std::cout << "odd: ";  for (int& x : odd)  std::cout << ' ' << x; std::cout << '\n'; // 1 3 5 7 9
    std::cout << "even: "; for (int& x : even) std::cout << ' ' << x; std::cout << '\n'; // 2 4 6 8
}

{
    std::vector<int> foo{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    std::vector<int> odd;

    std::partition(foo.begin(), foo.end(), IsOdd);

    auto it = std::partition_point(foo.begin(), foo.end(), IsOdd);
    odd.assign(foo.begin(), it);

    // print contents of odd:
    std::cout << "odd:";
    for (int& x : odd) std::cout << ' ' << x; // 1 9 3 7 5
    std::cout << '\n';
}

{
    std::vector<int> myvector;

    // set some values:
    for (int i = 1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9

    std::vector<int>::iterator bound;
    bound = std::stable_partition(myvector.begin(), myvector.end(), IsOdd);

    // print out content:
    std::cout << "odd elements:";
    for (std::vector<int>::iterator it = myvector.begin(); it != bound; ++it)
        std::cout << ' ' << *it; // 1 3 5 7 9
    std::cout << '\n';

    std::cout << "even elements:";
    for (std::vector<int>::iterator it = bound; it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 2 4 6 8
    std::cout << '\n';
}

    return 0;
}

//////////////////////////////////////
int test_algorithm_permutation()
{
{
    std::array<int, 5> foo = { 1, 2, 3, 4, 5 };
    std::array<int, 5> bar = { 3, 1, 4, 5, 2 };

    if (std::is_permutation(foo.begin(), foo.end(), bar.begin()))
        std::cout << "foo and bar contain the same elements.\n"; // foo and bar contain the same elements
}

{
    int myints[] = { 1, 2, 3 };

    std::sort(myints, myints + 3);

    std::cout << "The 3! possible permutations with 3 elements:\n";
    do {
        std::cout << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n';
    } while (std::next_permutation(myints, myints + 3));

    std::cout << "After loop: " << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n'; // 1 2 3
}

{
    int myints[] = { 1, 2, 3 };

    std::sort(myints, myints + 3);
    std::reverse(myints, myints + 3);

    std::cout << "The 3! possible permutations with 3 elements:\n";
    do {
        std::cout << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n';
    } while (std::prev_permutation(myints, myints + 3));

    std::cout << "After loop: " << myints[0] << ' ' << myints[1] << ' ' << myints[2] << '\n'; // 3 2 1
}

    return 0;
}

/////////////////////////////////////////////
struct myclass2 {
    bool operator() (int i, int j) { return (i<j); }
} myobject2;

bool compare_as_ints(double i, double j) { return (int(i)<int(j)); }

int test_algorithm_sort()
{
{
    std::array<int, 4> foo{ 2, 4, 1, 3 };

    do {
        // try a new permutation:
        std::prev_permutation(foo.begin(), foo.end());

        // print range:
        std::cout << "foo:";
        for (int& x : foo) std::cout << ' ' << x;
        std::cout << '\n';

    } while (!std::is_sorted(foo.begin(), foo.end()));

    std::cout << "the range is sorted!\n";
}

{
    std::array<int, 4> foo{ 2, 4, 1, 3 };
    std::array<int, 4>::iterator it;

    do {
        // try a new permutation:
        std::prev_permutation(foo.begin(), foo.end());

        // print range:
        std::cout << "foo:";
        for (int& x : foo) std::cout << ' ' << x;
        it = std::is_sorted_until(foo.begin(), foo.end());
        std::cout << " (" << (it - foo.begin()) << " elements sorted)\n";

    } while (it != foo.end());

    std::cout << "the range is sorted!\n";
}

{
    std::vector<int> myvector;

    // set some values:
    for (int i = 1; i<10; i++) myvector.push_back(i);   // 1 2 3 4 5 6 7 8 9

    std::random_shuffle(myvector.begin(), myvector.end());

    // using default comparison (operator <):
    std::nth_element(myvector.begin(), myvector.begin() + 5, myvector.end());

    // using function as comp
    std::nth_element(myvector.begin(), myvector.begin() + 5, myvector.end(), myfunction2);

    // print out content:
    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 1 2 3 4 5 6 7 8 9
    std::cout << '\n';
}

{
    int myints[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
    std::vector<int> myvector(myints, myints + 9);

    // using default comparison (operator <):
    std::partial_sort(myvector.begin(), myvector.begin() + 5, myvector.end());

    // using function as comp
    std::partial_sort(myvector.begin(), myvector.begin() + 5, myvector.end(), myfunction2);

    // print out content:
    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 1 2 3 4 5 9 8 7 6
    std::cout << '\n';
}

{
    int myints[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
    std::vector<int> myvector(5);

    // using default comparison (operator <):
    std::partial_sort_copy(myints, myints + 9, myvector.begin(), myvector.end());

    // using function as comp
    std::partial_sort_copy(myints, myints + 9, myvector.begin(), myvector.end(), myfunction2);

    // print out content:
    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 1 2 3 4 5
    std::cout << '\n';
}

{
    int myints[] = { 32, 71, 12, 45, 26, 80, 53, 33 };
    std::vector<int> myvector(myints, myints + 8);               // 32 71 12 45 26 80 53 33

    // using default comparison (operator <):
    std::sort(myvector.begin(), myvector.begin() + 4);           //(12 32 45 71)26 80 53 33

    // using function as comp
    std::sort(myvector.begin() + 4, myvector.end(), myfunction2); // 12 32 45 71(26 33 53 80)

    // using object as comp
    std::sort(myvector.begin(), myvector.end(), myobject2);     //(12 26 32 33 45 53 71 80)

    // print out content:
    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 12 26 32 33 45 53 71 80
    std::cout << '\n';
}

{
    double mydoubles[] = { 3.14, 1.41, 2.72, 4.67, 1.73, 1.32, 1.62, 2.58 };

    std::vector<double> myvector;

    myvector.assign(mydoubles, mydoubles + 8);

    std::cout << "using default comparison:";
    std::stable_sort(myvector.begin(), myvector.end());
    for (std::vector<double>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 1.32 1.41 1.62 1.73 2.58 2.72 3.14 4.67
    std::cout << '\n';

    myvector.assign(mydoubles, mydoubles + 8);

    std::cout << "using 'compare_as_ints' :";
    std::stable_sort(myvector.begin(), myvector.end(), compare_as_ints);
    for (std::vector<double>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 1.41 1.73 1.32 1.62 2.72 2.58 3.14 4.67
    std::cout << '\n';
}

    return 0;
}

////////////////////////////////////////////////////
int test_algorithm_swap()
{
{
    int myints[] = { 10, 20, 30, 40, 50 };              //   myints:  10  20  30  40  50
    std::vector<int> myvector(4, 99);                   // myvector:  99  99  99  99

    std::iter_swap(myints, myvector.begin());     //   myints: [99] 20  30  40  50
                              // myvector: [10] 99  99  99

    std::iter_swap(myints + 3, myvector.begin() + 2); //   myints:  99  20  30 [99] 50
                                  // myvector:  10  99 [40] 99

    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 10 99 40 99
    std::cout << '\n';
}

{
    int x = 10, y = 20;                              // x:10 y:20
    std::swap(x, y);                                 // x:20 y:10

    std::vector<int> foo(4, x), bar(6, y);       // foo:4x20 bar:6x10
    std::swap(foo, bar);                         // foo:6x10 bar:4x20

    std::cout << "foo contains:";
    for (std::vector<int>::iterator it = foo.begin(); it != foo.end(); ++it)
        std::cout << ' ' << *it; // 10 10 10 10 10 10
    std::cout << '\n';
}

{
    std::vector<int> foo(5, 10);        // foo: 10 10 10 10 10
    std::vector<int> bar(5, 33);        // bar: 33 33 33 33 33

    std::swap_ranges(foo.begin() + 1, foo.end() - 1, bar.begin());

    // print out results of swap:
    std::cout << "foo contains:";
    for (std::vector<int>::iterator it = foo.begin(); it != foo.end(); ++it)
        std::cout << ' ' << *it; // 10 33 33 33 10
    std::cout << '\n';

    std::cout << "bar contains:";
    for (std::vector<int>::iterator it = bar.begin(); it != bar.end(); ++it)
        std::cout << ' ' << *it; // 10 10 10 33 33
    std::cout << '\n';
}

    return 0;
}

///////////////////////////////////////////////
static bool mycomp(char c1, char c2) { return std::tolower(c1)<std::tolower(c2); }

int test_algorithm_lexicographical_compare()
{
    char foo[] = "Apple";
    char bar[] = "apartment";

    std::cout << std::boolalpha;

    std::cout << "Comparing foo and bar lexicographically (foo<bar):\n";

    std::cout << "Using default comparison (operator<): ";
    std::cout << std::lexicographical_compare(foo, foo + 5, bar, bar + 9); // true
    std::cout << '\n';

    std::cout << "Using mycomp as comparison object: ";
    std::cout << std::lexicographical_compare(foo, foo + 5, bar, bar + 9, mycomp); // false
    std::cout << '\n';

    return 0;
}

//////////////////////////////////////
static bool myfn(int i, int j) { return i<j; }

int test_algorithm_min_max()
{
{
    std::cout << "min(1, 2)==" << std::min(1, 2) << '\n'; // 1
    std::cout << "min(2, 1)==" << std::min(2, 1) << '\n'; // 1
    std::cout << "min('a', 'z')==" << std::min('a', 'z') << '\n'; // a
    std::cout << "min(3.14, 2.72)==" << std::min(3.14, 2.72) << '\n'; // 2.72
}

{
    int myints[] = { 3, 7, 2, 5, 6, 4, 9 };

    // using default comparison:
    std::cout << "The smallest element is " << *std::min_element(myints, myints + 7) << '\n'; // 2
    std::cout << "The largest element is " << *std::max_element(myints, myints + 7) << '\n'; // 9

    // using function myfn as comp:
    std::cout << "The smallest element is " << *std::min_element(myints, myints + 7, myfn) << '\n'; // 2
    std::cout << "The largest element is " << *std::max_element(myints, myints + 7, myfn) << '\n'; // 9

    // using object myobj as comp:
    std::cout << "The smallest element is " << *std::min_element(myints, myints + 7, myobject2) << '\n'; // 2
    std::cout << "The largest element is " << *std::max_element(myints, myints + 7, myobject2) << '\n'; // 9
}

{
    std::cout << "max(1,2)==" << std::max(1, 2) << '\n'; // 2
    std::cout << "max(2,1)==" << std::max(2, 1) << '\n'; // 2
    std::cout << "max('a','z')==" << std::max('a', 'z') << '\n'; // z
    std::cout << "max(3.14,2.73)==" << std::max(3.14, 2.73) << '\n'; // 3.14
}

{
    auto result = std::minmax({ 1, 2, 3, 4, 5 });

    std::cout << "minmax({1,2,3,4,5}): ";
    std::cout << result.first << ' ' << result.second << '\n'; // 1 5
}

{
    std::array<int, 7> foo{ 3, 7, 2, 9, 5, 8, 6 };

    auto result = std::minmax_element(foo.begin(), foo.end());

    // print result:
    std::cout << "min is " << *result.first; // 2
    std::cout << ", at position " << (result.first - foo.begin()) << '\n'; // 2
    std::cout << "max is " << *result.second; // 9
    std::cout << ", at position " << (result.second - foo.begin()) << '\n'; // 3
}

    return 0;
}

///////////////////////////////////////////
int test_algorithm_mismatch()
{
    std::vector<int> myvector;
    for (int i = 1; i<6; i++) myvector.push_back(i * 10); // myvector: 10 20 30 40 50

    int myints[] = { 10, 20, 80, 320, 1024 };                //   myints: 10 20 80 320 1024

    std::pair<std::vector<int>::iterator, int*> mypair;

    // using default comparison:
    mypair = std::mismatch(myvector.begin(), myvector.end(), myints);
    std::cout << "First mismatching elements: " << *mypair.first; // 30
    std::cout << " and " << *mypair.second << '\n'; // 80

    ++mypair.first; ++mypair.second;

    // using predicate comparison:
    mypair = std::mismatch(mypair.first, myvector.end(), mypair.second, mypredicate);
    std::cout << "Second mismatching elements: " << *mypair.first; // 40
    std::cout << " and " << *mypair.second << '\n'; // 320

    return 0;
}

//////////////////////////////////////////
/* The behavior of std::move_backward template is equivalent to:
template<class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2 move_backward ( BidirectionalIterator1 first,
    BidirectionalIterator1 last,
    BidirectionalIterator2 result )
{
    while (last!=first) *(--result) = std::move(*(--last));
    return result;
}
*/
int test_algorithm_move()
{
{
    std::vector<std::string> foo = { "air", "water", "fire", "earth" };
    std::vector<std::string> bar(4);

    // moving ranges:
    std::cout << "Moving ranges...\n";
    std::move(foo.begin(), foo.begin() + 4, bar.begin());

    std::cout << "foo contains " << foo.size() << " elements:";// 4
    std::cout << " (each in an unspecified but valid state)";
    std::cout << '\n';

    std::cout << "bar contains " << bar.size() << " elements:"; // 4
    for (std::string& x : bar) std::cout << " [" << x << "]"; // [air] [water] [fire] [earch]
    std::cout << '\n';

    // moving container:
    std::cout << "Moving container...\n";
    foo = std::move(bar);

    std::cout << "foo contains " << foo.size() << " elements:"; // 4
    for (std::string& x : foo) std::cout << " [" << x << "]"; // [air] [water] [fire] [earch]
    std::cout << '\n';
    std::cout << "bar contains " << bar.size() << " elements" << std::endl; // 0
    //std::cout << "bar is in an unspecified but valid state";
    //std::cout << '\n';
}

{
    std::string elems[10] = { "air", "water", "fire", "earth" };

    // insert new element at the beginning:
    std::move_backward(elems, elems + 4, elems + 5);
    elems[0] = "ether";

    std::cout << "elems contains:";
    for (int i = 0; i<10; ++i)
        std::cout << " [" << elems[i] << "]"; // [ether] [air] [water] [fire] [earch]
    std::cout << '\n';
}

    return 0;
}

//////////////////////////////////////////////
// random generator function:
int myrandom(int i) { return std::rand() % i; }

int test_algorithm_shuffle()
{
{
    std::srand(unsigned(std::time(0)));
    std::vector<int> myvector;

    // set some values:
    for (int i = 1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9

    // using built-in random generator:
    std::random_shuffle(myvector.begin(), myvector.end());

    // using myrandom:
    std::random_shuffle(myvector.begin(), myvector.end(), myrandom);

    // print out content:
    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it;

    std::cout << '\n';
}

{
    std::array<int, 5> foo{ 1, 2, 3, 4, 5 };

    // obtain a time-based seed:
    unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();

    shuffle(foo.begin(), foo.end(), std::default_random_engine(seed));

    std::cout << "shuffled elements:";
    for (int& x : foo) std::cout << ' ' << x;
    std::cout << '\n';
}

    return 0;
}

//////////////////////////////////////////
int test_algorithm_remove()
{
{
    int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };      // 10 20 30 30 20 10 10 20

    // bounds of range:
    int* pbegin = myints;                                   // ^
    int* pend = myints + sizeof(myints) / sizeof(int);      // ^                       ^

    pend = std::remove(pbegin, pend, 20);                   // 10 30 30 10 10 ?  ?  ?
                                                            // ^              ^
    std::cout << "range contains:";
    for (int* p = pbegin; p != pend; ++p)
        std::cout << ' ' << *p; // 10 30 30 10 10
    std::cout << '\n';
}

{
    int myints[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };            // 1 2 3 4 5 6 7 8 9

    // bounds of range:
    int* pbegin = myints;                                    // ^
    int* pend = myints + sizeof(myints) / sizeof(int);       // ^                 ^

    pend = std::remove_if(pbegin, pend, IsOdd);              // 2 4 6 8 ? ? ? ? ?
                                                             // ^       ^
    std::cout << "the range contains:";
    for (int* p = pbegin; p != pend; ++p)
        std::cout << ' ' << *p; // 2 4 6 8
    std::cout << '\n';
}

{
    int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };               // 10 20 30 30 20 10 10 20
    std::vector<int> myvector(8);

    std::remove_copy(myints, myints + 8, myvector.begin(), 20);      // 10 30 30 10 10 0 0 0

    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 10 30 30 10 10 0 0 0
    std::cout << '\n';
}

{
    int myints[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    std::vector<int> myvector(9);

    std::remove_copy_if(myints, myints + 9, myvector.begin(), IsOdd);

    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 2 4 6 8 0 0 0 0 0
    std::cout << '\n';
}

    return 0;
}

//////////////////////////////////////////////
int test_algorithm_replace()
{
{
    int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };
    std::vector<int> myvector(myints, myints + 8);            // 10 20 30 30 20 10 10 20

    std::replace(myvector.begin(), myvector.end(), 20, 99);   // 10 99 30 30 99 10 10 99

    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 10 99 30 30 99 10 10 99
    std::cout << '\n';
}

{
    std::vector<int> myvector;

    // set some values:
    for (int i = 1; i<10; i++) myvector.push_back(i);               // 1 2 3 4 5 6 7 8 9

    std::replace_if(myvector.begin(), myvector.end(), IsOdd, 0);    // 0 2 0 4 0 6 0 8 0

    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 0 2 0 4 0 6 0 8 0
    std::cout << '\n';
}

{
    int myints[] = { 10, 20, 30, 30, 20, 10, 10, 20 };

    std::vector<int> myvector(8);
    std::replace_copy(myints, myints + 8, myvector.begin(), 20, 99);

    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 10 99 30 30 99 10 10 99
    std::cout << '\n';
}

{
    std::vector<int> foo, bar;

    // set some values:
    for (int i = 1; i<10; i++) foo.push_back(i);                         // 1 2 3 4 5 6 7 8 9

    bar.resize(foo.size());   // allocate space
    std::replace_copy_if(foo.begin(), foo.end(), bar.begin(), IsOdd, 0); // 0 2 0 4 0 6 0 8 0

    std::cout << "bar contains:";
    for (std::vector<int>::iterator it = bar.begin(); it != bar.end(); ++it)
        std::cout << ' ' << *it; // 0 2 0 4 0 6 0 8 0
    std::cout << '\n';
}

    return 0;
}

///////////////////////////////////////////////////
int test_algorithm_reverse()
{
{
    std::vector<int> myvector;

    // set some values:
    for (int i = 1; i<10; ++i) myvector.push_back(i);   // 1 2 3 4 5 6 7 8 9

    std::reverse(myvector.begin(), myvector.end());     // 9 8 7 6 5 4 3 2 1

    // print out content:
    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 9 8 7 6 5 4 3 2 1
    std::cout << '\n';
}

{
    int myints[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    std::vector<int> myvector;

    myvector.resize(9);    // allocate space

    std::reverse_copy(myints, myints + 9, myvector.begin());

    // print out content:
    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 9 8 7 6 5 4 3 2 1

    std::cout << '\n';
}

    return 0;
}

////////////////////////////////////////////
/*
The behavior of std::rotate template (C++98) is equivalent to:
template <class ForwardIterator>
void rotate (ForwardIterator first, ForwardIterator middle, ForwardIterator last)
{
    ForwardIterator next = middle;
    while (first!=next) {
        swap (*first++,*next++);
        if (next==last) next=middle;
        else if (first==middle) middle=next;
    }
}
*/

int test_algorithm_rotate()
{
{
    std::vector<int> myvector;

    // set some values:
    for (int i = 1; i<10; ++i) myvector.push_back(i);                    // 1 2 3 4 5 6 7 8 9

    std::rotate(myvector.begin(), myvector.begin() + 3, myvector.end()); // 4 5 6 7 8 9 1 2 3
    // print out content:
    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 4 5 6 7 8 9 1 2 3
    std::cout << '\n';
}

{
    int myints[] = { 10, 20, 30, 40, 50, 60, 70 };

    std::vector<int> myvector(7);

    std::rotate_copy(myints, myints + 3, myints + 7, myvector.begin());

    // print out content:
    std::cout << "myvector contains:";
    for (std::vector<int>::iterator it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 40 50 60 70 10 20 30
    std::cout << '\n';
}

    return 0;
}

//////////////////////////////////////
/*
The behavior of std::set_difference template is equivalent to:
template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1,
    InputIterator2 first2, InputIterator2 last2, OutputIterator result)
{
    while (first1!=last1 && first2!=last2) {
        if (*first1<*first2) { *result = *first1; ++result; ++first1; }
        else if (*first2<*first1) ++first2;
        else { ++first1; ++first2; }
    }
    return std::copy(first1,last1,result);
}
*/

int test_algorithm_set()
{
{
    int first[] = { 5, 10, 15, 20, 25 };
    int second[] = { 50, 40, 30, 20, 10 };
    std::vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
    std::vector<int>::iterator it;

    std::sort(first, first + 5);     //  5 10 15 20 25
    std::sort(second, second + 5);   // 10 20 30 40 50

    it = std::set_difference(first, first + 5, second, second + 5, v.begin());
                               //  5 15 25  0  0  0  0  0  0  0
    v.resize(it - v.begin());                      //  5 15 25

    std::cout << "The difference has " << (v.size()) << " elements:\n"; // 3
    for (it = v.begin(); it != v.end(); ++it)
        std::cout << ' ' << *it; // 5 15 25
    std::cout << '\n';
}

{
    int first[] = { 5, 10, 15, 20, 25 };
    int second[] = { 50, 40, 30, 20, 10 };
    std::vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
    std::vector<int>::iterator it;

    std::sort(first, first + 5);     //  5 10 15 20 25
    std::sort(second, second + 5);   // 10 20 30 40 50

    it = std::set_intersection(first, first + 5, second, second + 5, v.begin());
                                                   // 10 20 0  0  0  0  0  0  0  0
    v.resize(it - v.begin());                      // 10 20

    std::cout << "The intersection has " << (v.size()) << " elements:\n"; // 2
    for (it = v.begin(); it != v.end(); ++it)
        std::cout << ' ' << *it; // 10 20
    std::cout << '\n';
}

{
    int first[] = { 5, 10, 15, 20, 25 };
    int second[] = { 50, 40, 30, 20, 10 };
    std::vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
    std::vector<int>::iterator it;

    std::sort(first, first + 5);     //  5 10 15 20 25
    std::sort(second, second + 5);   // 10 20 30 40 50

    it = std::set_symmetric_difference(first, first + 5, second, second + 5, v.begin());
                               //  5 15 25 30 40 50  0  0  0  0
    v.resize(it - v.begin());                      //  5 15 25 30 40 50

    std::cout << "The symmetric difference has " << (v.size()) << " elements:\n"; // 6
    for (it = v.begin(); it != v.end(); ++it)
        std::cout << ' ' << *it; // 5 15 25 30 40 50
    std::cout << '\n';
}

{
    int first[] = { 5, 10, 15, 20, 25 };
    int second[] = { 50, 40, 30, 20, 10 };
    std::vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
    std::vector<int>::iterator it;

    std::sort(first, first + 5);     //  5 10 15 20 25
    std::sort(second, second + 5);   // 10 20 30 40 50

    it = std::set_union(first, first + 5, second, second + 5, v.begin());
                               // 5 10 15 20 25 30 40 50  0  0
    v.resize(it - v.begin());                      // 5 10 15 20 25 30 40 50

    std::cout << "The union has " << (v.size()) << " elements:\n"; // 8
    for (it = v.begin(); it != v.end(); ++it)
        std::cout << ' ' << *it; // 5 10 15 20 25 30 40 50
    std::cout << '\n';
}

    return 0;
}

/////////////////////////////////////
int op_increase(int i) { return ++i; }

int test_algorithm_transform()
{
    std::vector<int> foo;
    std::vector<int> bar;

    // set some values:
    for (int i = 1; i<6; i++)
        foo.push_back(i * 10);                         // foo: 10 20 30 40 50

    bar.resize(foo.size());                         // allocate space

    std::transform(foo.begin(), foo.end(), bar.begin(), op_increase);
                                                           // bar: 11 21 31 41 51

    // std::plus adds together its two arguments:
    std::transform(foo.begin(), foo.end(), bar.begin(), foo.begin(), std::plus<int>());
                                                           // foo: 21 41 61 81 101

    std::cout << "foo contains:";
    for (std::vector<int>::iterator it = foo.begin(); it != foo.end(); ++it)
        std::cout << ' ' << *it; // 21 41 61 81 101
    std::cout << '\n';

    return 0;
}

/////////////////////////////////////////
int test_algorithm_unique()
{
{
    int myints[] = { 10, 20, 20, 20, 30, 30, 20, 20, 10 };           // 10 20 20 20 30 30 20 20 10
    std::vector<int> myvector(myints, myints + 9);

    // using default comparison:
    std::vector<int>::iterator it;
    it = std::unique(myvector.begin(), myvector.end());              // 10 20 30 20 10 ?  ?  ?  ?
                                                                     //                ^

    myvector.resize(std::distance(myvector.begin(), it));            // 10 20 30 20 10

    // using predicate comparison:
    std::unique(myvector.begin(), myvector.end(), myfunction);   // (no changes)

    // print out content:
    std::cout << "myvector contains:";
    for (it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 10 20 30 20 10
    std::cout << '\n';
}

{
    int myints[] = { 10, 20, 20, 20, 30, 30, 20, 20, 10 };
    std::vector<int> myvector(9);                                   // 0  0  0  0  0  0  0  0  0

    // using default comparison:
    std::vector<int>::iterator it;
    it = std::unique_copy(myints, myints + 9, myvector.begin());   // 10 20 30 20 10 0  0  0  0
                                                                   //                ^

    std::sort(myvector.begin(), it);                               // 10 10 20 20 30 0  0  0  0
                                                                   //                ^

    // using predicate comparison:
    it = std::unique_copy(myvector.begin(), it, myvector.begin(), myfunction);
                                                                   // 10 20 30 20 30 0  0  0  0
                                                                   //          ^

    myvector.resize(std::distance(myvector.begin(), it));    // 10 20 30

    // print out content:
    std::cout << "myvector contains:";
    for (it = myvector.begin(); it != myvector.end(); ++it)
        std::cout << ' ' << *it; // 10 20 30
    std::cout << '\n';
}

    return 0;
}

} // namespace algorithm_