but, what about the string, aaabbb, it is a palindrome with a's odd and b's odd. can someone explane the approche.

There is even simpler logic, along the same lines, though it takes one more mental step to prove it. There's no need to test whether the string length is odd or even. The correctness test is a little different than yours, of course.

No need to check whether the length of string is even or odd, the second condition i.e. count of ONLY one element should be odd will be enough.

This made it very easy to solve. Thanks for the tip!

Thank you. That was some "HINT".

i still haven't figured out how am i supposed to count each element and checking if the count is even or not .

Good one with collections in python life is easy :D

C solution:

void findPalind(char *arr)
{

    int flag = 0;
    // Find the required answer here. Print Yes or No at the end of this function depending on your inspection of the string

    int letter[26] = {0};

    for (int i = 0; i < strlen(arr); i++) {
        letter[arr[i] - 'a']++;
    }

    int count = 0;
    for (int i = 0; i < 26; i++) {
        if (letter[i] % 2 == 1) {
            count++;
        }
    }

    if (count > 1) {
        flag = 1;
    }

    if (flag==0)
        printf("YES\n");
    else
        printf("NO\n");

    return;
}
int main() {

    char arr[100001];
    scanf("%s",arr);
    findPalind(arr);
    return 0;
}

Or this logic: Maximum one element can have odd count, counts of rest elements should be even.

Thanks. This worked nicely with c++ bitsets and use of flip function.

string s;
cin>>s;
int flag = 0;

bitset<26> bs(std::string("00000000000000000000000000"));

for(int i = 0 ; i < s.size(); i++)
{
    bs.flip(s[i]-'a');     
}
if((s.size() % 2 !=0) 
    && (bs.count() == 1))
{
    flag = 1; 
}
else if ((s.size() %2 == 0)
    && (bs.count() == 0))
{
    flag = 1;     
}
if(flag==0)
    cout<<"NO";
else
    cout<<"YES";
return 0;

Using parity bits in a single integer was a fun way to do this in C++. Here a 0 bit is even, a 1 bit is odd.

int main() {
    string s;
    cin >> s;
    int parity = 0;
    for (char ch : s)
        parity ^= 1 << (ch - 'a');
    cout << (__builtin_popcount(parity) <= 1 ? "YES" : "NO") << endl;
    return 0;
}

nice one;)

you can use set also:

    Scanner scan = new Scanner(System.in);
    String str = scan.nextLine();

    Set<Character> set = new HashSet<Character>();
    for(Character ch : str.toCharArray()){
        if(set.contains(ch)){
            set.remove(ch);
        }else{
            set.add(ch);
        }
    }

    System.out.println((set.size()<=1)?"YES":"NO");


    scan.close();

Actually you only need the second check because there can not be a case where the lenght is even and only one element is odd

your logic is not correct in all cases

Thnx man..really usefull..but..already revealed solution so no points counted!..

Merge odd and even situations. That means regardless the len(str) is odd or even, just when the count of each elements have no more than ONE, the str is palindrome.

from collections import Counter
def gameOfThrones(s):
    # Complete this function
    num_odd = 0
    s1 = Counter(s)
    for each in s1.values():
        if each % 2 != 0:
            num_odd += 1
            # when num_odd > 1, not palindrome
            if num_odd > 1:
                return 'NO'
    return ('YES')

that's good... i'll try it

This is basically an "if you're stuck, this is the answer."

this could be considered one liner in python,

def gameOfThrones(s):
    return 'YES' if sum([1 for i in "abcdefghjkilmnopqrstuvwxyz" if i in s if sum([1 for j in s if i==j])%2==1]) <=1 else 'NO'

Or you can just have simple logic. A string to be formed as palindrome we should have only 1 character which has odd number of counts and other should have even number of counts.

I came to the same on my own. This is my implementation in Python3:

from collections import Counter

def gameOfThrones(s):
    counter = Counter(s)
    middle = 0

    if not len(s) // 2:  # even
        for k,v in counter.items(): 
            if v // 2: 
                return "NO"
    else:
        for k,v in counter.items():
            if v % 2 == 1:
                middle += 1
    if middle > 1:
        return "NO"
    return "YES"

Thank you :)

Use dictionary comprehension and s.count()

Map modulo two across the counts, odd = 1, even = 0, summing the result

If there is more than one odd result cannot be a palindrome

d = {c:s.count(c) for c in set(s)}
if sum(map(lambda x: x%2, d.values())) > 1:
    return 'NO'
return 'YES'

done the same code but test case fails for large string