1) MakeablewasIereIsawElbafromtheracecarMadamImAdam
2) ablewasiereisawelba
3) MakefromtheracecarMadamImAdam
4) 1) MakefromtheracecarMadamImAdam
   2) madamimadam
   3) makefromtheracecar
   4) 1)makefromtheracecar
      2) racecar
      ... (didn't want to bother with this, and I think the example will suffice)
      5) makefromthe**PALINDROME**
   5) makefromthe**PALINDROME****PALINDROME**
5) make**PALINDROME**from the**PALINDROME****PALINDROME**

"""Overlapping Palindrome Test"""

_debug = True

min_len = 1

### The phrase ###

phrase = '"Am I mad, eh?" Giselle sighed, "Am I, Ma?"';

if _debug: print 'The phrase:', phrase

### Strip the phrase ###

phrase = phrase.lower()

alphabet = 'abcdefghijklmnopqrstuvwxyz'
phrase = [letter for letter in phrase if letter in alphabet]

if _debug: print 'The stripped phrase:', ''.join(phrase)

if _debug: print # Newline (for aesthetics)

# Pop the last min_len characters from phrase into reversed
reversed = []
for i in range(min_len):
	reversed.append(phrase.pop())

results = []

# t holds odd letters (for example, 'i' in 'madamimadam')
t = None

for pos in range( len(phrase) ):
    
    # Try each match with and without t
    if t == None:
        t = phrase.pop()
    else:
        reversed.append(t)
        t = None
    
    phr_len = len(phrase)
    rev_len = len(reversed)
    
    # Store letters in temp as we accumulate a palindrome
    temp = ''
    
    for i in range(rev_len):
    
        # Attempt to match corresponding indices of phrase and reversed
        
        j = phr_len - rev_len + i
        
        if reversed[i] != phrase[j] and i != rev_len - 2: 
            # If unsuccessful, try again with new letters
            break
        else:
            # We have begun to accumulate a palindrome
            temp += reversed[i]
            
            if i == rev_len - 1:
                # We have a palindrome!
                
                # Assemble the palindrome
                palindrome = temp
                if t != None:
                    palindrome += t
                palindrome += temp[::-1]
                
                if _debug:
                    print 'Palindrome: ', palindrome
                    print 'Remainder: ', ''.join(phrase)
                    print
                
                # Add the palindrome to the list of results
                results.append(palindrome)

### Print the palindromes (if not in debug mode) ###

if not _debug:
    print "\n".join([result for result in results])

The phrase: "Am I mad, eh?" Giselle sighed, "Am I, Ma?"
The stripped phrase: amimadehgisellesighedamima

Palindrome:  amima
Remainder:  amimadehgisellesighedam

Palindrome:  amimadehgisellesighedamima
Remainder:  amimadehgisel

#include <string>
#include <cctype>
#include <iostream>

const int MINPALINDROMESIZE = 3;

std::string strip(const std::string& s)
{
  std::string stripped;
  for(int i = 0; i < s.length(); ++i)
    if(std::isalpha(s[i]))
      stripped += s[i];
  return stripped;
}

bool isPalindrome(const std::string& s)
{
  for(int i = 0, j = s.length() - 1; i < j; ++i, --j)
    if(std::tolower(s[i]) != std::tolower(s[j]))
      return false;
  return true;
}

std::string firstPalindrome(const std::string& s)
{
  int start = 0, len = 1;
  for(int i = 0; i < s.length(); ++i)
  {
    int curStart = i, curLen = 1;
    for(int k = s.length() - 1; i < k; --k)
    {
      if(std::tolower(s[i]) == std::tolower(s[k])) // ends match, so check insid
e
      {
        curLen = k - i + 1; // length of substring being considered
        if(curLen >= MINPALINDROMESIZE && isPalindrome(s.substr(i, curLen)))
        {
          if(curLen > len)
            start = curStart, len = curLen;
          goto end; // found largest pdrome for this starting letter
        }
      }
    }   
  }
end:
  std::string result;
  if(len >= MINPALINDROMESIZE)
    result = s.substr(start, len);
  return result;
}

int main(int argc, char** argv)
{
  if(argc != 2)
  {
    std::cerr << "Usage: " << argv[0] << " <phrase>" << std::endl;
    return 1;
  }
  std::string s = strip(argv[1]);
  std::cout << "The phrase after being stripped: " << std::endl;
  std::cout << s << std::endl << std::endl;
  std::string pal, res, rem;
  pal = firstPalindrome(s);
  if(pal == "")
    std::cout << "No palindromes found in this string.";
  else
  {
    rem = s.substr(s.find(pal)+pal.length());
    res = s.substr(0, s.find(pal)) + "**PALINDROME**";
    std::cout << "First Palindrome: " << pal << std::endl;
    if(rem != "")
      std::cout << "Remainder: " << rem << std::endl;
    while((pal = firstPalindrome(rem)) != "")
    {
      res += rem.substr(0, rem.find(pal)) + "**PALINDROME**";
      rem = rem.substr(rem.find(pal) + pal.length());
      std::cout << std::endl;
      std::cout << "Next Palindrome: " << pal << std::endl;
      if(rem != "")
        std::cout << "Remainder: " << rem << std::endl;
    }
    if(rem != "")
      res += rem;
    std::cout << std::endl;
    std::cout << "Substituted Result: " << res << std::endl;
  }
  return 0;
}

#Set this to true for a better understanding of how the program works
$DEBUG = false

# Return the largest palindrome anywhere in the string.
# It is assumed that the input has been passed first through process_string to
# rid it of only alphabetic characters.
# nil is returned if there are no palindromes in the string.
def find_largest_palindrome(raw_str)
	puts "Raw string = #{raw_str.join}"
    
    # an array to hold all the palindromes in the string
    pals = Array.new

    # loop through the indexes of the character array 
    raw_str.each_index do |a|
        # set the string to be tested for palindromes one letter less each time
	testing_str = raw_str[a..raw_str.length]
        
        if $DEBUG
            puts "Testing String: #{testing_str.join}"
            sleep(0.1)
        end

	0.upto(testing_str.length) do |b|
        # set the reversed string to the reverse of the testing string, but
        # cycle through all the possible reverses to find all the possible
        # matches.
	    reversed_str = testing_str.reverse[b..testing_str.length]
            
            if $DEBUG
                puts "\tReversed String: #{reversed_str.join}"
            end
            
	    sub_str = String.new
				
	    testing_str.each_index do |j|
		if testing_str[j] == reversed_str[j]
		    sub_str << testing_str[j]
		else
		    break
		end
            end
            
            unless sub_str.empty? or pals.include?(sub_str) or sub_str.length < 3
            	pals << sub_str
          
                if $DEBUG
                    puts "\t\t\t\tAdding palindrome: * #{sub_str} *"
                    sleep(1)
                end
            end 
        end
    end
    
    return pals.max { |a, b| a.length <=> b.length }
end

# Process the input string.
# First, all instances of **PALINDROME** are removed
# so they are not included in the search for palindromes.
# Second, all characters are removed except for letters of the  alphabet.
# An Array containing all the letters of the string is returned. 
def process_string(string)
	string.chomp.gsub("**PALINDROME**", '').gsub(/[^a-z]/i, '').downcase.split(//)
end

def dawei_challenge(phrase)
    result = process_string(phrase).join
	
    loop do
	pal = find_largest_palindrome(process_string(result))
	puts "Largest palindrome = #{pal or "None"}"
		
        if $DEBUG
            sleep(2)
        end
		
        if not pal
	    puts "No more palindromes!"
	    puts "Final result is \"#{result}\"."
	    return
	else
	    result.sub!(pal, '**PALINDROME**')
	    puts "Result so far: #{result}\n\n"
	end
    end
    
    result
end

text1 = "Makeable was I ere I saw Elba from the racecar (Madam, I'm Adam)."
text2 = "\"Am I mad, eh?\" Giselle sighed, \"Am I, Ma?\""
dawei_challenge(text1)

$ ruby palindrome.rb
Raw string = makeablewasiereisawelbafromtheracecarmadamimadam
Largest palindrome = ablewasiereisawelba
Result so far: make**PALINDROME**fromtheracecarmadamimadam

Raw string = makefromtheracecarmadamimadam
Largest palindrome = madamimadam
Result so far: make**PALINDROME**fromtheracecar**PALINDROME**

Raw string = makefromtheracecar
Largest palindrome = racecar
Result so far: make**PALINDROME**fromthe**PALINDROME****PALINDROME**

Raw string = makefromthe
Largest palindrome = None
No more palindromes!
Final result is "make**PALINDROME**fromthe**PALINDROME****PALINDROME**".

import string
import sys

def parts(text, size):
	for i in xrange(len(text) - size + 1):
		yield text[i:i + size]
		
def substrings(text, min):
	for size in xrange(min, len(text) + 1):
		for part in parts(text, size):
			yield part

def maxlen(x, y):
	if len(x) > len(y): return x
	else: return y

def reverse(text):
	return "".join(list(reversed(text)))

def palindrones(text, min = 3):
	return set(s for s in substrings(text, min) if s == reverse(s))

def keep_only(text, keep):
	return "".join(c for c in text if c in keep)

def sanitise(text):
	return keep_only(text.lower(), string.lowercase)

def max_palindrone(text, min = 3):
	found = palindrones(sanitise(text), min)
	if found: return reduce(maxlen, found)

def split_at_substring(text, s):
	index = text.find(s)
	return text[:index], text[index:index + len(s)], text[index + len(s):]
	
def mark_palindrones(text, min = 3):
	palindrone = max_palindrone(text, min)
	if palindrone:
		before, _, after = split_at_substring(sanitise(text), palindrone)
		return mark_palindrones(before, min) + "**PALINDROME**" + \
		       mark_palindrones(after, min)
	else:
		return text

print mark_palindrones(sys.argv[1])

$ python palindrome.py "Makeable was I ere I saw Elba from the racecar (Madam, I'm Adam)."
make**PALINDROME**fromthe**PALINDROME****PALINDROME**

$ python palindrome.py '"Am I mad, eh?" Giselle sighed, "Am I, Ma?"'
**PALINDROME**