posted by Jeremy W

posted by rasx

private bool CheckPalindrome(string myString)

{

int First;

int Second;

First = 0;

Second = myString.Length - 1;

while (First < Second)

{

if(myString.Substring(First,1) == myString.Substring(Second,1))

{

First ++;

Second --;

}else{

return false;

}

}

return true;

}

posted by CRPietschmann

posted by Maurits

This line of command and performance encourages pride in being able to solve the specific problem without placing the problem in context. It sends out a false sense of security in being able to do whatever it takes to get the job done. It encourages “hard coding” instead of developing once for many problems.

And talking about this matter instead of writing code in this post is just me showing many sophomoric folk out there in the “real” world that I am simply stalling because I cannot solve the problem. I am using my slick talk to slide out of getting “real” work done. Right?

Many, many years ago, I failed to answer a job interview question where the interviewer was measuring my experience with VBA by finding out if I knew whether the StrReverse() function existed or not. What the interviewer would never know is that I wrote all of my string handling functions years before the interview and years before the StrReverse() function appeared in VBA. So I was doomed because I was unaware of this new function and I failed to memorize my own code that worked so well I forgot about it!

I will have the same problem now with C# because I fully intend to write my code so well that I won’t need to memorize every algorithm just to impress an interviewer. In the same manner that writing in Microsoft Word 2003 does not improve spelling skills, writing good code does not help me remember every algorithm under the sun. “Good” code is meant to be forgotten—and “good” documentation helps us remember in the appropriate context.

To me, the best way to interview a programmer is to put her in a room with a computer, tell her what the problem is and walk out of the room with a promise to return in 15 minutes. Very, very few programmers get the opportunity to stand up in front of a white board and “lecture” to people about solving the problem.

posted by rasx

posted by Maurits

posted by Maurits

Private Function IsPalindrome(ByVal TestString As String) As Boolean

Dim First As Integer = 0

Dim Last As Integer = TestString.Length - 1

While First < Last

   If TestString.Substring(First, 1) = TestString.Substring(Last, 1) Then

First += 1

Last -= 1

Else

Return False

End If

End While

Return True

End Function

posted by Gerard O'Donnell

posted by Maurits

posted by Maurits

posted by Maurits

posted by Maurits

posted by TimP

public bool IsPalindrome(string palindrome)
{
   if(palindrome == null || palindrome.Length == 0)
      return false;
   palindrome = palindrome.Replace(" ", "").ToLower();
   char[] reverse = palindrome.ToCharArray();
   Array.Reverse(reverse);
   string s = new string(reverse);
   return palindrome == s;
}

Here's a case/space insensitive and smaller palindrome checker.

posted by TimP

1000 Iterations
18.1072177121771
1000 Iterations
12.1946568265683

5000 Iterations
17.8115896678967
5000 Iterations
12.046842804428

10000 Iterations
17.2203335793358
10000 Iterations
11.4925402214022

15000 Iterations
17.121790897909
15000 Iterations
11.6280364083641

20000 Iterations
17.1833800738007
20000 Iterations
11.5294937269373

30000 Iterations
17.2080157441574
30000 Iterations
11.7019434194342

Non-Palindromes:

1000 Iterations
21.8025682656827
1000 Iterations
15.1509372693727

5000 Iterations
21.6547542435424
5000 Iterations
15.2248442804428

10000 Iterations
21.8764752767528
10000 Iterations
14.6335881918819

15000 Iterations
21.777932595326
15000 Iterations
14.6089525215252

20000 Iterations
22.0981963099631
20000 Iterations
14.6890184501845

30000 Iterations
22.3075995079951
30000 Iterations
14.7444487084871

The character by character method beating the Array.Reverse method on non-palindromes is a no brainer, because it returns false after the first check, where as the Array.Reverse has to reverse and test the whole string every time.

I was a bit surprised by it winning on palindromes, though. If anyone has any insight into this, I'd love to hear it. All I can assume is that a character by character check is more efficient than putting a string into an array, reversing it, and putting it back into a string.

posted by TimP

      while (first <= last)
      {
         if (*first != *last)
            return false;

         first++;
         last--;
      }
      return true;
   }
   return false;
}

posted by GNUHippie

posted by rpg

#include <iostream>

#include <algorithm>

#include <string>

using namespace std;

bool IsPalindrome(string strName)

{

string strReverse = strName;

if(strName == "")

{

return false;

}

reverse(strReverse.begin(), strReverse.end());

for(int i = 0; i < strName.size(); i++)

{

if( strName[i] == strReverse[i] )

{

continue;

}

else

{

return false;

}

}

}

int main()

{

string strPalindrome;

cout << "Enter a word: ";

getline(cin, strPalindrome);

if(IsPalindrome(strPalindrome.c_str()) == false )

{

cout << strPalindrome << " is not a palindrome" << endl;

}

else

{

cout << strPalindrome << " is a palindrome" << endl;

}

getchar();

getchar();

return 0;

}

posted by goodeffort

posted by cwilliams1145

 // Special case , invalid input can not be palindrome
 if (NULL==str) {
   return false;
 }

 // Pointer to first character in string
 TCHAR* first = str; // Initialy point to start of string
 // Pointer to second character in string
 TCHAR* second = first; 
 // Pointer to last character in string
 TCHAR* last  = str + _tsclen(str); // Initialy point to null terminator
// Point to terminator character (not nessesary NULL terminator!)
 TCHAR* term = last;
 // Flag to indicate if any alpha-numeric characters were found
 bool   nonEmpty = false;

 do {
   do {
    // Threat second character as start of new string
    first = second;

    // Get pointer to next character in new string
    // Will be used to calculate length of first character
    second = CharNext(first);

    // If first character point to terminator - this mean that there is no any valid
    // characters - so nothing that can be different. Stop comparation
    if (first>=term) return nonEmpty;
   } while (!IsCharAlphaNumeric(*first));

   do {
     // Thread previous character as terminator of new string
     term = last;

     // Extract character previous to new terminator
     last = CharPrev(str,term);

     // If we terminator crossed start of our string - return information we know already
     if (first>=term) return nonEmpty;
   } while(!IsCharAlphaNumeric(*last));

   // Compare thouse extracted characters if they are equal
   if (CompareString(LOCALE_SYSTEM_DEFAULT, // Use system default because IsCharAlphaNumeric rely on system default
                    NORM_IGNORECASE | NORM_IGNOREWIDTH | NORM_IGNOREKANATYPE, // Some crazy flags
                    first,  // first alphanumeric chacter in our string
                    second-first, // length of first character
                    last, // last alphanumeric character
                    term-last    // length of last character
                    ) != CSTR_EQUAL) {
      return false;
   }

   // Here we can set flag to indicate if any AlphaNumeric characters were found
   nonEmpty = true;

 // Loop while there any character beetwean start of string and previnator
 } while (first<term);
 
 // Looks like nothing wrong were found
 // This is valid palindrome
 // But it will be nice to check if any AlphaNumeric were found
 return nonEmpty;
}

P.S> This is C++ source code. To convert to C declare variables early. I'm unsure it will compile and work - I've coded it in WordPad
 
NOTE: As I've found CharPrev and CharNext does not support Unicode 2.0 surrogates. Also this is unknown if CompareString support them.
But this is definitely an issue with IsCharAlphaNumeric function.
Looks like modification requered to work with Unicode correctly

posted by AT

posted by boneman

posted by bishfish

posted by Icon

//look for a forward and reverse character pattern. like so "ab c ba"

bool IsPalendrone(char* ptext)

{

bool rtnval = true;

//Check for NULL or a zero length string

if((ptext == NULL) || (*ptext == 0))

return false;

int textlen = strlen(ptext);

//Check for the case where ptext is only on char

if(textlen == 1)

return rtnval;

//ptext is more than one car we need to do some

//comparisons

char* lptr = ptext;

char* rptr = ptext + (textlen - 1);

do

{

//If we find a case where the character pointed to on

//the left and right are not equal we can say this is

//not a palendrone

if((*lptr) != (*rptr))

{

rtnval = false;

break;

}

//Move our pointer towards each other

lptr++;

rptr--;

}while(lptr <= rptr);

return rtnval;

}

posted by myronww

posted by myronww

posted by barlo_mung

static private bool isPalindrome (string stringToTest)

char[] stringChars = stringToTest.ToCharArray();

foreach (char character in stringChars)

if (char.IsPunctuation(character) || char.IsSeparator(character))

stringToTest = stringToTest.Replace(character.ToString(), "").ToLower();

if (stringToTest.Length % 2 == 0) // even number of characters in the string

int halfwayMark = (stringToTest.Length/2);

char[] firstHalf = stringToTest.Substring(0, halfwayMark).ToCharArray();

char[] secondHalf = stringToTest.Substring(halfwayMark, stringToTest.Length-halfwayMark).ToCharArray();

bool flag = true; // innocent until proven guilty

for (int i=0;i<halfwayMark;i++)

if (firstHalf[i] != secondHalf[i])

flag = false;

break; // break out of the loop

return flag;

else // odd number of chars, middle char needs to be ignored

int halfwayMark = (stringToTest.Length/2) + 1;

char[] firstHalf = stringToTest.Substring(0, halfwayMark).ToCharArray();

char[] secondHalf = stringToTest.Substring(--halfwayMark).ToCharArray();

bool flag = true;

for (int i=0;i<halfwayMark;i++)

if (firstHalf[i] != secondHalf[i])

flag = false;

break; // break out of the loop

return flag;

posted by x.static

bool IsPalindrome1(string &s)
{
	if(s.length() == 0) return false;
	string::iterator begin = s.begin();
	string::iterator last = s.end() -1;
	while(begin < last)
	{
		if(*begin++ != *last--) return false;
	}
	return true;
}

posted by mwirth

public bool IsPalindrome(string inputString)
{
 StringBuilder inputStringBuilder = new StringBuilder(inputString);
 for (int i = inputString.Length-1; i > -1; i--)
  {
   if (!Char.IsLetterOrDigit(inputString.Substring(i, 1),0))
   {
    inputStringBuilder.Remove(i, 1);
   }
  }
 return IsPalindromeNormalized( inputStringBuilder.ToString().ToLower());
}

private bool IsPalindromeNormalized(string inputString)
{
 switch (inputString.Length)
 {
  case 0:
   return false;
   break;
  case 1:
   return true;
   break;
  case 2:
   return inputString.Substring(0, 1) == inputString.Substring(1, 1);
   break;
  default:
   if (inputString.Substring(0, 1) == inputString.Substring(inputString.Length - 1, 1))
   {
    return IsPalindromeNormalized(inputString.Substring(1, inputString.Length - 2));
   }
   else
   {
    return false;
   }
   break;
 }
}

posted by PeterF

posted by PeterF

        If (strTest.Length > 0) Then

            Dim sourceArray As Char() = strTest.ToCharArray()

            Dim reversedArray(sourceArray.Length - 1) As Char

            System.Array.Copy(sourceArray, reversedArray, sourceArray.Length)

            reversedArray.Reverse(reversedArray)

            Return (sourceArray = reveredArray)

        Else
            Return (False)
        End If

    End Function

BLOG: www.anguslogan.com

posted by anguslogan

posted by mwirth

<script type="text/javascript">

// driver function
function check_palindrome(s)
{ var b = is_palindrome(s);

 if (b)
 { alert("YES\n\n" + s + "\n\nIS a palindrome\n");
 } else if (b == null)
 { alert("Is null a palindrome?  The answer is null.");
 } else
 { alert("NO\n\n" + s + "\n\nIS NOT a palindrome\n");
 }
}

// doesn't collate (n w/tilde doesn't match n w/o tilde)
// if accents are necessary then a Unicode-based function is probably the best way to go
function is_palindrome(s)
{ if (s == null) return null;  // pass ambiguity back to caller - let them decide

 var interestingcharspat = /[a-z]/i; // maybe add digits? or do /[:alpha:]/
 var casesensitive = 0;
 var index_left = 0;
 var index_right = s.length - 1;
 var char_left;
 var char_right;
 var debug = 1;

 while (index_left < index_right)
 {
  if (debug) alert(s.charAt(index_left) + ", " + s.charAt(index_right) + " at " + index_left + ", " + index_right);
  // get first interesting character on the left
  while (
   index_left < index_right &&
   !interestingcharspat.test(s.charAt(index_left))
  )
  { index_left++;
  }

  if (debug) alert(s.charAt(index_left) + ", " + s.charAt(index_right) + " at " + index_left + ", " + index_right);
  // get first interesting character on the right
  while (
   index_left < index_right &&
   !interestingcharspat.test(s.charAt(index_right))
  )
  { index_right--;
  }

  if (debug) alert(s.charAt(index_left) + ", " + s.charAt(index_right) + " at " + index_left + ", " + index_right);
  // if index_left >= index_right we're done
  if (index_left < index_right)
  { char_left = s.charAt(index_left);
   char_right = s.charAt(index_right);

   // handle case insensitivity
   if (!casesensitive)
   { char_left = char_left.toUpperCase(); // no-op on nonletters
    char_right = char_right.toUpperCase(); // no-op on nonletters
   }

   // if there's a mismatch then it's NOT a palindrome
   if (char_left != char_right)
   {
    if (debug) alert(char_left + ", " + char_right + " at " + index_left + ", " + index_right);
    return false;
   }

   // otherwise narrow the search by one
   index_left++;
   index_right--;
  }
 }

 // if we made it through with no mismatches it's a palindrome
 return true;
}

</script>

doesn't equate accented characters with their unaccented equivalent
<form onsubmit="check_palindrome(this.string.value); return false;">
<textarea name="string" rows="10" cols="50"
 >A man, a plan, a canal - Panama!</textarea><br>
<input type="submit" value="Check Palindrome-ness">
</form>

<a href="#" onclick="check_palindrome(null); return false;">Check palindrome-ness of null</a>

posted by Maurits

 while(1)
 {
  if(*first!=*last)
   return false;
  while(*(++first)==space);
  while(*(--last)==space);
 if(last<=first)
  return true;
 
 } 
}

Now I wasn't quite happy with having to use the built-in _tcsclen, but this does provide a relatively efficient result, and I managed to work in the ignoring of spaces, and I checked for null strings and null pointers.

6.  In an effort to make the solution a little more "pure", I decided to manually traverse the list, looking for the null, and then work my way half-way backwards checking as I go backwards. Code follows:

bool IsPalindrome(TCHAR* tcstring)
{
 if(tcstring==NULL|| *tcstring==NULL) return false;
 TCHAR* ptr=tcstring;
 TCHAR* halfptr;
 while(*(++ptr)!=NULL);
 halfptr=tcstring+(ptr-tcstring)/2;
 while(*(tcstring++) == *(--ptr) && ptr>halfptr);
 if(*(--tcstring) == *ptr) return true; 
 return false;
}

I like this solution for its efficiency, even though it won't handle spaces, case, or punctuation.  I could handle any of those by expanding the while loops.

7.  Lastly, I thought I'd see if I could gain anything by trying the typicalyl gimmicky recursion method.  Code follows:

bool IsPalindromeHelper(TCHAR* first, TCHAR* last)
{
 if(first>=last) return true;
 if(*first!=*last) return false;
 return(IsPalindromeHelper(first+1,last-1));
}

bool IsPalindrome(TCHAR* thestr)
{
 TCHAR* last=thestr;
 while(*(++last)!=NULL);
 return(IsPalindromeHelper(thestr,--last));
}

While the recursion adds a bit of a "cool" factor to the solution, it doesn't handle spaces or case, and you have the added overhead of the recursive call, so I don't think it's quite worth it.

8.  I'd probably go back to my second solution, and work in any requirements for spaces / case insensitivity. (and add comments of course!)

9.  For preliminary testing, I'd include null pointers, invalid pointers, null strings, non-terminated strings, even-length palindromes, odd-length palindromes, even and odd length non-palindromes, near palindromes with differences at the beginning/end, near palindromes with differences at the middle two chars for even length, and differences at +/-1 from middle for odd length.  Palindromes and non-palindromes of length 1,2, 3, and very large palindrome and non-palindrome inputs of lengths 2^10, 2^16-1,2^16,2^16+1, 2^32-1,2^32, 2^32+1, etc.  Also test palindromes that excercise any of the special requirements, i.e. spaces, punctuation, etc...  Include these special chars at beginning/end/middle...

posted by RickH

public bool isPalindrome(String s)

{

if ( s.Length <= 1 ) return true;

if ( s.EndsWith(s.Substring(0,1) ))

     return isPalindrome( s.Substring(1, s.Length - 2 ) );

return false;

}

posted by Anonieko Ramos

posted by Peter

posted by Maurits

1. Under this scheme, the text, "Mal Ayal Am" would be a pallindrome  because if you prun the spaces, it reads the same forwards and backwards. In such a case it would be correct to first trim the spaces inside the string and outside it (leading and trailing) and then use the IsPallindrome function above on the resultant string.
   
2. However, if you do not ignore the spaces, it is not a pallindrome because the spaces encountered in a forward traversal do not coincide with the spaces encountered backward. In such a case, the above mentioned IsPallindrome should yeild the correct results.
   

posted by Sathyaish Chakravarthy

posted by Maurits

posted by Sathyaish Chakravarthy

Input:
Characters, Numbers, Alphanumerics, White Spaces, Wildcards.
----

Example Test Cases:
tarat, ta r at, tar at, ta 1 at, ab 1A1 ba, ab1A 1ba etc (The code considers them correct inputs).
Ta a, ta 1 ata, etc are not palindromes.
----

Output:
True or False
----

Algorithm:
To acheive efficient memory management, computation time and code complexity, I would parse through the text from the two

corners ie begining and end and reach the center of the text while comparing each of the input characters. There would be

checks for white spaces. Other characters such as commas, appostrophies etc would be considered as character inputs. If it

encounters white spaces, it would ignore them and (increment the begining counter or decrement the end counter).

Other implementation such as a recursive one would require extra stack space and recursive calls to the heap. Which might

not be a good idea. Reversing the string and comparing with the original one would also not be a good idea as extra memory

would be required.

Pseudocode:
-Initilize all variables ie int beg, end, bool check variables.

-point the beg pointer to the first character of the input string.

-Find length of string and point the 'end pointer' to the (str_len - 1)th position.

-Enter a while loop and compare the beg and end.

---If they are equal, do beg++ and end--.

---if they are not, check for white spaces, ignore white spaces, and inc or dec accordingly ie if beg, inc beg and leave end

as it is, OR, if it is end, than dec end and leave beg to point to where it is pointing.

----if they are still not equal, return FALSE.

-end of program.
----

Complexity:
The complexity of the code would be O(n) where n is the length of the input string. In reality, the code would run for n/2

iterations as when the beg pointer reaches the middle+1th part of the string, it would stop the while loop.

Code:

#include <iostream.h>
#include <string.h>

bool ispalin(char * input)
{
 char * beg=new char;
 char * end = new char;
 
 beg = input;
 end = &input[strlen(input)-1];
 
 if(beg==0 || beg==NULL)
  return false;
 
 while(*beg==*end && *beg != input[strlen(input)/2])
 {
  if(*beg == ' ')
   beg++;
  if(*end = ' ')
   end--;
  if(beg!=end)
   return false;
  if(beg==end)
   return true;

  beg++;
  end--;
 }
 

}

int main()
{
 bool check=false;
 char * input = new char[30];
 cin.getline(input, 30, '\n');//as cin.getline caters to white spaces as well
 check = ispalin(input);

 if(check==0)
 {
  cout<<"equal\n";
 }
 else
  cout<<"not equal\n";

 return 0;
}
-------

posted by tashfeen_suleman

posted by CRPietschmann

posted by Sathyaish Chakravarthy

template <
   typename RandIt, 
   typename CharT, 
   CharT space
   >
bool IsPalindrome(RandIt start, RandIt end)
{
 end--;
 do
 {
  while (space == *start)
   start++;
  while (space == *end)
   end--;
  if (end < start)
   return false;
  if (*start != *end)
   return false;
  start++;
  end--;
  
 } while (start<end);
 return true;
}

bool IsPalindrome(const char* str)
{
 assert(str);
 return IsPalindrome<const char*,char,' '>(
   str,
   str+strlen(str)
   );
}

posted by cpdaniel

posted by goodeffort

posted by AT

posted by rasx

private bool IsYalendrome2(string t)
{
   if(t == null || t.Length == 0)
     return false;

   bool r = true;
   
   for(int i = 0, n = t.Length -1; i < n && r; i++, n--)
     r = t[i] == t[n];

   return r;
}

I like the XML-Blog solution (it's very elegant), but i think this one is a little more readable, and i think that's is one of the goal we (as developers) have to take care.

Anyway: B# use C# ;-D

posted by ezu

posted by Maurits

posted by Maurits

posted by MattK

posted by MattK

#include <list>

inline bool isAlphanumeric(_TCHAR ch) {

    return ((ch >= 'a') && (ch <= 'z') || (ch >= 'A') && (ch <= 'Z') || (ch >= '0') && (ch <= '9'));

}

int isPalindrome(_TCHAR* string) {

    // init

    if (string == 0) return -1;

    _TCHAR *c = string;

    std::list<_TCHAR> stack;

    // build stack

    while (*c != 0)

        stack.push_back(*c++);

    _TCHAR a, b;

    while (stack.size() > 1) {

        // pull the start and end items off the stack

        a = stack.front(); b = stack.back();

        stack.pop_front(); stack.pop_back();

        if (a != b) return 0;

        // they are both equal so just test one

        if (!isAlphanumeric(a)) return 0;

    }

    // if the middle character is not alphanumeric the stack scanning algorithm won't catch it, so check

    if ((stack.size() > 0) && (!isAlphanumeric(stack.back()))) return 0;

    return 1;

}

posted by Kaelan

posted by Maurits

posted by Maurits

    for(int f=0, b = s.Length - 1; f < b; f++, b--)
    {
        if(s[f] != s[b])
            return false;
    }
    return true;
}

Cheers Martin, with a phone number in palindrome...cool huh?

posted by ML

Me.txt2.Text = "True"

Else

Me.txt2.Text = "False"

End If
---------------------------

The code entails 3 objects - 2 text boxes and a button. Attach the code to a button control and
you are done.

The code handles punctuation, nulls, whitespaces and is even case sensitive meaning, this code recognizes case sensitive palindromes, so AbBa would not be considered a palindrome using this algorithm.

Now, depending on what side of the philosophical argument you are on in terms of what constitutes a palindrome relative to upper and lower case letters, the code I provided can be minimally tweaked to accommodate the palindrome for either interpretation. All that is needed to recognize mixed case palindromes is to integrate an additional function (UCase) to the mix.

I found this problem interesting but fairly easy to solve.

posted by Brice It

posted by AndyC

posted by Brice It

using System.Collections.Generic;

#endregion

namespace IsPalindrome

{

  using System.Globalization;

  using System.Text;

  class Program

  {

    static void Main(string[] args)

    {

      Program program = new Program();

      Console.WriteLine("IsPalindrome method passes: " + program.testIsPalindrome().ToString());

    }

    bool IsPalindrome(String candidate)

    {

      return IsPalindrome(candidate, CultureInfo.CurrentCulture);

    }

/// <summary>

/// From m-w.com, definition of Palindrome: a word, verse, or sentence (as "Able was I ere I saw Elba") or a number (as 1881) that reads the same backward or forward.

/// For the purposes of this method, a palindrome is a string whose component characters "read" the same

/// forwards or backwards, ignoring whitespace, punctuation, and control. Whether it means anything in the

/// target language is, unfortunately, ignored! But it should work with strings of any culture.

/// A null culture is assumed to mean the current culture.

/// A null or zero-length candidate string is not considered a palindrome.

/// </summary>

/// <returns></returns>

    bool IsPalindrome(String candidate, CultureInfo culture)

    {

      if (null == candidate)

        return false; // null candidates are not palindromes.

      if (candidate.Length == 0)

        return false; // zero-length candidates are not palindromes

      if (null == culture)

        culture = CultureInfo.CurrentCulture; // use the default if a null was provided.

      StringBuilder blackStringB = new StringBuilder(candidate.Length); // black string; no whitespace.

// remove whitespace, punctuation, control characters; they don't count towards palindromes.

      for (int i = 0; i < candidate.Length; i++)

      {

        if (!Char.IsWhiteSpace(candidate, i)

&& !Char.IsPunctuation(candidate, i)

&& !Char.IsControl(candidate, i))

          blackStringB.Append(candidate, i, 1);

      }

// now we have no whitespace.

      if (blackStringB.Length == 0)

        return false; // zero-length candidates are not palindromes

      String blackString = blackStringB.ToString().ToUpper(culture);

// we've removed case sensitivity by converting all characters to upper case.

      int length = blackString.Length;

      for (int i = 0; i < length / 2; i++)

      {

        if (0 != blackString[i].CompareTo(blackString[(length - i) - 1]))

        return false;

      }

      return true;

    }

    bool testIsPalindrome()

    {

// palindromes

    if (!IsPalindrome("a", CultureInfo.CurrentCulture))

      return false;

    if (!IsPalindrome("aA", CultureInfo.CurrentCulture))

      return false;

    if (!IsPalindrome("aa", CultureInfo.CurrentCulture))

      return false;

    if (!IsPalindrome("aaa", CultureInfo.CurrentCulture))

      return false;

    if (!IsPalindrome("2a7a2", CultureInfo.CurrentCulture))

      return false;

    if (!IsPalindrome("aaaa", CultureInfo.CurrentCulture))

      return false;

    if (!IsPalindrome("aBa", CultureInfo.CurrentCulture))

      return false;

    if (!IsPalindrome("a Ba", CultureInfo.CurrentCulture))

      return false;

    if (!IsPalindrome("aB a", CultureInfo.CurrentCulture))

      return false;

    if (!IsPalindrome("a.Ba?", CultureInfo.CurrentCulture))

      return false;

    if (!IsPalindrome("A B?; a?", CultureInfo.CurrentCulture))

      return false;

    if (!IsPalindrome("Able was I ere I saw Elba", CultureInfo.CurrentCulture)) // Napoleon, we hardly knew ye.

      return false;

    if (!IsPalindrome("A man, a plan, a canal: Panama!", CultureInfo.CurrentCulture))

      return false;

    StringBuilder sb = new StringBuilder();

    sb.Append(Char.MinValue);

    sb.Append(Char.MaxValue);

    sb.Append(Char.MinValue);

    if (!IsPalindrome(sb.ToString(), CultureInfo.CurrentCulture))

      return false;

    if (!IsPalindrome(GeneratePalindrome()))

      return false;

    if (!IsPalindrome(GeneratePalindrome()))

      return false;

    if (!IsPalindrome(GeneratePalindrome()))

      return false;

// not palindromes

    if (IsPalindrome("oiiunrviuhnuiycgcbzsrucgckjzsehbcuycu33ndjdjdj", CultureInfo.CurrentCulture))

      return false;

    if (IsPalindrome("67__32++7S'", CultureInfo.CurrentCulture))

      return false;

    if (IsPalindrome("ab", CultureInfo.CurrentCulture))

      return false;

    if (IsPalindrome("aB", CultureInfo.CurrentCulture))

      return false;

    if (IsPalindrome("", CultureInfo.CurrentCulture))

      return false;

    if (IsPalindrome(null, CultureInfo.CurrentCulture))

      return false;

    if (IsPalindrome("A man, a plan, a canal: Suez?", CultureInfo.CurrentCulture))

      return false;

    sb = new StringBuilder(); // check a string that can't be a palindrome with end chars.

    sb.Append(Char.MinValue);

    sb.Append(Char.MaxValue);

    sb.Append('a');

    sb.Append('a');

    sb.Append(Char.MinValue);

    sb.Append('a');

    if (IsPalindrome(sb.ToString(), CultureInfo.CurrentCulture))

      return false;

    return true;

    }

/// <summary>

/// A method for testing IsPalindrome, which brings forth the pressing question: who's testing GeneratePalindrome?

/// </summary>

  string GeneratePalindrome()

  {

    Random random = new Random();

    int halfLength = random.Next(80);

    char[] buffer = new char[halfLength * 2];

    for (int i = 0; i < halfLength; i++)

    {

      buffer[i] = (char)(random.Next(Char.MinValue, Char.MaxValue));

      buffer[buffer.Length - 1 - i] = buffer[i];

    }

    return new string(buffer);

    }

  }

}

posted by pmcculler

posted by PeterF

posted by xml-blog

      short begin = 0, end = (short)bits.Length;
      for(short x = begin, z = end; x < bits.Length / 2 ; x++, z--)
         result = (bits[x]==bits[z-1]);

      return result;
   }
};

posted by Garnet

posted by Maurits

The winner is:    "empty string is a palindrome"   

posted by Maurits

posted by USAF1

posted by identy

posted by AT

posted by arfnarfsi

posted by Maurits

 {
    if (firstHalf[i] != secondHalf[i])
   {
     return false;
   }
 }
 return true;
}

performance wise, this is much cheaper than most other solutions presented as it goes char by char.

posted by x.static

static private bool isPalindrome (string stringToTest)

char[] stringChars = stringToTest.ToCharArray();

// format the string

foreach (char character in stringChars)

if (char.IsPunctuation(character) || char.IsSeparator(character))

stringToTest = stringToTest.Replace(character.ToString(), "").ToLower();

int halfwayMark = (stringToTest.Length/2);

char[] firstHalf = stringToTest.Substring(0, halfwayMark).ToCharArray();

char[] secondHalf = stringToTest.Substring(halfwayMark).ToCharArray();

for (int i=0;i<halfwayMark;i++)

if (firstHalf[i] != secondHalf[i])

return false;

return true;

posted by x.static

   TCHAR *e, *p = s;

   if (p == 0 || *p == 0) return false;

   e = p + _tcslen(p) - 1;

   while (*e == *p && e != p && e != s) { e--; p++; }

   return e == p || e == s;

}

printf("%s=%d\n", "ABBA", IsPalindrome("ABBA"));
printf("%s=%d\n", "ABXBA", IsPalindrome("ABXBA"));

ABBA=1
ABXBA=1

posted by JonasE

posted by ZippyV

   if (checkString != null)
   {
      for (int i=0; i<checkString.Length; i++)
      {
         if (checkString.Substring(i, 1) != checkString.Substring(checkString.Length - (i + 1), 1))
         {
            result = false;
            break;
         }
      }
   }
   return result;
}

posted by jj

posted by jj

         void DoIt();

}

public class Base : ICommon {

         void ICommon.DoIt() { Debug.Write (“A”); }

         public virtual void DoIt() { Debug.Write (“B”); }

}

public class Derived : Base, ICommon {

         void ICommon.DoIt() { Debug.Write (“C”); }

         public new virtual void DoIt() { Debug.Write (“D”); }

}

public class ReallyDerived : Derived, ICommon {

         public override void DoIt() { Debug.Write (“E”); }

}

static void Main() {

         ReallyDerived r1 = new ReallyDerived();

         Derived r2 = r1;

         Base r3 = r1;

         ICommon r4 = r1;

         r1.DoIt();

         r2.DoIt();

         r3.DoIt();

         r4.DoIt();

}

posted by JonasE

bool IsPalindrome(string sz)
{
  string szReverse(sz.length(), ' ');
  reverse_copy(sz.begin(), sz.end(), szReverse.begin());
  return szReverse == sz;
}

bool IsPalindrome2(string sz)
{
  string::iterator forward = sz.begin(), backward = sz.end() - 1;
  while( forward < backward && *forward == *backward ) {
    ++forward; --backward;
  }
  return forward >= backward;
}

template<typename T>
bool IsPalindrome3(T sz)
{
  T::iterator forward = sz.begin(), backward = sz.end() - 1;
  while( !(forward - 1 == backward || forward == backward) && *forward == *backward ) {
    ++forward; --backward;
  }
  return (forward - 1 == backward || forward == backward);
}

int main()
{
  string sz;
  cout << "Please enter a string:" << endl;
  getline(cin, sz);
  if( IsPalindrome2(sz) )
    cout << "It's a palindrome!" << endl;
  else
    cout << "It's not a palindrome!" << endl;
 
  return 0;
}

Three versions in C++, the first one is the lazyman's version, using std::reverse_copy. The second one is the iterator implementation. And since I figured I was using iterators anyway, so why not make a templated version that works on any standard container that defines a begin() and end() that return a bidirectional iterator. That way you can check a std::list for being a palindrome too! ^_^
You could also make a version two template iterator parameters, like many of the <algorithm> functions, that would work on any bidirectional iterator, including pointers.

posted by Sven Groot

posted by fabulous

Private Function IsPalindrome(ByVal inWord As String) As Boolean
   Dim max As Integer = inWord.Length - 1
   For i As Integer = 0 To max \ 2
      If Not inWord.Substring(i, 1) = inWord.Substring(max - i, 1) Then
         Return False
      End If
   Next
   Return True
End Function

posted by fabulous

posted by rpg

posted by sc00ter

posted by CatsCradle

bool IsPanlindrome( TCHAR *pszString )
{
   if ( NULL == pszString )
      return false;

   const int length = lstrlen( pszString );
   const int repeat = length / 2;

   for ( int loop = 0; loop < repeat; ++loop )
   {
      if ( pszString[ loop ] != pszString[ length - 1 - loop ] )
         return false;
   }

   return ( 0 != length );
}

I say similar, because I would probably have been very nervous so it may not have been exactly the same. I also think I wouldn't have written as much pseudo code as in the video, as the simplicity of the question coupled with my nervousness may have had me thinking 'he just wants me to write the code'.

I would have pointed out I was dividing the length by two because the integer arithmetic would simply discard the central character for odd length strings.

n!

posted by nfactorial_

ZippyV wrote:

Channel 9 should have a 'weekly coding challenge'.

posted by CaptainOblivious

posted by mochafella

posted by mochafella

posted by hong

This book provides a comprehensive introduction to the modern study of computer algorithms. It presents many algorithms and covers them in considerable depth, yet makes their design and analysis accessible to all levels of readers. We have tried to keep explanations elementary without sacrificing depth of coverage or mathematical rigor.  Each chapter presents an algorithm, a design technique, an application area, or a related topic.

Algorithms are described in English and in a “pseudocode” designed to be readable by anyone who has done a little programming. The book contains over 230 figures illustrating how the algorithms work. Since we emphasize efficiency as a design criterion, we include careful analyses of the running times of all our algorithms.

The text is intended primarily for use in undergraduate or graduate courses in algorithms or data structures. Because it discusses engineering issues in algorithm design, as well as mathematical aspects, it is equally well suited for self-study by technical professionals.  In this, the second edition, we have updated the entire book. The changes range from the addition of new chapters to the rewriting of individual sentences.

This book is designed to be both versatile and complete. You will find it useful for a variety of courses, from an undergraduate course in data structures up through a graduate course in algorithms. Because we have provided considerably more material than can fit in a typicalone-term course, you should think of the book as a “buffet” or “smorgasbord” from which you can pick and choose the material that best supports the course you wish to teach. You should find it easy to organize your course around just the chapters you need. We have made chapters relatively self-contained, so that you need not worry about an unexpected and unnecessary dependence of one chapter on another. Each chapter presents the easier material first and the more difficult material later, with section boundaries marking natural stopping points. In an undergraduate course, you might use only the earlier sections from a chapter; in a graduate course, you might cover the entire chapter. We have included over 920 exercises and over 140 problems. Each section ends with exercises, and each chapter ends with problems. The exercises are generally short questions that test basic mastery of the material. Some are simple self-check thought exercises, whereas others are more substantial and are suitable as assigned homework. The problems are moreelaborate case studies that often introduce new material; they typically consist of several questions that lead the student through the steps required to arrive at a solution.

We have starred (⋆) the sections and exercises that are more suitable for graduate students than for undergraduates. A starred section is not necessarily more difficult than an unstarred one, but it may require an understanding of more advanced mathematics. Likewise, starred exercises may require an advanced background or more than average creativity.

We hope that this textbook provides you with an enjoyable introduction to the field of algorithms. We have attempted to make every algorithm accessible and interesting. To help you when you encounter unfamiliar or difficult algorithms, we describe each one in a step-bystep manner. We also provide careful explanations of the mathematics needed to understand the analysis of the algorithms. If you already have some familiarity with a topic, you will find the chapters organized so that you can skim introductory sections and proceed quickly to the more advanced material.

This is a large book, and your class will probably cover only a portion of its material. We have tried, however, to make this a book that will be useful to you now as a course textbook and also later in your career as a mathematical desk reference or an engineering handbook. What are the prerequisites for reading this book?

·        You should have some programming experience. In particular, you should understand recursive procedures and simple data structures such as arrays and linked lists.

·        You should have some facility with proofs by mathematical induction. A few portions of the book rely on some knowledge of elementary calculus. Beyond that, Parts I and VIII of this book teach you all the mathematical techniques you will need.

The wide range of topics in this book makes it an excellent handbook on algorithms. Because each chapter is relatively self-contained, you can focus in on the topics that most interest you. Most of the algorithms we discuss have great practical utility. We therefore address implementation concerns and other engineering issues. We often provide practical alternatives to the few algorithms that are primarily of theoretical interest.

If you wish to implement any of the algorithms, you will find the translation of our pseudocode into your favorite programming language a fairly straightforward task. The pseudocode is designed to present each algorithm clearly and succinctly. Consequently, we do not address error-handling and other software-engineering issues that require specific assumptions about your programming environment. We attempt to present each algorithm simply and directly without allowing the idiosyncrasies of a particular programming language to obscure its essence.

posted by prog_dotnet

Go:
lea edi,[string]
mov ecx,5 ;length
call Palindrome
;al=1 == true

posted by mikosoft

posted by guydotnetxmlwebservices

posted by The Channel 9 Team

   if(str.length()==0)

      return false;

   else if(str.length()<=2)

      return str[0]==str[str.length()-1];

   else{

      if(str[0]==str[str.length()-1])

         return IsPalindrome(str.substr(1,str.length()-2));

      else

         return false;

   }

}

posted by Rtugok

If a.Length < 2 Then Return True

If a.Chars(0) = a.Chars(a.Length - 1) Then

a = a.Remove(a.Length - 1, 1)

If a.Length > 0 Then a = a.Remove(0, 1)

Return isPalendrome(a)

End If

Return False

End Function

posted by Guster_Q

posted by homerjay

posted by peterpeter

posted by Jos104

posted by HippieGeek

      /// <summary>
      /// Verifies the input text is a palindrome.
      /// </summary>
      /// <param name="input">The text to be       verified.</param>
      /// <param name="ignoreWhitepspace">Option set to true to ignore whitespace.</param>
      /// <param name="caseSensitive">Option that toggles case-sensitive.</param>
      /// <param name="alphaOnly">Option that verifies only alpha-numeric characters exist.</param>
      public static void VerifyPalindrome(string input, bool ignoreWhitespace, bool caseSensitive, bool alphaOnly)
      {
#if DEBUG
         // verify input is not null
         // NOTE: we could simply rely on Replace() below to throw this exception, hence DEBUG
         if (input == null) 
            throw new NullReferenceException("Input cannot be null.");
#endif

         // strip whitespace
         if (ignoreWhitespace)
            input = System.Text.RegularExpressions.Regex.Replace(input, @"\s", "");

         // verify alphanumeric
         if (alphaOnly && System.Text.RegularExpressions.Regex.IsMatch(input, @"\W"))
            throw new ApplicationException("Input contained non-alphanumeric characters.");

         // lowercase input
         if (!caseSensitive)
            input = input.ToLower();

         // verify input length is valid for a palindrome
         if (input.Length < 2)
            throw new ApplicationException("Length of input must be greater than 1.");

         int forwardIndexer = 0, reverseIndexer = input.Length-1;

         while ((forwardIndexer <= reverseIndexer) && (input[forwardIndexer] == input[reverseIndexer]))
         {
            forwardIndexer++;
            reverseIndexer--;
         }

         if (forwardIndexer <= reverseIndexer)
            throw new ApplicationException("Not a valid Palindrome.");
      }

      /// <summary>
      /// Performs a case insensitive, non-whitespace intensive palindrome verification on the input string.
      /// </summary>
      /// <returns>true if input is a palindrome</returns>
      public static bool IsPalindrome(string input)
      {
         try
         {
            VerifyPalindrome(input, true, false, false);
         }
         catch (ApplicationException appex)
         {
            return false;
         }
         return true;
      }
   }
}


I prefer that exceptions be leveraged especially for internal code. Optimization based on failure-rates aside, I think it's more elegant to say in-code:

string input = "dood";
VerifyPalindrome(input);

and then fail back to the caller if he supplied us with invalid input. No need to continually re-invent error checks because of booleans along the stack.

Of course, 1 or two more overloads wouldn't hurt.

I didn't read through ALL posts made by everyone. If it looks like I copied your code, sorry, just know I didn't get past the t-sql post on the first page before realizing I thought the code should be done differently. This took me 9 minutes. I didn't test it (whiteboards don't have a debugger at Microsoft, do they?)

posted by SEWilson

posted by Maurits

using System;
using System.Text;
using System.Globalization;

bool IsPalindrome(string st) {
  StringInfo si = new StringInfo(st);
  int count = si.LengthInTextElements;

  if (count == 0) return false; 

  for (int i = 0; i < ((count % 2 != 0) ? count - 1 : count) / 2; i++) {
    string st1 = si.SubstringByTextElements(i, 1);
    string st2 = si.SubstringByTextElements(count - i - 1, 1);

    if (CultureInfo.CurrentCulture.CompareInfo.Compare(st1, st2) != 0) {
      return(false);
    }
  }

  return (true);
}

posted by michkap

using System;
using System.Text;
using System.Globalization;

bool IsPalindrome(string s)
{   char[] cs = s.ToCharArray();
    Array.Reverse(cs);
    string r = new string(cs);

    CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
    CompareOptions co =
        CompareOptions.IgnoreCase |
        CompareOptions.IgnoreKanaType |
        CompareOptions.IgnoreNonSpace |
        CompareOptions.IgnoreSymbols |
        CompareOptions.IgnoreWidth;

    return (ci.Compare(s, r, co) == 0);
}

posted by Maurits

posted by michkap

string StringReverse(string s)
{    TextElementEnumerator e = StringInfo.GetTextElementEnumerator(s);
    string r = "";

    while (e.MoveNext())
    {    r = e.GetTextElement() + r;
    }

    return r;
}

bool IsPalindrome(string s)
{   string r = StringReverse(s);

    CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
    CompareOptions co =
        CompareOptions.IgnoreCase |
        CompareOptions.IgnoreKanaType |
        CompareOptions.IgnoreNonSpace |
        CompareOptions.IgnoreSymbols |
        CompareOptions.IgnoreWidth;

    return (ci.Compare(s, r, co) == 0);
}

posted by Maurits

bool IsPalindrome(string s)
{    CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
    CompareOptions co =
        CompareOptions.IgnoreCase |
        CompareOptions.IgnoreKanaType |
        CompareOptions.IgnoreNonSpace |
        CompareOptions.IgnoreSymbols |
        CompareOptions.IgnoreWidth;

    int i = 0;
    TextElementEnumerator e = StringInfo.GetTextElementEnumerator(s);
            
    while (e.MoveNext())
    {    i++; // just counting, that's all
    }

    String[] ts = new String[ i ];

    e.Reset();
    i = 0;
    while (e.MoveNext())
    {    ts[ i ] = e.GetTextElement();
        i++;
    }

    // phew!  Now ts[ i ] is an array of textelements
    // place finger A on the beginning of the string
    // place finger B on the end of the string
    // move fingers toward the middle a step at a time
    // until you get to a mismatch or your fingers meet
    int a = 0;
    int b = ts.Length - 1;
    while (a < b)
    {    // move A forward until you find an interesting element
        while (a < b && ci.Compare(ts[ a ], "", co) == 0)
        {    a++;
        }

        // move B backward until you find an interesting element
        while (a < b && ci.Compare(ts[ b ], "", co) == 0)
        {    b--;
        }

        if (a < b)
        {    // compare the two elements
            // if they're the same, continue...
            if (ci.Compare(ts[ a ], ts[ b ], co) == 0)
            {    a++; b--;
            }
            else // they're different - NOT a palindrome
            {    return false;
            }
        }
    }

    return true;
}

posted by Maurits

posted by fxbrain

      For X := 1 to Length(Str1) do
        Insert(Copy(Str2,X,1),WorkStr,0);

      If (WorkStr = Str1) Then
        Result := prTrue
      Else
        Result := prFalse;

    Except
      On Exception do Result := prException;

    End;
  Finally
    //Perform any necessary cleanup
  End;

posted by RuneSpyder

bool isAlphaNumeric(char c)
{
    if(iswalpha(c) || iswdigit(c)) return true;
    return false;    
}

bool isPalindrome(char *str)
{
    if(*str == '\0')
    {
        return false;    
    }
    int len = strlen(str);
    if(len <= 1) return true; // 0- or 1-length strings are simplest palindromes
    
    char *start = str;
    char *end = start + strlen(str) - 1;
    
    while(start < end)
    {
        // if start not a char, increment start and continue
        if(!isAlphaNumeric(*start))
        {
            *start++;
            continue;    
        }
        // if end not a char, decrement end and continue
        if(!isAlphaNumeric(*end))
        {
            *end--;
            continue;    
        }
        // if two characters are not equal, return false
        if(towlower(*start) != towlower(*end)) return false;
        // otherwise start++, end--
        *start++;
        *end--;        
    }
    return true;
}

void revstr(TCHAR *str)
{
    if(*str == '\0')
    {
        return;    
    }
    
    TCHAR *start = str;
    TCHAR *end = start + strlen(str) - 1;
    
    while(start < end)
    {
        *start ^= *end;
        *end ^= *start;
        *start ^= *end;
        *start++;
        *end--;
        // could also use *start ^= *end ^= *start++ ^= *end-- if you want to get fancy
    }    
}

posted by DoggettCK

posted by ritzbit

posted by vivemoire

posted by ton_chat

posted by bentan

{

   char[] _chars = val.ToCharArray();

   System.Array.Reverse(_chars);

   string _reverseVal = new string(_chars);

   return val.Equals(_reverseVal);

}

posted by IanB

 while( str < end )
  result &= (((*(str++)) ^ (*(end--))) == 0);
 return result;
}

posted by emreknlk

      while(ptsz < ptszEnd)
      {
         bool bDoCheck = true;
         for(size_t i = 0; i < sizeof(ptszSkip)/sizeof(ptszSkip[0]); i++)
         { /*check for skiped chars*/
            if(*ptsz == ptszSkip[i])
            {
               ++ptsz;
               bDoCheck = false;
               break;
            }
            if(*ptszEnd == ptszSkip[i])
            {
               --ptszEnd;
               bDoCheck = false;
               break;
            }
         }

         if(bDoCheck)
         {
            if(*ptsz != *ptszEnd) //as soon as find first not equal chars ,  return false
            {
               bRet = false; 
               break;
            }
            ++ptsz;
            --ptszEnd;
         }
      }
   }
   return bRet;
}

posted by IgorZ

posted by J.Marcelo Auler

posted by FigmentEngine

posted by variable

bool is_palindrome(char *string) {
	int length = strlen(string);
	
	for(int i = 0; i < length / 2; ++i) {
		if (string[i] != string[length-i-1])
			return false;
	}
	
	return true;
}

posted by rxxjxxk