# HackerRank Palindrome Index Solution

Hello Programmers, In this post, you will learn how to solve HackerRank Palindrome Index Solution. This problem is a part of the HackerRank Algorithms Series.

One more thing to add, don’t straight away look for the solutions, first try to solve the problems by yourself. If you find any difficulty after trying several times, then look for the solutions. We are going to solve the HackerRank Algorithms problems using C, CPP, JAVA, PYTHON, JavaScript & SCALA Programming Languages.

## HackerRank Palindrome Index Solution

Given a string of lowercase letters in the range ascii[az], 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.

Example

s = “bcbc”

Either remove ‘b’ at index 0 or ‘c’ at index 3.

Function Description

Complete the palindromeIndex function in the editor below.

palindromeIndex has the following parameter(s):

• string s: a string to analyze

Returns

• int: the index of the character to remove or -1.

Input Format

The first line contains an integer q, the number of queries.
Each of the next q lines contains a query string s.

Constraints

• 1 <= q <= 20
• 1 <= length of s <= 105 + 5
• All characters are in the range ascii[a-z].

Sample Input

STDIN Function
—– ——–
3 q = 3
aaab s = ‘aaab’ (first query)
baa s = ‘baa’ (second query)
aaa s = aaa’ (third query)

Sample Output

3
0
-1

Explanation

Query 1: “aaab
Removing ‘b’ at index 3 results in a palindrome, so return 3.

Query 2: “baa”
Removing ‘b’ at index 0 results in a palindrome, so return 0.

Query 3: “aaa”
This string is already a palindrome, so return -1. Removing any one of the characters would result in a palindrome, but this test comes first.

Note: The custom checker logic for this challenge is available.

### HackerRank Palindrome Index Solution in C

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

int ret;
scanf("%d", &ret);
return ret;
}

/* caller should free the memory */
int *ret = malloc(n * sizeof(int));
for (int i = 0; i < n; ++i) {
scanf("%d", ret + i);
}
return ret;
}

static int intcomp(const void *v1, const void *v2) {
return *(const int *)v1 - *(const int *)v2;
}

static int is_palindrome(const char *s, int len) {
/* assert(len > 0); */
/* assert(s); */
if (!s || len <= 0) {
return 0;
}
for (const char *start = s, *end = s + len - 1; start < end; start++, end--) {
if (*start != *end) {
return 0;
}
}

return 1;
}

static int so(const char *s, int len, int current_index) {
/* assert(len >= 1); */
if (len < 1) {
return 0;
}

while (1) {
if (len == 1 || len == 2) {
return current_index;
}

char start = s[0];
char end   = s[len - 1];
if (start != end) {
/* we have to remove either one */
/* test [start + 1, end] */
if (is_palindrome(s + 1, len - 1)) {
return current_index;
} else {
return current_index + len - 1;
}
} else {
/* return so(s + 1, len - 2, current_index + 1); */
s ++;
len -= 2;
current_index ++;
}
}
}

static int solve(const char *s) {
return so(s, strlen(s), 0);
}

int main(int argc, char *argv[]) {
/* assert(is_palindrome("aba", 3) == 1); */
/* assert(is_palindrome("abc", 3) == 0); */
/* assert(is_palindrome("a", 1) == 1); */
/* assert(is_palindrome("ab", 2) == 0); */
/* assert(is_palindrome("aa", 2) == 1); */
/* assert(is_palindrome("abba", 4) == 1); */

for (int i = 0; i < t; ++i) {
char buf[100010];
scanf(" %s", buf);
printf("%d\n", solve(buf));
}
return 0;
}```

### HackerRank Palindrome Index Solution in Cpp

```#include<stdio.h>
#include<string.h>
char a[1000005];
char b[1000005];
int is(char *a, int n){
int i;
for(i=0;i<n/2;i++)if(a[i]!=a[n-1-i])return i;
return -1;
}
int main(){
int t;
scanf("%d",&t);
while(t--){

scanf("%s",&a);
int l = strlen(a);
int x = is(a,l);
if(x==-1){
printf("-1\n");
}
else {
int i;
int j=0;
for(i=0;a[i];i++){
if(i!=x)b[j++] = a[i];

}
if(is(b,l-1)==-1)printf("%d\n",x);
else printf("%d\n",l-1-x);
}
}
}```

### HackerRank Palindrome Index Solution in Java

```import java.io.*;

public class Solution {

public static void solve(Input in, PrintWriter out) throws IOException {
int tests = in.nextInt();
for (int test = 0; test < tests; ++test) {
String s = in.next();
int i = 0, j = s.length() - 1;
while (i < j && s.charAt(i) == s.charAt(j)) {
++i;
--j;
}
int ans;
if (i >= j) {
ans = -1;
} else if (palindrome(s.substring(0, i) + s.substring(i + 1))) {
ans = i;
} else if (palindrome(s.substring(0, j) + s.substring(j + 1))) {
ans = j;
} else {
throw new AssertionError(s + " " + i + " " + j);
}
out.println(ans);
}
}

private static boolean palindrome(String s) {
int i = 0, j = s.length() - 1;
while (i < j && s.charAt(i) == s.charAt(j)) {
++i;
--j;
}
return i >= j;
}

public static void main(String[] args) throws IOException {
PrintWriter out = new PrintWriter(System.out);
out.close();
}

static class Input {
StringBuilder sb = new StringBuilder();

this.in = in;
}

public Input(String s) {
}

public String next() throws IOException {
sb.setLength(0);
while (true) {
if (c == -1) {
return null;
}
if (" \n\r\t".indexOf(c) == -1) {
sb.append((char)c);
break;
}
}
while (true) {
if (c == -1 || " \n\r\t".indexOf(c) != -1) {
break;
}
sb.append((char)c);
}
return sb.toString();
}

public int nextInt() throws IOException {
return Integer.parseInt(next());
}

public long nextLong() throws IOException {
return Long.parseLong(next());
}

public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
}
}```

### HackerRank Palindrome Index Solution in Python

```import sys

def main():
t = int(raw_input())
for _ in xrange(t):
print palin_index(raw_input())

def palin_index(s):
i, j = 0, len(s)-1
while i < j:
if s[i] != s[j]:
if is_palin(s, i+1, j):
return i
else:
return j
i += 1
j -= 1
return -1

def is_palin(s, a, b):
while a < b:
if s[a] != s[b]: return False
a += 1
b -= 1
return True

if __name__ == "__main__": sys.exit(main())```

### HackerRank Palindrome Index Solution using JavaScript

```'use strict';

function solve(S) {
var mid = Math.floor(S.length / 2);
var idx = -1;
for (var i = 0, j = S.length - 1; i < mid; i++, j--) {
if (S[i] != S[j]) {
if (idx == -1) {
idx = i;
j++;
continue;
} else {
idx = S.length - 1 - idx;
break;
}
}
}
return idx;
}

function processData(input) {
var parse_fun = function (s) { return parseInt(s, 10); };

var lines = input.split('\n');
var T = parse_fun(lines.shift());

for (var t = 0; t < T; t++) {
var S = lines[t].trim().split('');
console.log(solve(S));
}
}

process.stdin.resume();
process.stdin.setEncoding("ascii");
var _input = "";
process.stdin.on("data", function (input) { _input += input; });
process.stdin.on("end", function () { processData(_input); });```

### HackerRank Palindrome Index Solution in Scala

```object Solution
{
val in = {
val lines = scala.io.Source.stdin.getLines
lines map (_ split ' ' filter (_.nonEmpty)) flatten
}

def main(args: Array[String]): Unit = {

val testCount = in.next.toInt

for (_ <- 1 to testCount)
{
val S = in.next
val N = S.size

if (S == S.reverse) println(-1)
else {
var i = 0
var found = false
while (i < N && !found)
{
if (S(i) != S(N - i - 1))
{
val s1 = ((0 until N) filter (_ != i) map S).mkString
val s2 = ((0 until N) filter (_ != N - i - 1) map S).mkString
if (s1 == s1.reverse)
{
found = true
println(i)
}
else
if (s2 == s2.reverse)
{
found = true
println(N - i - 1)
}
}
i += 1
}
}
}
}
}```

### HackerRank Palindrome Index Solution in Pascal

```program Solution;

uses sysutils, strutils;

var
t, i: byte;
s : AnsiString;

function ispalindrome(s : AnsiString) : boolean;
begin
ispalindrome := (ReverseString(s) = s);
end;

function index(s : AnsiString) : LongInt;
var
start, end1 : Longword;
begin
start := 1;
end1  := length(s);
while((start < end1) and (s[start] = s[end1])) do
begin
Inc(start);
Dec(end1);
end;

if ispalindrome(s) then index := -1
else if (s[start] = s[end1 -1]) and (s[start+1] = s[end1-2]) then index := end1-1
else index := start-1;

end;

BEGIN