Check string is permutation of palindrome I assume there can be space in between and I have ignored that. Also, there will be only lower case characters in the string.   

My logic: There can be only one occurrence of odd number of character in palindrome string. 

#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;unordered_map&gt;

using std::cout;
using std::endl;


int main(int argc, const char * argv[]) {


    char arr[] = "tact coa";

    std::unordered_map&lt;char, int&gt; m;

    size_t len = strlen(arr);

    for (int i = 0; i&lt;len; i++) {

        if(arr[i] == ' ') continue; //ignoring space

        if(m.find(arr[i]) == m.end())
        {
             m[arr[i]] = 1;

        }
        else{
            m[arr[i]]++;
        }
    }

    int count = 0;

    for (int i = 0; i&lt;len; i++) {

        if((m[arr[i]] % 2) == 1)count++;

    }
    if(count &gt; 1) {cout&lt;&lt;"Not Palindrom"&lt;&lt;endl;}
    else {cout&lt;&lt;"Palindrom"&lt;&lt;endl;}

    return 0;
}
I would separate the algorithm from the main so that you can reuse your algorithm later. 

The idea of using a hash-table based unordered_map is going into the right direction. However...

if(m.find(arr[i]) == m.end())
{
     m[arr[i]] = 1;
}


you don't need that initialization; you can think that each integer key is zero by default.

What comes to this:

for (int i = 0; i&lt;len; i++) {
    if((m[arr[i]] % 2) == 1)count++;
}


In the loop, you can check whether the counter gets the value of 2, and exit as soon as you detect this, which adds to the efficiency of the routine.

All in all, I had this in mind:

bool is_palindrome_permutation(char* p)
{
    std::unordered_map&lt;char, size_t&gt; m;

    while (*p)
    {
        if (std::isalpha(*p))
        {
            m[*p]++;
        }

        p++;
    }

    size_t count = 0;

    for (auto&amp; p : m)
    {
        if (p.second % 2 == 1)
        {
            if (++count == 2)
            {
                return false;
            }
        }
    }

    return true;
}


Hope that helps.

Edit 1

As additional fun, you can consider having a template, which allows you to abstract away the actual sequence implementation:

template&lt;typename ForwardIter&gt;
bool is_palindrome_permutation(ForwardIter begin, ForwardIter end)
{
    using value_type = typename std::iterator_traits&lt;ForwardIter&gt;::value_type;
    std::unordered_map&lt;value_type, size_t&gt; m;

    while (begin != end &amp;&amp; *begin) // *begin: a dirty hack for correctness
    {                              // on zero-terminated C strings.
        m[*begin]++;
        ++begin;
    }

    size_t count = 0;

    for (auto&amp; pair : m)
    {
        if (pair.second % 2 == 1)
        {
            if (++count == 2)
            {
                return false;
            }
        }
    }

    return true;
}

template&lt;typename Sequence&gt;
bool is_palindrome_permutation(const Sequence&amp; seq)
{
    return is_palindrome_permutation(std::begin(seq), std::end(seq));
}


int main() {
    char str[] = "tacoota";
    cout &lt;&lt; "Palindrome permutation: "
         &lt;&lt; std::boolalpha
         &lt;&lt; is_palindrome_permutation(str,
                                      str + sizeof(str) / sizeof(str[0]))
         &lt;&lt; endl;

    std::string str2{"tacoota"};
    cout &lt;&lt; "Palindrome permutation: "
         &lt;&lt; is_palindrome_permutation(str2)
         &lt;&lt; endl;

    std::vector&lt;char&gt; vec;
    std::copy(str2.begin(), str2.end(), std::back_inserter(vec));
    cout &lt;&lt; "Palindrome permutation: "
         &lt;&lt; is_palindrome_permutation(vec)
         &lt;&lt; endl;
    return 0;
}