8.3.4. palnumber.cpp

The following palnumber demonstrations follow the algorithms developed in the Palindrome-number problem section and parallel the cpalnumber.cpp programs presented previously in this chapter. However, the following demonstrations replace the C-strings used in the earlier versions with instances of the C++ string class. Presented first is a string version of the "finger" solution. The next example creates a function that converts integers into string objects, a function similar to the itoa function we wrote previously. The last demonstration presents a string version of the "reverse" solution.

Programming The "Finger" Solution

#include <iostream>
#include <string>
using namespace std;

int main()
{
	for (int number = 1; ; number++)				// (a/I.i. and I.ii.)
	{
		int	square = number * number;			// (b/II.)

		//----------------------------------------------	   III.
		string	s = to_string(square);				// (c)

		//----------------------------------------------	   IV.
		if (s.length() < 6)					// (d/IV.i)
			continue;

		if (s[0] == '0' || s[s.length() - 1] == '0')		// (e/IV.ii)
			continue;

		//----------------------------------------------	   IV.iii
		int	i;						// (f)
		for (i = 0; i < s.length() / 2; i++)			// (g)
			if (s[i] != s[s.length() - 1 - i])		// (h)
				break;

		if (i == s.length() / 2)				// (i)
		{
			cout << number << " " << square << endl;	// (j)
			break;
		}
	}

	return 0;
}

Converting Numbers To Strings

Visual Studio 2012 added the to_string function to C++. Before then, the palnumber example included its own version of to_string. Although writing our own to_string function is no longer necessary, doing so is still a good learning exercise. Internally, computers store textual data in a coded format. Java uses Unicode, a 2-byte integer, to encode text. C++ can represent text as a 1- or 2-byte (wide) character. We focus on 1-byte characters encoded with the older American Standard Code for Information Interchange (ASCII) scheme.

Examine the ASCII table, especially the middle column; look at the codes for the characters '0' through '9' (the red characters). The character '0' is represented by the numeric code 48 (base 10), and the character '9' is represented by the numeric code 57 (base 10). Also, notice that the characters between '0' and '9' are represented by consecutive code values.

Given an integer, our task is to convert that integer into a string that looks like the number. The solution involves working with an integer one digit at a time. If we work from left to right, the string will contain the digits in the correct order. However, working from left to right is difficult because we don't know how many digits the number has. Working backward (right to the left) is easier but converts the digits in reverse order. The string concatenation operator allows us to solve this problem elegantly: we append or concatenate the new characters on the right side of the string as we build it.

Before using our conversion function, we must modify the palnumber.cpp code in Figure 1 in two ways:

1. Add a prototype at the top of the file: string my_to_string(int n);
2. Replace the function call to_string(square); with my_to_string(square);

string my_to_string(int n)			// (a)
{
	string	s;				// (b)
	string	sign;				// (c)

	if (n < 0)				// (d)
	{
		sign = "-";
		n *= -1;
		// n = -n;			// alternate way of making n positive
	}

	do					// (e)
	{
		s = (char)(n % 10 + '0') + s;	// (f)
		n /= 10;			// (g)
	} while (n);				// (h)

	return sign + s;			// (i)
}

The Reverse Solution

The definition of a palindrome is a string that reads the same forwards and backward (without considering spaces or other punctuation characters). The program described below solves the palindrome-number problem based on the definition. It reverses the candidate string and then compares it to the original string. If the two strings are the same (i.e., equal), then the candidate string is a palindrome; if the two strings are not the same, then the candidate is not a palindrome.

int main()
{
	for (int number = 1; ; number++)				// (a)
	{
		int	square = number * number;			// (b)
		string	s = to_string(square);				// (c)

		if (s.length() < 6)					// (d)
			continue;

		if (s.find('0') == 0 || s.rfind('0') == s.length() - 1)	// (e)
			continue;

		if (s == reverse(s))					// (f)
		{
			cout << number << " " << square << endl;
			break;
		}
	}

	return 0;
}

string reverse(string s)
{
	string r;

	for (int i = 0; i < s.length(); i++)	// (a)
		r += s[s.length() - 1 - i];	// (b)

	return r;
}

string reverse(string s)
{
	string r;

	for (char c : s)		// (c)
		r = c + r;		// (d)

	return r;
}

Comparing the C-string and string class solutions for the palindrome-number problem, including the three different versions of the reverse function, suggests three elaborating questions that we should ask ourselves:

1. The C-string solution copied the candidate string before reversing, but the string class solution does not. Why are the solutions different?
2. The for-loop in the C-string version iterates for one-half the length of the string, but both string class versions iterate for the string's full length. Why is there a difference?
3. The two string class versions use different concatenation operators to build the reversed string. The traditional for-loop uses the concatenation-with-assignment operator, +=, which concatenates the new character to the right of the reversed string. The for-range loop uses separate operators: + and =, and c+r concatenates the new character to the left of the reversed string. Can you figure out why there is a difference?

Downloadable Code

• palnumber.cpp (formatted with tab stops set at 8 characters)
• reverse1.cpp (formatted with tab stops set at 8 characters)
• reverse2.cpp (formatted with tab stops set at 8 characters)