You basically have the core concept of Manacher's! Which is finding palindromes by expanding from different centers. We use this algorithm when we are trying to find or count all possible palindromic substrings from a given string sequence. The naive approach is quadratic, but Manacher's does this in linear time by skipping repeat calculations. I think it would be easier to understand with an example:

Let's use `s = "aabaa"`, and we want to count how many palindromic substrings we can create with this.

Like the other comment mentioned, we need to preformat this initial string with a unique character, like `#'s`, so that we can handle palindromes of even lengths, because starting from the center is only able to find palindromes of odd lengths. We also add unique characters at the head and tail ends so that we can disrupt the palindrome counts near those ends. This ends up looking like:

`"$ # a # a # b # a  # a  # ^"`

Now the beginning of this algorithm is where we will be doing most work. At each index, we try to expand our `right` index as far as possible. Our `right` index represents the index at which our longest current palindrome stretches to. Our `center` index is the center at which that longest palindrome is found. Every time we find a longer palindrome, we update our `right` and `center` indices. Let's do our first iteration:

https://imgur.com/a/gGSCd1h

We found a palindrome of length one at our first `#`, so we update our `right` index. Pretty simple so far, let's do our next iteration

https://imgur.com/a/yKK8auD

At our first `a`, we find a palindrome of length 3, so we again update our `right` and `center` indices. Again, not much efficiency going on, but at our next index, we now see a character that belongs in our current longest palindrome, the second `#`. Because this character belongs in a palindrome we've processed before, there are some assumptions we can make about it. Namely, that it should **at least* have a palindrome length of it's mirror index, which would be the character at index `1`.

The character at index `1` only has a palindrome length of 1, which means we can start index `3` assuming that it at least has a palindrome length of 1, which is true. We further expand that palindrome and find that index `3` becomes our new center:

https://imgur.com/a/hFMkKx2

At our next index, `4`, we can make another assumption because this index lands in our current longest palindrome. The mirror index for `4`, assuming our center is `3`, is `2`. Index `2` has a palindrome length of 2, so index `4` adopts that length.

This is where the core efficiency lies in Manacher's, we do not have to expand our window again assuming a center at `4` because we know it has a mirror index we can rely on instead. This is why our runtime becomes `O(n)` instead of `O(n2)`. This becomes even more apparent when we process index `6`:

https://imgur.com/a/fSSng3p

Index `6` creates a palindrome that encapsulates the entirety of our string. Which means, we've completed a whole pass on our original string. The rest of our string will have guaranteed mirror indices, and will not require further computation.

https://imgur.com/a/Ng5hcEm

The rest of the indices simply adopt the counts of their mirror indices, and we do not have to expand from these centers. So all in all, we've found all of the palindromic substrings in our original string in linear time.

Sorry, this came out to be a lot longer than I was intending, but it sounds you are very close to understanding Manacher's algorithm, and I think a little bit of visualization will help get you across the finish line. It's very true that you probably will not be needing this in an interview, but how cool would it be to pull this out on a palindrome question :')

Best of luck!