
{
    int r = a < b ? a : b;
}


{
    // r is the minimum of a and b
    int r = a < b ? a : b;
}


{
    int r = min(a, b);
}


/// Returns the minimum of two integers
int min(int a, int b) {
    return a < b ? a : b;
}


/// Returns the minimum of two integers
int min(int a, int b);


{
    vector a{0, 0, 1, 0, 1 };
    erase(a, a[0]);
}


{
    vector a{0, 0, 1, 0, 1 };
    erase(a, a[0]);
    display(a);
}


{
    vector a{0, 0, 1, 0, 1 };
    erase(a, copy(a[0]));
    display(a);
}


/// Transmogrify the elements in the range [f, l).
template <class ForwardIterator>
void transmogrify(ForwardIterator f, ForwardIterator l);


{
    /// removes values equal to a in the range [f, l)
    /// returns the position, b, such that [f, b) contains all the values in [f, l) not equal to a
    ///   values in the range [b, l) are unspecified
    auto remove = [](auto f, auto l, const auto& a) {
        auto b = find(f, l, a);
        if (b == l) return b;
        auto p = next(b);
        // invariant: all values in the range [f, b) do not equal x
        // decreasing: distance(p, l)
        while (p != l) {
            if (*p != a) {
                *b = std::move(*p);
                ++b;
            }
            ++p;
        }
        return b;
    };
    
    vector a{ 0, 0, 1, 0, 1 };
    a.erase(remove(begin(a), end(a), 0), end(a));

    display(a);
}


{
    int a[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    display(*find(begin(a), end(a), 5));
}


namespace bcc {

template <class T, class F>
constexpr void iota(T first, T last, F out) {
    for (; first != last; ++first) {
        out(first);
    }
}

} // namespace bcc


{
    vector<int> v;
    bcc::iota(0, 10, [&](int n) { v.push_back(n); });
    display(v);
}


{
    vector a{0, 1, 2, 3, 4, 5};

    erase_if(a, [n = 0](int x) mutable {
        return (x & 1) && !n++;
    });
    display(a);
}

template <class F, class P>
auto remove_if(F f, F l, P pred) {
    f = find_if(f, l, pred); // <-- pred is passed by value

    if (f == l) return f;

    for (auto p = next(f); p != l; ++p) {
        if (!pred(*p)) *f++ = move(*p);
    }
    return f;
}


{
    vector<int> a{0, 1, 2, 3, 4, 5};

    int n = 0;
    auto first_is_odd = [&n](int x) {
        return (x & 1) && !n++;
    };

    erase_if(a, first_is_odd);
    display(a);
}


namespace v0 {

template <class I>
void swirl(I f, I l) {
    auto m = next(f, distance(f, l) / 2);
    if (f == m) return;
    m = rotate(f, m, l);
    reverse(m, l);
    ++f;
    reverse(f, m);
}

} // namespace v0


{
    using namespace v0;

    int a[]{0, 1, 2, 3, 4, 5, 6, 7, 8};
    swirl(begin(a), end(a));

    display(a);
}


namespace v1 {

template <class I>
void swirl(I f, I l) {
    reverse(f, l);
    auto m = next(f, distance(f, l) / 2);
    if (m == l) return;
    rotate(f, m, next(m));
}

} // namespace v1


{
    using namespace v1;

    int a[]{0, 1, 2, 3, 4, 5, 6, 7, 8};
    swirl(begin(a), end(a));

    display(a);
}


namespace v2 {

template <class I>
I swirl(I f, I l) {
    reverse(f, l);
    auto m = next(f, distance(f, l) / 2);
    if (m == l) return m;
    rotate(f, m, next(m));
    return m;
}

} // namespace v1


template <class I> // I models RandomAccessIterator
void sort_subrange_0(I f, I l, I sf, I sl) {
    std::sort(f, l);
}

template <class I> // I models RandomAccessIterator
void sort_subrange(I f, I l, I sf, I sl) {
    if (f != sf && sf != l) {
        std::nth_element(f, sf, l); // partition [f, l) at sf
        ++sf;
    }
    std::partial_sort(sf, sl, l);
}


{
    int a[]{ 0, 1, 2, 3, 3, 3, 4, 4, 5, 6 };
    auto p = lower_bound(begin(a), end(a), 3);
    display(a);
    cout << string(distance(begin(a), p) * 3 + 1, ' ') << "^\n";
}


{
    struct employee {
        string _first;
        string _last;
    };

    employee a[]{{"Joe", "Zimmer"}, {"Frank", "Berse"}};

    sort(begin(a), end(a), [](const employee& a, const employee& b) {
        return a._last < b._last;
    });
    auto p = lower_bound(begin(a), end(a), "Zimmer"s, [](const employee& a, const string& b) {
        return a._last < b;
    });

    display(p->_first);
}

{
    struct employee {
        string _first;
        string _last;
    };

    employee a[]{{"Joe", "Zimmer"}, {"Frank", "Berse"}};

    ranges::sort(a, less<>(), &employee::_last);
    auto p = ranges::lower_bound(a, "Zimmer"s, less<>(), &employee::_last);

    display(p->_first);
}

Algorithms¶

Naming a Function (Guidelines)¶

Specifying a Function¶

Argument Types¶

Implicit Preconditions¶

Object Lifetimes¶

Validity¶

Law of Exclusivity¶

Ranges¶

Implicit Postconditions¶

Validity of References¶

Loops and Recursion¶

Sequences¶

Common algorithms and their uses¶

Generic Algorithms¶

Requirements and Guarantees¶

Concept¶

Model¶

Contracts¶

Precondition¶

Postcondition¶

Class Invariant¶

Concepts, Partial Functions, and Domain¶

Axes of Freedom¶

OutputIterators and sink functions¶

Algorithm Semantics¶

Positional Permutations¶

Predicate Permutations¶

Comparison Permutations¶

Operations on sorted sequences¶

Projections¶

Iterator hierarchy (and why you probably shouldn't care)¶

Composition vs. multi-pass¶

Generators vs input iterator¶

Heap operations¶