Same problem here, #11 and #14 are failing!

Original string:
hgygsvlfcwnswtuhmyaljkqlqjjqlqkjlaymhutwsnwcwflvsgygh

After deleting 8'th character:
hgygsvlfwnswtuhmyaljkqlqjjqlqkjlaymhutwsnwcwflvsgygh

Please check if it is a palindrome :)

Same here failing on my submission; https://www.hackerrank.com/challenges/palindrome-index/submissions/code/12772467

same problem here

8 cannot be the ans..as string will still not be pallindrome after removing 'c'. correct ans is associated with the removal of 'w'.

is it working now ? m facing the same problem !

actually, both answers aren't correct... removing 8 "c", doesn't make the resulting string a palindrome.

what to print if the given string can not be converrted to palindrome????????

Actually the test case #11 and #14 should be fine. If you change the order of check logic, you may fail another 2 test cases. I think the problem lies on "checking s[j+1] & s[k], s[j]&s[k-1] is not sufficient". Try checking s[j+2] & s[k-1] also. I'm able to pass all test cases :)

Try these 3 test cases:

abcba

cwwcw

wcwwc

44 is the only correct answer. If you remove char 8, the resultant string is not palindromic. You're only checking one character deep after finding the end of the initial palindrome.

Thought I was going crazy...

You need to look one character beyond that. On the right side (going from right to left), the characters are wcwns.... On the left side (going from left to right), the characters are cwns.... You have to remove only w, because removing c will not result in a palindrome.

I guess I know why. Your algorithm is probably deleting the C(index 8) instead of w (index 44)

Compare the original string with its reversed form: ori: hgygsvlfcwnswtuhmyaljkqlqjjqlqkjlaymhutwsnwcwflvsgygh rev: hgygsvlfwcwnswtuhmyaljkqlqjjqlqkjlaymhutwsnwcflvsgygh

the difference appears at index 8. but the correct action is to remove index 44. If you remove 8 you wont have a palindrome.

Same. Issue. 11 & 14 not working

Remove i=8 
Outside:    hgygsvlfc       cflvsgygh
Middle:     wnswtuhmyaljkqlqjjqlqkjlaymhutwsnw

Remove i=44
Outside:    hgygsvlfw       wflvsgygh
Inside:     cwnswtuhmyaljkqlqjjqlqkjlaymhutwsn

As you can see you also need to check the next two characters to see if the string will continue to be a palindrome

if removing i8, check first that i9 == i44 && i10 == i43


if removing i44, check first that i8 == i43 && i9 == i42

All test cases are correct, these are just tricky.

check this in java import java.io.; import java.util.;

public class Solution {

public static boolean palindrome(String s){
    StringBuffer sb = new StringBuffer();
        sb = sb.append(s);
        sb = sb.reverse();
        String n = sb.toString();
       if(n.equals(s)){
           return true;
       }
    else return false;
}
public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    for(int a=0; a<n; a++){
        int out = 0;
        String input = sc.next();           
        if(palindrome(input)){
            System.out.println("-1");
        }
        else{
            for(int i=0; i<input.length(); i++){
                StringBuilder ss = new StringBuilder(input);
                if(input.charAt(i)!=input.charAt(input.length()-i-1)){
                 if(palindrome(ss.deleteCharAt(i).toString())){
                     System.out.println(i);
                 }
                    else System.out.println(input.length()-i-1);
                         break;
                }
            }
        }
    }
}

}

It is the same even after two years, it is not accepting either one of both the valid answers

include

include

include

include

include

using namespace std;

int main() { /* Enter your code here. Read input from STDIN. Print output to STDOUT */
int t; cin>>t; while(t--) { string s; cin>>s; int i,j; i=0; j=s.length()-1; int flag=0; int ind=0; int d=0; while(i

            if(s[i+1]==s[j]&&s[i]==s[j-1]){

                if(s[i+1]==s[j-2])
                    {
                   ind=j;
                    j--;

                }
                else if(s[j-1]==s[i+2])
                    {
                    ind=i;
                    i++;
                }

            else{
                flag=1;
                break;
            }                    
            }
            else if(s[i+1]==s[j])
                {
                ind=i;
                d=1;
                j++;
            }
            else if(s[i]==s[j-1])
                {
                ind =j;
                d=1;
                i--;
            }
            else{
                flag=1;
                break;
            }
        }
        i++;
        j--;
    }
    if(flag==1)
        {
        cout<<"-1"<<endl;
        continue;
    }
    else{
        if(d==0&&ind==0)
            {
            cout<<"-1"<<endl;
        }
        else{
            cout<<ind<<endl;}
    }
}
return 0;

}

The program is correct check my py code

n=int(raw_input())
for n0 in range(n):
    s=list(raw_input())
    if list(reversed(s))==s:
        print -1
    else:
        for _ in range(1,(len(s)/2)+1):
            if s[_-1]!= s[-_]:
                break
        s1=s[:]
        del s[_-1]
        del s1[-_]
        if list(reversed(s))==s:
            print _-1
        else:
            print len(s)+1-_

int q;
cin >> q;
for(int a0 = 0; a0 < q; a0++){
    string s;
    cin >> s;

    int i;
    for (i=0;i<s.length()/2;i++) {
        if (s[i]==s[s.length()-1-i]) continue;

        // check if substr is palindrome by getting rid of ith char
        int j;
        for (j=i+1;j<i+1+(s.length()-1-i-i)/2;j++) {               
            if (s[j]==s[s.length()-j]) continue;
            cout << s.length()-1-i << endl;
            break;
        }
        if (j==i+1+(s.length()-1-i-i)/2) cout << i << endl;
        break;
    }
    if (i==s.length()/2) cout << -1 << endl;
}

only w can be removed at 44th index

TC11 and 14 are correct... here is my solution

static int palindromeIndex(String s) {
        for(int i = 0, j = s.length() - 1; i < j; i++, j--) {
            if(s.charAt(i) != s.charAt(j)) {
                if(s.charAt(i+1) != s.charAt(j))
                    return j;
                else if(s.charAt(i) != s.charAt(j-1)) 
                    return i;
                else {
                    if(s.charAt(i+2) != s.charAt(j-1))
                        return j;
                    if(s.charAt(i+1) != s.charAt(j-2))
                        return i;
                }
            }
        }
        return -1;
    }

My simple solution is like this :

static int palindromeIndex(String s){
        // Complete this function
        int i, res = -1, n, temp;
        char[] charStr = s.toCharArray();
        
        n = s.length();
        
        for( i= 0; i< n; i++) {
            temp = charStr[i] - charStr[n-1 -i];
            if(temp == 0)
                continue;
            else
                if((charStr[i+1] - charStr[n-1 -i] == 0) && (charStr[i+2] == charStr[n-2 -i])){
                    res = i;
                    break;
                }
                else{
                    res = n-1 -i;
                    break;
                }
                
        }
        return res;
        
    }

Rather than checking for only the next character after a mismatch,check for the next two characters.

Yea these cases are bit tricky ones you need to backtrack to the postion you have earlier selected n choose different path(i.e if you choose 8 for deletion now select len-8) when characters are not matching.

The string: "hgygsvlfcwnswtuhmyaljkqlqjjqlqkjlaymhutwsnwcwflvsgygh" is present in testcase #11, and also in testcase #1. In #1, if the code returns 8, it's fine, but en #11, return of an 8 fails the test

complete solution https://www.hackerrank.com/challenges/palindrome-index/forum/comments/474736

I made another approach for this problem in Python 3: * invert all the string and store in s_i * Iterarate s removing postion from start to end and iterate s_i removing postion from end to start * if s and s_i are equals, return postion

This solution pass in all test cases.

def palindromeIndex(s):
        N = len(s)
        N_i = N - 1
        s_i = s[::-1]
        if s == s_i:
                return -1

        for i in range(N):
                test = s[:i] + s[i+1:]
                test_i = s_i[:N_i-i] + s_i[N_i-i+1:]
                if test == test_i:
                        return i

        return -1

I think this would help

def palindromeIndex(s):
    n = len(s)
    for i in range(n//2):
        if s[i]!= s[n-i-1]:
            if s[i]==s[n-i-2] and s[i+1]==s[n-i-3]:
                return n-i-1
            else:
                return i
    return -1

My code in C++:

include

include

using namespace std;

int main(){

int q,i,j,count,pos1,pos2,len,flag,flag1; string str;

cin>>q;

for(int k=0;k

flag=0,flag1=0; cin>>str;

len =str.length();

for(i=0,j=len-1;i

if(str[i]!=str[j]){ pos1=i; pos2=j; flag=1; break; } }

if(flag==0){ cout<<"-1\n"; continue; }

str.erase(str.begin() + pos1);

int len1=str.length(); for(i=0;i < len1/2 ;i++){ if(str[i] != str[len1-i-1]){ flag1 = 1; break; } }

if (flag1) { cout< else { cout<

} return 0; }

You are right . same problem

I was getting th same issue and I adjusted my code to suit the outputs. Here's my JS solution:

    if(s.split(``).reverse().join(``) !== s){
        let half = Math.floor(s.length * 0.5);

        for(let i = 0; i < half; i++){
            let id = s.length - 1 - i;
            if(s.charAt(i) !== s.charAt(id)){
                let sub = s.substring(i,id);
                if(sub === sub.split(``).reverse().join(``)){
                    return id;
                }
                sub = s.substring(i+1,id+1);
                
                if(sub === sub.split(``).reverse().join(``)){
                    return i;
                }
                else{
                    break;
                }
            }
        }
    }
    return -1;

6 years have elapsed since you posted this error and it still remains there. Testcase 11 and 14 fails.

We also need to check whether the subsequent elements are palindrome, as only one removal is needed we just check for the next elements to be equal.

int palindromeIndex(string s) {

for(int i=0;i<s.size()/2;i++){
    if(s[i]!=s[s.size()-1-i]){
        if(s[i]==s[s.size()-2-i] && s[i+1]==s[s.size()-3-i])
            return s.size()-1-i;
        else
            return i;
    }
}
return -1;

}

same happening wih me.

My code result in TLE only for TC2 & TC5

Can Some optimze it using similar approach

    static int palindromeIndex(String s)
    {
        boolean once;
        int j, k, len = s.length();

        for(j = 0 , k = len - 1 ; j < k ; j++, k--)
            if(!(s.charAt(j) == s.charAt(k)))
                break;
        if(j >= k)
            return -1;

        for(int i = 0; i < len ; i++)
        {
            j = 0;
            k = len - 1;
            once = true;
            while(j < k)
            {
                if(i == j && once)
                {
                    j++;
                    once = false;
                    continue;
                }
                else if(i == k && once)
                {
                    k--;
                    once = false;
                    continue;
                }
                if(s.charAt(j) == s.charAt(k))
                {
                    j++;
                    k--;
                }
                else
                    break;
            }
            if(j >= k) return i;
        }
        return -1;
    }

Edit: New Solution

    static int palindromeIndex(String s)
    {
        int i, j, x, y, len = s.length();

        for(i = 0 , j = len - 1 ; i < j ; i++, j--)
            if(!(s.charAt(i) == s.charAt(j)))
                break;
        if(i >= j)
            return -1;

        for(x = i + 1, y = j ; x < y ; x++, y--)
            if(!(s.charAt(x) == s.charAt(y)))
                break;
        
        if(x >= y)
            return i;
        else
            return j;
    }

This question is little bit weird . You have to assume that a given string is a pallindrome or just off by a single character . So basically you have to run a loop from both starting and ending and check which characters dont match. Now you have to remove any one of the character and check if the string is pallindrome .If yes return the index of the character removed or else return the index of other character (the character which didnt match at the start) .Just look at this code and you will understand what i was taking about .(Its a java code btw )

            int low = 0 ; 
    int high = s.length()-1 ;
    while(low < high)
    {
        if(s.charAt(low) != s.charAt(high))
        {
            break;
        }
        low++;
        high--;

    }
    if(low > high)
    {
        return -1; 
    }

    int res1 = high ;
    int res2 = low ;
   while(low < high)
   {
       if(s.charAt(low+1) != s.charAt(high))
       {
           return res1 ;
       }
       low++;
       high--;
   }
   return res2 ;

The problem of test case 11 and 14 is that you have to check two index ahead in both cases hgygsvlfcwnswtuhmyaljkqlqjjqlqkjlaymhutwsnwcwflvsgygh mismatch at index 8 so if you remove c at index 8 just checking after c is w then it will fail cause it won't be palindrome.

Check you answer for sample case: cwccw You'll get an better understanding. You can check my code, it works....

` python3 code

def palindromeIndex(s):

        n = len(s)

        if ispalindrome(s):
                return -1 

        k = 0
        for i in range(n//2):
                if s[-i-1]!=s[i]:
                        if s[-i-2]==s[i] or s[i+1]==s[-i-1]:
                                wrd = remove(s,n-i-1)
                                if ispalindrome(wrd):
                                        return n-i-1 

                                wrd = remove(s,i)
                                if ispalindrome(wrd):
                                        return i

        return -1
>             

NO BRO...your string is "hgygsvlfcwnswtuhmyaljkqlqjjqlqkjlaymhutwsnwcwflvsgygh"

If you remove all middle equal characters it will be

"hgygsvlfcw - nswtuhmyaljkqlqjjqlqkjlaymhutwsn - wcwflvsgygh"

here you find one 'w' is extra...

"hgygsvlfcwwcwflvsgygh"

brother, if we remove 8th letter 'c' we get .....fwns...... front left and from right we get ......fwcwns.... . but if we remove 44 letter we get a palandrome. i faced the same problem , so i sort to check the third letter after mismatch

if s[i]!=s[j]: if s[i]==s[j-1] and s[i+1]==s[j-2]: return j else return i

I had the same problem but I solved the problem with the string you shared. Thank you. My solution is:

for (int i = 0, j = s.Length - 1; i < s.Length / 2 && j >= s.Length / 2; i++, j--) { if (s[i] != s[j]) { if(s[i] == s[j - 1] && s[i + 1] == s[j]) { if (s[i + 1] == s[j - 2]) index = j; else index = i; } else if (s[i + 1] == s[j]) index = i; else if (s[i] == s[j - 1]) index = j; break; } } return index;

Testcase 11 and 14 are CORRECT.

correct explanation to soln is explained by this thread. https://www.hackerrank.com/challenges/palindrome-index/forum/comments/121372

https://www.hackerrank.com/challenges/palindrome-index/forum/comments/60201

no, removing any of both char won't work, it has to be only 'w'(idx 44) because.. the string is "...fcwn...nwcwf..." (dots are all palindrome only you can check), now after char 'f', 'c'(idx 8) and 'w' char are different, now if you remove 'c' here.. the string would be "...fwn...nwcwf..." which doesn't make the string palindrome, but if you remove w, the string will be "...fcwn...nwcf..." which is palindrome, that's why here answer should be 44, not 8

//I THINK THIS MAY BE READABLE (C++)
    bool palindrome(string s)
 {
 int l=s.size();
 for(int i=0;i<l/2;i++)
  {
   if(s[i]!=s[l-i-1])
   return false;
  }  
 return true;
}
 int palindromeIndex(string s) {
int x,y;
 int l=s.size();
for(int i=0;i<l/2;i++)
  {
if(s[i]!=s[l-i-1])
{
    x=i;
    y=l-i-1;
    break;
}
  }
s=s.substr(0,x)+s.substr(x+1,s.size());
if(palindrome(s))
 {
 return x;
 }
 else {
 return y;
 }
  }

My first algorithm was also failing tests 11 and 14. But I realized it was a problem of the algorithm, not of the test. If you remove 8th caracter from the string "hgygsvlfcwnswtuhmyaljkqlqjjqlqkjlaymhutwsnwcwflvsgygh" it will not become a palindrome. I have 'isolated' my algorithm problem here.

"cwnnwcw"

We have to remove 6th carachter to form a palindrome.

For anoyone still looking for an O(n) solution (2 pointers) that passes test cases 11 and 14, here's a working C# solution with comments:

the issue with 11 & 14 is that we could remove/skip either the left or right character when iterating through, but only 1 of them leads to a solution, so we have to check the next character as well to see if left or right is the right to remove/skip

public static int palindromeIndex(string s)
{
  int charRemoved = -1;
  int left=0;
  int right=s.Length-1;
  
  while (right > left) {
    if (s[left] != s[right]) {
      if (charRemoved != -1) //already removed a char, we're done
        return -1;
      
      bool removeLeft = left < s.Length -1 && s[left+1] == s[right];
      bool removeRight = right > 0 && s[left] == s[right-1];
      
      if (removeLeft && removeRight) { //if we could remove either
        //check one more char furhter in...
        removeLeft = (left+1) < s.Length-1 && s[left+2] == s[right-1]; 
        removeRight = !removeLeft;
      }

      if (removeLeft) {
        charRemoved = left;
        left++; //skip this character
      } else if (removeRight) {
        charRemoved = right;
        right--; //skip this character
      } else { //if removing neither character works
        return -1;
      }
    }
    //move both pointers to the next character toward the middle
    right--;
    left++;
  }
  
  return charRemoved; //return the index of the char we removed
}

The answer is 44. I created an extra check palindrome function, and removing index 8 only does not result in a palindrome. only by removing index 44, will the resulting string be a palindrome.