FM / algorithm

/usr/include/boost/algorithm

Name	Size	Mode	Actions
cxx11/	-	0755	rm
cxx14/	-	0755	rm
cxx17/	-	0755	rm
searching/	-	0755	rm
string/	-	0755	rm
algorithm.hpp	2421	0644	edit dl rm
apply_permutation.hpp	4512	0644	edit dl rm
clamp.hpp	7917	0644	edit dl rm
find_backward.hpp	2523	0644	edit dl rm
find_not.hpp	986	0644	edit dl rm
gather.hpp	4164	0644	edit dl rm
hex.hpp	13122	0644	edit dl rm
is_palindrome.hpp	4279	0644	edit dl rm
is_partitioned_until.hpp	2576	0644	edit dl rm
minmax.hpp	1281	0644	edit dl rm
minmax_element.hpp	17488	0644	edit dl rm
sort_subrange.hpp	3611	0644	edit dl rm
string.hpp	1061	0644	edit dl rm
string_regex.hpp	730	0644	edit dl rm

Edit: /usr/include/boost/algorithm/is_palindrome.hpp (4279B)

/*
  Copyright (c) Alexander Zaitsev <zamazan4ik@gmail.com>, 2016

Distributed under the Boost Software License, Version 1.0. (See
  accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt)

See http://www.boost.org/ for latest version.
*/

/// \file  is_palindrome.hpp
/// \brief Checks the input sequence on palindrome.
/// \author Alexander Zaitsev

#ifndef BOOST_ALGORITHM_IS_PALINDROME_HPP
#define BOOST_ALGORITHM_IS_PALINDROME_HPP

#include <iterator>
#include <functional>
#include <cstring>

#include <boost/config.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>

namespace boost {  namespace algorithm {

/// \fn is_palindrome ( BidirectionalIterator begin, BidirectionalIterator end, Predicate p )
/// \return true if the entire sequence is palindrome
///
/// \param begin    The start of the input sequence
/// \param end		One past the end of the input sequence
/// \param p        A predicate used to compare the values.
///
/// \note This function will return true for empty sequences and for palindromes.
///     For other sequences function will return false.
///     Complexity: O(N).
template <typename BidirectionalIterator, typename Predicate>
bool is_palindrome(BidirectionalIterator begin, BidirectionalIterator end, Predicate p)
{
    if(begin == end)
    {
        return true;
    }

--end;
    while(begin != end)
    {
        if(!p(*begin, *end))
        {
            return false;
        }
        ++begin;
        if(begin == end)
        {
            break;
        }
        --end;
    }
    return true;
}

/// \fn is_palindrome ( BidirectionalIterator begin, BidirectionalIterator end )
/// \return true if the entire sequence is palindrome
///
/// \param begin    The start of the input sequence
/// \param end	    One past the end of the input sequence
///
/// \note This function will return true for empty sequences and for palindromes.
///     For other sequences function will return false.
///     Complexity: O(N).
template <typename BidirectionalIterator>
bool is_palindrome(BidirectionalIterator begin, BidirectionalIterator end)
{
    return is_palindrome(begin, end,
                         std::equal_to<typename std::iterator_traits<BidirectionalIterator>::value_type> ());
}

/// \fn is_palindrome ( const R& range )
/// \return true if the entire sequence is palindrome
///
/// \param range The range to be tested.
///
/// \note This function will return true for empty sequences and for palindromes.
///     For other sequences function will return false.
///     Complexity: O(N).
template <typename R>
bool is_palindrome(const R& range)
{
    return is_palindrome(boost::begin(range), boost::end(range));
}

/// \fn is_palindrome ( const R& range, Predicate p )
/// \return true if the entire sequence is palindrome
///
/// \param range The range to be tested.
/// \param p     A predicate used to compare the values.
///
/// \note This function will return true for empty sequences and for palindromes.
///     For other sequences function will return false.
///     Complexity: O(N).
template <typename R, typename Predicate>
bool is_palindrome(const R& range, Predicate p)
{
    return is_palindrome(boost::begin(range), boost::end(range), p);
}

/// \fn is_palindrome ( const char* str )
/// \return true if the entire sequence is palindrome
///
/// \param str C-string to be tested.
///
/// \note This function will return true for empty sequences and for palindromes.
///     For other sequences function will return false.
///     Complexity: O(N).
bool is_palindrome(const char* str)
{
    if(!str)
	    return true;
    return is_palindrome(str, str + strlen(str));
}

/// \fn is_palindrome ( const char* str, Predicate p )
/// \return true if the entire sequence is palindrome
///
/// \param str C-string to be tested.
/// \param p   A predicate used to compare the values.
///
/// \note This function will return true for empty sequences and for palindromes.
///     For other sequences function will return false.
///     Complexity: O(N).
template<typename Predicate>
bool is_palindrome(const char* str, Predicate p)
{
    if(!str)
	    return true;
    return is_palindrome(str, str + strlen(str), p);
}
}}

#endif // BOOST_ALGORITHM_IS_PALINDROME_HPP

/* Copyright (c) Alexander Zaitsev , 2016 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) See http://www.boost.org/ for latest version. */ /// \file is_palindrome.hpp /// \brief Checks the input sequence on palindrome. /// \author Alexander Zaitsev #ifndef BOOST_ALGORITHM_IS_PALINDROME_HPP #define BOOST_ALGORITHM_IS_PALINDROME_HPP #include #include #include #include #include #include namespace boost { namespace algorithm { /// \fn is_palindrome ( BidirectionalIterator begin, BidirectionalIterator end, Predicate p ) /// \return true if the entire sequence is palindrome /// /// \param begin The start of the input sequence /// \param end One past the end of the input sequence /// \param p A predicate used to compare the values. /// /// \note This function will return true for empty sequences and for palindromes. /// For other sequences function will return false. /// Complexity: O(N). template bool is_palindrome(BidirectionalIterator begin, BidirectionalIterator end, Predicate p) { if(begin == end) { return true; } --end; while(begin != end) { if(!p(*begin, *end)) { return false; } ++begin; if(begin == end) { break; } --end; } return true; } /// \fn is_palindrome ( BidirectionalIterator begin, BidirectionalIterator end ) /// \return true if the entire sequence is palindrome /// /// \param begin The start of the input sequence /// \param end One past the end of the input sequence /// /// \note This function will return true for empty sequences and for palindromes. /// For other sequences function will return false. /// Complexity: O(N). template bool is_palindrome(BidirectionalIterator begin, BidirectionalIterator end) { return is_palindrome(begin, end, std::equal_to::value_type> ()); } /// \fn is_palindrome ( const R& range ) /// \return true if the entire sequence is palindrome /// /// \param range The range to be tested. /// /// \note This function will return true for empty sequences and for palindromes. /// For other sequences function will return false. /// Complexity: O(N). template bool is_palindrome(const R& range) { return is_palindrome(boost::begin(range), boost::end(range)); } /// \fn is_palindrome ( const R& range, Predicate p ) /// \return true if the entire sequence is palindrome /// /// \param range The range to be tested. /// \param p A predicate used to compare the values. /// /// \note This function will return true for empty sequences and for palindromes. /// For other sequences function will return false. /// Complexity: O(N). template bool is_palindrome(const R& range, Predicate p) { return is_palindrome(boost::begin(range), boost::end(range), p); } /// \fn is_palindrome ( const char* str ) /// \return true if the entire sequence is palindrome /// /// \param str C-string to be tested. /// /// \note This function will return true for empty sequences and for palindromes. /// For other sequences function will return false. /// Complexity: O(N). bool is_palindrome(const char* str) { if(!str) return true; return is_palindrome(str, str + strlen(str)); } /// \fn is_palindrome ( const char* str, Predicate p ) /// \return true if the entire sequence is palindrome /// /// \param str C-string to be tested. /// \param p A predicate used to compare the values. /// /// \note This function will return true for empty sequences and for palindromes. /// For other sequences function will return false. /// Complexity: O(N). template bool is_palindrome(const char* str, Predicate p) { if(!str) return true; return is_palindrome(str, str + strlen(str), p); } }} #endif // BOOST_ALGORITHM_IS_PALINDROME_HPP