Return to Answer

Following is my solution. It's much less code. It also handles the case of string literals correctly (e.g., is_palindrome("aba")).

In modern C++ (11 and onward), there is no need to differentiate predicate and non-predicate versions of generic algorithms. The fact that the standard library does overload predicate and non-predicate versions is simply due to historical reasons. See this S.O. topic for details.

#include <functional>
#include <iterator>
#include <utility>
template <typename Iterator, typename Pred = std::equal_to<void>>
bool is_palindrome(Iterator beg, Iterator end, Pred pred = Pred{}) {
 if (beg == end) return true;
 end = std::prev(end);
 if (beg == end) return true;
 do {
 if (! pred(*beg++, *end--)) return false;
 }
 while (beg != end && beg != std::next(end));
 return true;
}
template <typename T, typename Pred = std::equal_to<void>>
bool is_palindrome(const T& x, Pred pred = Pred{}) {
 return is_palindrome(std::begin(x), std::end(x), std::move(pred));
}
template <std::size_t n, typename Pred = std::equal_to<void>>
bool is_palindrome(const char (&x)[n], Pred pred = Pred{}) {
 return is_palindrome(x, x + n - 1, std::move(pred));
}

Following is my solution. It's much less code. It also handles the case of string literals correctly (e.g., is_palindrome("aba")).

In modern C++ (11 and onward), there is no need to differentiate predicate and non-predicate versions of generic algorithms. The fact that the standard library does overload predicate and non-predicate versions is simply due to historical reasons. See this S.O. topic for details.

#include <functional>
#include <iterator>
#include <utility>
template <typename Iterator, typename Pred = std::equal_to<void>>
bool is_palindrome(Iterator beg, Iterator end, Pred pred = Pred{}) {
 if (beg == end) return true;
 end = std::prev(end);
 if (beg == end) return true;
 do {
 if (! pred(*beg++, *end--)) return false;
 }
 while (beg != end && beg != std::next(end));
 return true;
}
template <typename T, typename Pred = std::equal_to<void>>
bool is_palindrome(const T& x, Pred pred = Pred{}) {
 return is_palindrome(std::begin(x), std::end(x), std::move(pred));
}
template <std::size_t n, typename Pred = std::equal_to<void>>
bool is_palindrome(const char (&x)[n], Pred pred = Pred{}) {
 return is_palindrome(x, x + n - 1, std::move(pred));
}

Following is my solution. It's much less code. It also handles the case of string literals correctly (e.g., is_palindrome("aba")).

#include <functional>
#include <iterator>
#include <utility>
template <typename Iterator, typename Pred = std::equal_to<void>>
bool is_palindrome(Iterator beg, Iterator end, Pred pred = Pred{}) {
 if (beg == end) return true;
 end = std::prev(end);
 if (beg == end) return true;
 do {
 if (! pred(*beg++, *end--)) return false;
 }
 while (beg != end && beg != std::next(end));
 return true;
}
template <typename T, typename Pred = std::equal_to<void>>
bool is_palindrome(const T& x, Pred pred = Pred{}) {
 return is_palindrome(std::begin(x), std::end(x), std::move(pred));
}
template <std::size_t n, typename Pred = std::equal_to<void>>
bool is_palindrome(const char (&x)[n], Pred pred = Pred{}) {
 return is_palindrome(x, x + n - 1, std::move(pred));
}

Following is my solution. It's much less code. It also handles the case of string literals correctly (e.g., is_palindrome("aba")).

In modern C++ (11 and onward), there is no need to differentiate predicate and non-predicate versions of generic algorithms. The fact that the standard library does overload predicate and non-predicate versions is simply due to historical reasons. See this S.O. topic for details.

#include <functional>
#include <iterator>
#include <utility>
template <typename Iterator, typename Pred = std::equal_to<void>>
bool is_palindrome(Iterator beg, Iterator end, Pred pred = Pred{}) {
 if (beg == end) return true;
 end = std::prev(end);
 if (beg == end) return true;
 do {
 if (! pred(*beg++, *end--)) return false;
 }
 while (beg != end && beg != std::next(end));
 return true;
}
template <typename T, typename Pred = std::equal_to<void>>
bool is_palindrome(const T& x, Pred pred = Pred{}) {
 return is_palindrome(std::begin(x), std::end(x), std::move(pred));
}
template <std::size_t n, typename Pred = std::equal_to<void>>
bool is_palindrome(const char (&x)[n], Pred pred = Pred{}) {
 return is_palindrome(x, x + n - 1, std::move(pred));
}

Following is my solution. It's much less code.

#include <functional>
#include <iterator>
#include <utility>
template <typename Iterator, typename Pred = std::equal_to<void>>
bool is_palindrome(Iterator beg, Iterator end, Pred pred = Pred{}) {
 if (beg == end) return true;
 end = std::prev(end);
 if (beg == end) return true;
 do {
 if (! pred(*beg++, *end--)) return false;
 }
 while (beg != end && beg != std::next(end));
 return true;
}
template <typename T, typename Pred = std::equal_to<void>>
bool is_palindrome(const T& x, Pred pred = Pred{}) {
 return is_palindrome(std::begin(x), std::end(x), std::move(pred));
}

Following is my solution. It's much less code. It also handles the case of string literals correctly (e.g., is_palindrome("aba")).

#include <functional>
#include <iterator>
#include <utility>
template <typename Iterator, typename Pred = std::equal_to<void>>
bool is_palindrome(Iterator beg, Iterator end, Pred pred = Pred{}) {
 if (beg == end) return true;
 end = std::prev(end);
 if (beg == end) return true;
 do {
 if (! pred(*beg++, *end--)) return false;
 }
 while (beg != end && beg != std::next(end));
 return true;
}
template <typename T, typename Pred = std::equal_to<void>>
bool is_palindrome(const T& x, Pred pred = Pred{}) {
 return is_palindrome(std::begin(x), std::end(x), std::move(pred));
}
template <std::size_t n, typename Pred = std::equal_to<void>>
bool is_palindrome(const char (&x)[n], Pred pred = Pred{}) {
 return is_palindrome(x, x + n - 1, std::move(pred));
}