Finding possible prefix palindromes - c++

Question

We are given a string S of length N. We have to calculate number of prefixes which can be rearranged into palindromes. E.g: Consider string "abba"- "a", "abb" and "abba" are the prefixes which can be rearranged into palindromes.
My approach:
I tried to use XOR for solving this problem. For example a string containing even number of characters can be made palindrome if the xor of all characters in the string is 0.In case of strings having odd characters, the xor of all characters should be between 97 and 122, i.e a single character.
Here's a part of my code-
string s;
cin>>s;
int a,n;
int ans=1;
n= s.length();
a=s[0];
for (int i=1;i<n;i++)
{
a=a^(s[i]);
if (i%2)
{
if (a==0)
{
ans++;
}
}
else
{
if ((a>=97)&&(a<=122))
{
ans++;
}
}
}
cout<< ans<< "\n";
I tried to run and it runs successfully for some test cases but fails for others. Any idea of what's wrong in this approach?

Answer 1

Better solution, based on the comments from OP:
#include <string>
#include <iostream>
#include <cctype>
int main() {
std::string input;
std::cin >> input;
unsigned char_xor = input[ 0 ];
unsigned pal = 1; // number of palindromes (initialized to 1,
// since a singular letter is always a
// palindrome)
for ( std::string::size_type i = 0; input.size() >= i; ++i ) {
char_xor ^= input[ i + 1 ];
// check whether length of current prefix is:
// - odd: check whether it is a lowercase character
// - even: check whether it is equal to 0
if ( ( i % 2 && std::islower( char_xor ) ) ||
( !( i % 2 ) && !char_xor ) ) {
++pal;
}
}
std::cout << "Amount of possible palindromes: " << pal << std::endl;
return 0;
}
The following assumption is incorrect (see comments below).
As having understood from
a string containing even number of characters can be made palindrome if the xor of all characters in the string is 0.In case of strings having odd characters, the xor of all characters should be between 97 and 122
you're making a mistake in checking whether the computed XOR is equal to 0/between 97 and 122 on each iteration (after XORing each character), whereas you should be checking it after iterating over the whole std::string. The following works with your given example of "abba" and, for instance, "aaaadcasdasdaffaaa" (having produced 12):
#include <string>
#include <iostream>
#include <cctype>
bool can_be_palindrome( const std::string& str ) {
unsigned char_xor = str[ 0 ];
// compute the xor of all characters
for ( std::string::size_type i = 1; str.size() != i; ++i ) {
char_xor ^= str[ i ];
}
// determine whether the input string has an even number of characters;
// if so, return whether char_xor is equal to 0;
// if not, return whether char_xor is a lowercase letter.
return !( str.size() % 2 ) ? !char_xor : std::islower( char_xor );
}
int main() {
std::string input;
std::cin >> input;
unsigned pal = 1; // number of palindromes (initialized to 1, since a
// singular letter is always a palindrome)
for ( std::string::size_type i = 2; input.size() >= i; ++i ) {
// extract a prefix from the range [0; i) and determine whether it
// can become a palindrome
if ( can_be_palindrome( input.substr( 0, i ) ) ) {
++pal;
}
}
std::cout << "Amount of possible palindromes: " << pal << std::endl;
return 0;
}