HackerRank Palindrome Index problem solution

In this HackerRank Palindrome Index problem solution, we have given a string of lowercase letters in the range ascii[a-z], to determine the index of a character that can be removed to make the string a palindrome. There may be more than one solution, but any will do. If the word is already a palindrome or there is no solution, return -1. Otherwise, return the index of a character to remove.

Problem solution in Python.

```def calc_pal(line):

list = [x for x in line]

orig = list[:]
rev = list[:]
rev.reverse()

if orig == rev:
return -1

for i in range(len(orig)):
if not orig[i] == rev[i]:
cpy = orig[:]
del cpy[i]
cpyRev = rev[:]
del cpyRev[len(orig) - i - 1]
if cpy == cpyRev:
return i
else:
return len(orig) - i - 1

m = int(input().strip())

lines = []
for i in range(m):
lines.append(input())

for line in lines:
print(calc_pal(line))
```

Problem solution in Java.

```import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

class Result {

public static int palindromeIndex(String s) {

char arr[]=s.toCharArray();
int left=0;
int right=arr.length-1;

while(left<=right){
if(arr[left]!=arr[right]){
boolean Rres=IsPalindrome(arr,left,right-1);
if(Rres)
return right;
else
{
boolean Lres=IsPalindrome(arr,left+1,right);
if(Lres)
return left;
}

}
right--;
left++;
}
return -1;
}
public static boolean IsPalindrome(char arr[],int left,int right){

while(left<=right){
if(arr[left]!=arr[right])
return false;
right--;
left++;
}

return true;

}

}

public class Solution {
public static void main(String[] args) throws IOException {
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

IntStream.range(0, q).forEach(qItr -> {
try {

int result = Result.palindromeIndex(s);

bufferedWriter.write(String.valueOf(result));
bufferedWriter.newLine();
} catch (IOException ex) {
throw new RuntimeException(ex);
}
});

bufferedWriter.close();
}
}
```

Problem solution in C++.

```#include <stdio.h>
#include <string.h>

char x[120000];

int main()
{
int cases;
scanf("%d", &cases);

for (int index = 1; index <= cases; index++)
{
scanf("%s", &x);
int len = strlen(x);

int i, j;
for (i = 0, j = len - 1; i <= j; i++, j--)
{
if (x[i] != x[j])
{
int p, q;
for (p = i + 1, q = j; p <= q; p++, q--)
{
if (x[p] != x[q])
{
printf("%d\n", j);
goto out;
}
}
printf("%d\n", i);
out:
goto end;
}
}

printf("%d\n", -1);
end:;
}

return 0;
}
```

Problem solution in C.

```#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_STRING_LENGTH 100005

#define TRUE 1
#define FALSE 0

int isPalindrome(char* s) {
int isPal= TRUE;
int len = strlen(s);
int j;
for (j = 0; j < (len / 2) + 1 && isPal; ++j) {
if (s[j] != s[len - j - 1]) {
isPal = FALSE;
}
}
return isPal;
}

int main(void) {

int i, j;
int numTestCases;
char s[MAX_STRING_LENGTH + 1];
char s1[MAX_STRING_LENGTH + 1];
int len;

scanf("%d", &numTestCases);

for (i = 0; i < numTestCases; ++i) {

scanf("%s", s);

if (isPalindrome(s)) {
printf("-1\n");
continue;
}

s1[0] = '\0';
len = strlen(s);

for (j = 0; j < (len / 2) + 1; ++j) {
if (s[j] != s[len - j - 1]) {
strncpy(s1, s, j);
s1[j] = '\0';
strcat(s1, &s[j + 1]);
if (isPalindrome(s1)) {
printf("%d\n", j);
} else {
printf("%d\n", len - j - 1);
}
break;
}
}
}

return 0;

}
```