Example of Binary Addition

Binary Arithmetic

Binary arithmetic is of interest because that’s how computers do math. When implemented in computers, many things must be taken into account: format (fixed-point, floating-point, etc.), word size (8-bit, 16-bit, 32-bit, etc.), sign representation (sign-magnitude, ones’ complement, two’s complement, etc.), overflow (when numbers are too big), and underflow (when numbers are too small). Furthermore, there is the design of the circuits to perform the algorithms (full adders, half adders, ripple carry adders, carry-lookahead adders, restoring dividers, non-restoring dividers, etc.). These are not inherent properties of binary arithmetic — they’re just implementation issues.

The truth is, in its purest form, binary arithmetic is very simple. The same “pencil and paper” algorithms you learned in grade school work for binary numbers. All you do differently is apply the “facts” for binary numerals, the (small) set of rules for manipulating 0s and 1s. And binary numbers on paper are written as you’d expect: without leading zeros, and with a minus sign (‘-’) if negative.

In my series of articles, I will explain the pure forms of the four basic operations of binary arithmetic: addition, subtraction, multiplication, and division. In this first article, I will discuss binary addition.

Decimal Addition

To add two multiple-digit decimal numbers, you first need to know how to add two single-digit decimal numbers. This requires the memorization of 100 facts, or 55 facts if you exclude the commutative or “turnaround” facts. Also, because of carries, you need to know ten additional facts: 10 + 0 = 10, 10 + 1 = 11, … , 10 + 9 = 19. The latter apply when there’s a carry (always 1) and the “top” digit is 9.

For example, let’s add 19.7 and 12.8:

Example of Decimal Addition

Let’s think about what a carry does. It turns our neat “add two single-digit numbers per column” problem into “add three single-digit numbers per column.” But addition is a binary (in a different sense) operation, meaning it operates on two numbers at a time. So what we do is add the carry to the “top” digit, and then add that result to the “bottom” digit. The first addition may result in a double digit answer (10), which means we’d have to use one of the ten extra facts to do the second addition.

In our example, the carry is added to 9, giving 10, and then 10 is added to 2, giving 12. The second addition used the extra “10 + 2 = 12″ fact.

Decimal Addition Showing Intermediate Additions

Binary Addition

Binary addition works the same way as decimal addition, except it uses a different — and much smaller — set of facts. There are only four single-digit facts, or three if you exclude the commutative fact. To handle carries, you need to know two additional facts, 10 + 0 = 10 and 10 + 1 = 11. (Resist the urge to pronounce 10 as ten and 11 as eleven; either call them one-zero and one-one, or two and three.) The latter apply when there’s a carry (always 1) and the “top” digit is 1.

Of the five order-independent facts, two are the same as in decimal (0 + 0 = 0 and 1 + 0 = 1), and one is trivial since it just adds zero (10 + 0 = 10). This leaves only two facts to memorize: 1 + 1 = 10 and 10 + 1 = 11!

To add two binary numbers, proceed as in decimal addition:

• If one or both numbers has a fractional part, line up the radix points.
• Proceeding from right to left, add the digits in each “column,” according to the facts table.
• If the result has two-digits, write down the least significant digit; carry the most significant digit to the next column.

Let’s return to the example in the introduction, 1011.01 + 11.011, this time showing it step-by-step:

Steps of Binary Addition

Eventually you won’t need to write down the intermediate additions, and you might even start doing ‘1 + 1 + 1’ as one step.

Checking the Answer

You can verify the answer by converting the operands to decimal, doing decimal addition, and then converting the decimal answer to binary (of course you can do it that way period, avoiding binary arithmetic entirely!). 1011.01 = 11.25, and 11.011 = 3.375. They sum to 14.625, which is 1110.101, the answer we got using binary addition.

Discussion

We didn’t need to know the place value of columns, or that a carry represents a power of the base; the algorithm is base-independent. We did however need a base-dependent set of facts, which allowed us to manipulate binary numerals according to the basic rules of binary addition.

By Rick Regan (Copyright © 2008-2012 Exploring Binary)

Binary Addition

(Please post your own in the comments.)

By Rick Regan (Copyright © 2008-2012 Exploring Binary)

Binary Numbers Haiku

My presentation was based on base-ten-block-like imagery, since I knew the students were comfortable expressing numbers with base ten blocks. I thought extending the block model to other bases would work well. I think it did.

The Number Twenty-Seven in Tape Flags, Broken Into Powers of Two

Introduction

Before my presentation, I put twenty-seven tape flags on the whiteboard, in an unorganized fashion like this:

Twenty-Seven Objects

(I would have preferred to use magnets instead of tape flags, since they would have been easier to move and align; but I didn’t have twenty-seven identical magnets.)

I started my presentation by telling the class that I would teach them about something called binary numbers, but that first I would review the numbers they already know — decimal numbers (I took a moment to explain that this was not the same as “decimals”). The first thing we did was count the tape flags, and as we counted together I rearranged them into a line:

Twenty-Seven Objects, Arranged In a Line

I asked them how they would write that number. One student came up and wrote “27,” which is the first answer I expected. Other suggestions were Roman numerals (“XXVII”) and “twenty-seven,” also as I anticipated. One student suggested writing it in Japanese (I was expecting a foreign language, but Spanish: “veintisiete”). Some students suggested arithmetic expressions, like 20 + 7. One unexpected answer was from a girl who wrote it on the board in base ten blocks, which is how I was planning to rearrange the tape flags next!

I suggested tally marks as another alternative, and wrote twenty-seven in tally marks on the board.

Decimal

I singled-out the answer “27” and said it is written in place value. I reviewed how the places were powers of ten. Then, as the class counted along to twenty-seven, I rearranged the flags into base ten block powers of ten groups, under headings labeled “tens” and “ones”:

Twenty-Seven Objects, Broken Into Powers of Ten

We counted the powers of ten and wrote the totals in the blanks I drew below each grouping of blocks; we came up with the numeral “27”: two tens and seven ones.

Quinary

I told the class that place value is not limited to base ten. I said, for example, you could write any number in base five, or quinary. (I wanted to take an intermediate step to binary, which is the simplest base, having only a maximum of one instance of each power.) I had them compute the powers of five from one to 625, and I explained that these are the places in quinary. I told them we would group the flags into powers of five. I wrote three headings on the board: “twenty-fives,” “fives,” and “ones.”

I asked “are there any twenty-fives in twenty-seven” and they said “yes.” We then counted out twenty-five flags, which I removed from the decimal grouping we’d just done. I built a block as we went, under the twenty-five label. Next I asked if there were any more twenty-fives in the flags that remained, and they quickly said “no.” They could also see there were no fives, and that there were only two ones left, which I moved under the ones label.

Twenty-Seven Objects, Broken Into Powers of Five

We counted the powers of five and wrote them under each grouping of blocks, coming up with the numeral “102”: one twenty-five, zero fives, and two ones. Some kids wanted to pronounce this as “one-hundred and two”, but I told them you pronounce it as “twenty-seven,” or “one-zero-two base five.”

Binary

Now I said let’s look at another example of place value: base two, or binary. I said it is based on powers of two. We computed the powers of two from one to thirty-two (my son was rattling them off to 4096 before I could cut him off ), which they remembered from my last visit.

We proceeded as above, except we pulled out the powers of two (from the flags in the quinary grouping): first we looked for sixteens, then eights, then fours, then twos, and then ones.

Twenty-Seven Objects, Broken Into Powers of Two

We counted the powers of two and wrote them under each label, coming up with the numeral “11011”: one sixteen, one eight, zero fours, one two, and one one.

Number of Digits

When I was done with the tape flag examples, I took a moment to explain that base ten has ten digits, base five has five digits, and base two has two digits. As an example, I said that in base ten you could never have a 10 in any place, because that would be the same as a 1 in the next higher place. Similarly for base two, a 2 in a place would equal the next higher power of two, which also would be the same as a 1 in the next higher place.

Other Bases

I told the class that you could write any whole number in any base. One kid asked if I could do it in a base that was greater than ten (I forget which base he used as an example). I said any number could be the base, but you’d have to have enough symbols. I briefly explained why you wouldn’t want a multi-digit number in a place (it would make the numeral ambiguous). I mentioned base sixteen, and said it uses the letters A through F for the values ten through fifteen. (I did not intend to get into hexadecimal, but hey, I wanted to answer the question!)

Students as Binary Numbers

At the front of the classroom, just below the whiteboard, I arranged five chairs, facing the class. I wrote the names of the binary places above the chairs, left to right from the class’s point of view: sixteens, eights, fours, twos, ones. I got five volunteers to come up, and said that I would turn them into a binary number. I said if I told them to sit in their chair, they would count as a 0; if I told them to stand in front of their chair, they would count as a 1.

For my first example, I put the students in the pattern 11011, which the class correctly read as twenty-seven (they added the place values above the chairs of the standing students — that or they read the numerals I had left on the board under the tape flags ). I did a few other examples like this, which amounted to binary to decimal conversion. They got them all right.

Next I did what amounted to decimal to binary conversion, asking the class how to arrange the volunteers to represent a given number. For example, when I said “nine,” they called out instructions to make the volunteers stand and sit to make the pattern 1001. They got all of these examples correct as well.

Binary Counting

The above discussion took about twenty-five minutes, so with the extra five minutes I squeezed in a demonstration of a binary counter. I took a new set of five volunteers and had the class direct them through the sequence zero to thirty-one. We got through the count, but I think a few students got lost as some of the faster adders called out instructions. In any case, there were definitely some who understood the process, enough to know that when I asked them to display thirty-two, they said we would need another volunteer.

If I had more time, I would have done the count a second time, with the volunteers driving the counting; I came up with this scheme after I left the class:

• All volunteers start out sitting, representing zero.
• Whenever I say “count”
  • The ones place volunteer does the opposite of what she is currently doing: if she’s sitting, she stands; if she’s standing, she sits.
  • For everyone not in the ones place, if the kid to your left sits, you do the opposite of what you’re currently doing.

I think this would have made the counting easier and more fun.

Binary Fractions

I mentioned briefly that there is an equivalent of decimals in binary numbers. Instead of the tenths, hundredths, etc. places there are the halves, quarters, eighths, etc. places.

Discussion

I think most of the kids understood the presentation; certainly, they were all engaged. I’d like to think it gave them a better understanding of decimal, even if they didn’t understand the details of binary. I told them “you may not understand this now, but when you see it again someday, you’ll remember back to this day in third grade and it will come to you.” Someone then asked what grade they teach this in. I said it’s not really part of any particular math class (as far as I know) but that they would be taught it in a high-school computer class if they took one.

I used number words when I wanted to avoid decimal numerals; for example, when describing a number or when labeling places. Unfortunately, number words have decimal place value built-in, but that’s the closest I know how to get to a base-independent description of a number. That said, I don’t think the class recognized this, so I don’t think it caused any confusion.

I didn’t explain why we broke the numbers down by starting with the largest powers and working down. If I had more time, maybe I would have let them discover the algorithm themselves.

I use the term “number” when I really mean “numeral”, as in “binary number” or “decimal number.” This terminology is unfortunate, but it is standard.

References

• Rick Garlikov’s use of the Socratic method to teach binary numbers to third graders.

  I used a different approach, but a lot of the same concepts are involved. Rick’s method centered on binary counting, which lead to a discussion of powers and places. My method started with powers and places, and lead to binary numerals and then binary counting. Rick discussed other bases after discussing binary, whereas I discussed them before. Also, he discussed binary arithmetic, but I did not.

  One thing I liked about my approach is that I built in the concept of base conversion, showing the equivalence of whole numbers written in any base. I also liked the way I exhibited the concept of “number vs. numeration.”

• Computer Science Unplugged Page on Binary Numbers.

  This page contains videos on binary counting, which inspired my own binary counting demonstration.

• My article “How I Taught My Mother Binary Numbers.”

  I taught my mother a little differently (at least in my second attempt), mainly because I think most adults don’t think explicitly about place value.

Please Try This

I’d love to know if this method works for you; if you try it, please let me know!

By Rick Regan (Copyright © 2008-2012 Exploring Binary)

How I Taught Third Graders Binary Numbers

I started my search with my program that finds multiple-base palindromes. I generated palindromes in binary, and then checked them to see if they were also palindromes in hexadecimal and decimal. I looked for decimal/binary/hexadecimal palindromes up to 16 hex digits long, but did not find any.

To continue my search into bigger numbers, I wrote a program that uses arbitrary-precision integer arithmetic and a more efficient algorithm. Despite being able to search much further, I still have not found any.

In this article, I’ll analyze the size of the palindrome “search space”, explain my improved algorithm, and discuss the state of my search.

Search Space for Decimal/Binary/Hexadecimal Palindromes

The biggest obstacle in the search for palindromes is the growth in the amount of numbers that must be checked — the search space. As the number of digits increases, the search space grows exponentially. While this exponential growth can’t be eliminated, it can be delayed — by pruning the search space.

Consider the search space for 32 hexadecimal digit decimal/binary/hexadecimal palindromes. With no pruning, 15·16³¹ integers would have to be checked — 319,014,718,988,379,809,496,913,694,467,282,698,240 numbers, an impossible task. If only hexadecimal palindromes are considered, the search space is reduced to 15·16¹⁵ = 17,293,822,569,102,704,640 numbers — much smaller but still intractable. If only binary/hexadecimal palindromes are considered, then there are 2¹⁶ + 2³² = 4,295,032,832 numbers to be checked — quite manageable!

The binary/hexadecimal palindrome space can be partitioned by starting digit so that subsets can be searched independently. Consider the 32 hexadecimal digit binary/hexadecimal palindromes. There are 2¹⁶ = 65,536 that begin with the digits 1 and 3, and 2³² = 4,294,967,296 that begin with the digits 5, 7, 9, and F. The number of palindromes that start with 1 and 3 is markedly lower, allowing for a deeper search within them.

The following diagrams illustrate how the search space grows, showing the search spaces for the 16, 32, and 64 digit hexadecimal palindromes:

Number of 16-Digit Hexadecimal Palindromes, by Subset (not to scale)

Number of 32-Digit Hexadecimal Palindromes, by Subset (not to scale)

Number of 64-Digit Hexadecimal Palindromes, by Subset (not to scale)

Program to Find Decimal/Binary/Hexadecimal Palindromes

I wrote a C program to search for decimal/binary/hexadecimal palindromes — it is based on two things:

• Arbitrary-precision integers.

  This allows for palindrome numbers that are too big to fit in an unsigned long long integer variable; that is, numbers bigger than 64 bits, or 16 hex digits. I used GMP in Visual C++ on Windows.

• Direct generation of binary/hexadecimal palindromes.

  This reduces the search space dramatically, so that only known binary/hexadecimal palindromes are checked — for being palindromic in decimal. I used a simple algorithm derived from my analysis of binary/hexadecimal palindromes.

I will outline the algorithm instead of providing the source code.

The Algorithm

Binary/hexadecimal palindromes could be generated in two ways. One way would be incrementally, by generating the two-digit palindromes, then the three-digit palindromes, then the four-digit palindromes, etc. A set of m-digit palindromes would be built from a set of m-1 digit palindromes, by inserting a digit in the middle of each m-1 digit palindrome. This requires storage of palindromes, which will not scale — the number of palindromes grows exponentially.

Another way to generate binary/hexadecimal palindromes — the way I chose — is to construct them from permutations of hex digits. Each of the six subsets of binary/hexadecimal palindromes has its own rules for valid digits:

• Starts/ends with 1: each digit between can be 0 or 1
• Starts/ends with 3: each digit between can be 0 or 3
• Starts/ends with 5: each digit between can be 0, 2, 5, or 7
• Starts/ends with 7: each digit between can be 0, 2, 5, or 7
• Starts/ends with 9: each digit between can be 0, 6, 9, or F
• Starts/ends with F: each digit between can be 0, 6, 9, or F

You construct palindromes of n digits from permutations of floor(n/2) digits. For example, to generate a 32 digit palindrome that starts with 5, create a number that starts with 5 followed by a 15 digit permutation of the digits 0, 2, 5, and 7. Then, reverse that number and append it to itself to create a 32 digit palindrome. (The process for odd length palindromes is similar, except you insert an extra middle digit between the two halves.)

Permutations are easily generated, with a series of nested loops. You can nest loops statically, by coding a loop for each place of the permutation, or you can nest them dynamically, by calling a single loop recursively. The advantage of dynamic nesting is not having to add loops manually for increasing digit lengths; the advantage of static nesting is the ability to “checkpoint” the state of the search easily — an important feature for long running programs. I chose static nesting for that reason.

Results

I’ve searched the “1/3 space” through all 64 hex digit numbers, and the “5/7/9/F space” through all 32 hex digit numbers. I have not found a single multi-digit decimal/binary/hexadecimal palindrome.

I have suspended my search, since the running time of my program is starting to explode. For example, it took almost 60 hours on my Intel Core Duo processor to test all 2³² 64 hex digit binary/hexadecimal palindromes in the 1/3 space. Resuming the search would probably require a GIMPS-like distributive computing approach, which I have no plans to undertake.

Discussion

Are there any tricks to reduce the search space further, delaying the inevitable exponential explosion even more? Charlton’s binary/decimal palindrome search algorithm eliminates swaths of numbers as it runs, recognizing conditions under which copalindromic numbers can’t exist. Can similar ideas be applied to the search for decimal/binary/hexadecimal palindromes?

Another Way to Count Binary/Hexadecimal Palindromes

In my article “Counting Binary/Hexadecimal Palindromes” I derived formulas to count binary/hexadecimal palindromes using geometric series. An alternate way would be based on counting permutations. For example, the number of 32 digit palindromes starting with 5 is the number of 15 digit permutations of the digits 0, 2, 5, and 7; that is, 4¹⁵ = 2³⁰ = 1,073,741,824.

(You would still need geometric series to count the number of palindromes of n-digits or less.)

Are There Any?

Are there any decimal/binary/hexadecimal palindromes? Can it be proved either way?

I have no reason to believe they don’t exist. After all, there are at least two multi-digit decimal/binary/octal palindromes. And it’s always possible I made an error in my search, although Charlton’s results confirm my results through 32 hex digits plus.

By Rick Regan (Copyright © 2008-2012 Exploring Binary)

In Search of Decimal/Binary/Hexadecimal Palindromes

In this article, I will derive similar formulas to count binary/hexadecimal palindromes — multi-base palindromes I’ve shown to have an algorithmically defined structure.

Binary/Hexadecimal Palindromes of n Hexadecimal Digits

To derive the formula to count binary/hexadecimal palindromes, look at the tables in my article “The Structure of Binary/Hexadecimal Palindromes”. There’s a table of palindromes for each starting hexadecimal digit: 1, 3, 5, 7, 9, and F. Each table lists the binary/hexadecimal palindromes of one to five hex digits, for each starting digit. If you count the palindromes in the tables — and continue the pattern beyond five digits — this is what you’ll get:

This pattern continues forever, based on the structure of the palindromes.

(Notice we’re not counting 0 as a palindrome — if you want to, add 1 to the formulas we derive below.)

There are two different count sequences: one of interleaved nonnegative powers of two, and one of interleaved nonnegative powers of four. As we learned when counting n-digit binary palindromes, the sequence of interleaved nonnegative powers of two is captured by these two formulas:

• When n is even: 2^n/2-1
• When n is odd: 2^(n+1)/2-1

Those two formulas apply to the starting hex digits 1 and 3, counting the number of n hex digit binary/hexadecimal palindromes for each.

You can use similar formulas to generate the sequence of interleaved nonnegative powers of four:

• When n is even: 4^n/2-1 = 2^2·(n/2-1) = 2^n-2
• When n is odd: 4^(n+1)/2-1 = 2^{2·((n+1)/2-1)} = 2^n-1

(It should not be surprising that these expressions simplify to powers of two — powers of four are powers of two.)

Those two formulas apply to the starting hex digits 5, 7, 9, and F, counting the number of n hex digit binary/hexadecimal palindromes for each.

Combining the Formulas

The formulas above count the number of n hex digit binary/hexadecimal palindromes by starting hex digit. We can combine them into one pair of formulas that counts all n hex digit binary/hexadecimal palindromes, by adding two copies of the first pair of formulas to four copies of the second pair:

• When n is even: 2·2^n/2-1 + 4·2^n-2 = 2^n/2 + 2ⁿ
• When n is odd: 2·2^(n+1)/2-1 + 4·2^n-1 = 2^(n+1)/2 + 2ⁿ⁺¹

Binary/Hexadecimal Palindromes of n Hexadecimal Digits or Less

To compute the total number of binary/hexadecimal palindromes of n hex digits or less, we need to add together the count of palindromes for each number of digits, 1 through n. We could create a series using the pair of formulas above, but it’s easier to start from scratch: we’ll create a series for each starting digit, and then add them together.

The count of palindromes for each starting digit, from 1 to n digits, is an interleaved sequence — either of nonnegative powers of two or nonnegative powers of four. If you separate those sequences and add their terms — creating series — you’ll have these building blocks, which I’ll use to derive a formula:

• The sum of the first m nonnegative powers of two: = 2^m – 1 .
• The sum of the first m nonnegative powers of four: = (4^m – 1)/3 .

We can use these expressions for each of the interleaved series, adding them together to get expressions that count palindromes of n digits or less by starting digit. We can then combine those expressions to get one pair of formulas — one that counts all palindromes of n digits or less.

Total Palindromes for Each of the Starting Digits 1 and 3

• The number of digits n is even

  The sum consists of two identical series of n/2 terms each:

  = 2^n/2 – 1.

  Added together, they are 2(2^n/2 – 1).

• The number of digits n is odd

  The sum consists of two identical series of (n-1)/2 terms each, plus an extra term. Each series looks like this:

  = 2^(n-1)/2 – 1.

  Added together, they are 2·(2^(n-1)/2 – 1).

  The extra term is 2^(n-1)/2, what would have been the next term in one of the series. Adding this to the two series we get 2(2^(n-1)/2 – 1) + 2^(n-1)/2, which simplifies to 3·2^(n-1)/2 – 2.

Total Palindromes for Each of the Starting Digits 5, 7, 9, and F

• The number of digits n is even

  The sum consists of two identical series of n/2 terms each:

  = (4^n/2 – 1)/3.

  Added together, they are 2·(4^n/2 – 1)/3.

• The number of digits n is odd

  The sum consists of two identical series of (n-1)/2 terms each, plus an extra term. Each series looks like this:

  = (4^(n-1)/2 – 1)/3.

  Added together, they are 2·(4^(n-1)/2 – 1)/3.

  The extra term is 4^(n-1)/2, what would have been the next term in one of the series. Adding this to the two series we get 2(4^(n-1)/2 – 1)/3 + 4^(n-1)/2, which simplifies to (5·4^(n-1)/2 – 2)/3.

Total Palindromes for All Digits

To get the total palindromes of n digits or less, we add two copies of the “1/3” pair of formulas to four copies of the “5/7/9/F” pair of formulas:

• The number of digits n is even

  2(2(2^n/2 – 1)) + 4(2(4^n/2 – 1)/3) = 4(2^n/2 – 1) + 8(2ⁿ – 1)/3

• The number of digits n is odd

  2(3·2^(n-1)/2 – 2) + 4((5·4^(n-1)/2 – 2)/3) = 2(3·2^(n-1)/2 – 2) + 4(5·2^n-1 – 2)/3

Summary

Here is a summary of the binary/hexadecimal palindrome counting formulas:

Here’s a table listing the values of these formulas for n = 1 to 16:

By Rick Regan (Copyright © 2008-2012 Exploring Binary)

Counting Binary/Hexadecimal Palindromes

Certainly they’re made up of the hexadecimal digits that are themselves palindromic in binary: 0, 6, 9, F; for example, F060F₁₆ = 11110000011000001111₂ and 9F9₁₆ = 100111111001₂. Each of these four hexadecimal digits maps neatly to a 4-digit binary palindrome, so any hexadecimal palindrome made from them is automatically palindromic in binary.

But there are other binary/hexadecimal palindromes, like 525₁₆ = 10100100101₂ and 70207₁₆ = 1110000001000000111₂, that contain hexadecimal digits that are not palindromic in binary. In this case, binary palindromes are produced with combinations of hexadecimal digits. It turns out there are a limited number of valid combinations, and that they’re localized — they span only two hexadecimal digits.

In this article, I’ll analyze binary/hexadecimal palindromes and describe their structure — a structure due to the relationship of the two bases, binary and hexadecimal.

Example Binary/Hexadecimal Palindromes

Inferring the Structure of Binary/Hexadecimal Palindromes

Before determining the structure of binary/hexadecimal palindromes analytically, let’s look at more examples. I listed the first 124 (nonzero) binary/hexadecimal palindromes — that is, those palindromes consisting of five hexadecimal digits or less — using my C program that finds multi-base palindromes. I noticed that each palindrome starts (and thus ends) with one of six hexadecimal digits: 1, 3, 5, 7, 9, F. I also noticed that, depending on the starting digit, only certain middle digits appear:

• Palindromes starting with 1: only 0 and 1 appear as middle digits.
• Palindromes starting with 3: only 0 and 3 appear as middle digits.
• Palindromes starting with 5 or 7: only 0, 2, 5, and 7 appear as middle digits.
• Palindromes starting with 9 or F: only 0, 6, 9, and F appear as middle digits.

Within each of the four groups of palindromes, the middle digits alternate in each digit position, in the order listed above.

Here is the output of my program, segmented by starting digit (the highlighted digits in the hexadecimal palindromes are the digits “inserted” into them to take them from n digits to n+1 digits):

Palindromes starting with hex ‘1’:

Palindromes starting with ‘3’:

Palindromes starting with hex ‘5’:

Palindromes starting with hex ‘7’:

Palindromes starting with hex ‘9’:

Palindromes starting with hex ‘F’:

You can see that binary palindromes starting with hex digits 1, 3, 5, and 7 are not multiples of four bits. This is because leading zeros do not count. Each of those four hex digits — when used as a starting digit — requires less than four bits. In this case, it’s important to remember that hex digits are formed in groups of four bits, from right to left.

Starting Digits

We’ve seen empirically that a nonzero binary/hexadecimal palindrome starts with the hexadecimal digit 1, 3, 5, 7, 9, or F — now it’s time to prove it.

First, observe that the starting hex digit must be odd: an even hex digit ends with a 0 when written in binary, and palindromes can’t start with 0. This leaves eight starting digits as candidates: 1, 3, 5, 7, 9, B, D, F.

Let’s classify our palindromes into two categories: single hex digit and multiple hex digit. A single hex digit palindrome is a single hex digit that is palindromic in binary: 1, 3, 5, 7, 9, and F are the only choices (1₁₆ = 1₂, 3₁₆ = 11₂, 5₁₆ = 101₂, 7₁₆ = 111₂, 9₁₆ = 1001₂, F₁₆ = 1111₂). A multiple hex digit palindrome as a whole is palindromic in binary, but individually, each hex digit may not be — and in fact, will not be — palindromic in binary.

Let’s analyze multiple hex digit palindromes by classifying them into two categories, depending on whether their ending hex digit has a binary equivalent that starts with a 1 or 0:

• Binary equivalent starts with 1.

  The hexadecimal palindrome will have an associated binary palindrome that is a multiple of four bits. This means that each hex digit must stand alone as a binary palindrome: 9 and F are the only choices for the starting digit. There are two 2-digit palindromes that start with 9 and F: 99₁₆ = 10011001₂ and FF₁₆ = 11111111₂; these will serve as “bookends” for all palindromes of 3 digits or more.

• Binary equivalent starts with 0.

  The hexadecimal palindrome will have an associated binary palindrome that is not a multiple of four bits. This means that each hex digit does not stand alone as a binary palindrome.

  The best way to show which starting digits are allowed in this case is to try all four candidates as 2-digit palindromes: 11₁₆ = 10001₂, 33₁₆ = 110011₂, 55₁₆ = 1010101₂, and 77₁₆ = 1110111₂. All are binary palindromes, so 1, 3, 5, 7 are the valid starting digits.

Middle Digits

We’ve seen empirically what the middle digits of multiple digit binary/hexadecimal palindromes are, and that they follow a pattern — now I’ll show why.

Definition. I’ll say a number is a leading-zero palindrome or is leading-zero palindromic if it is palindromic with zero or more leading zeros.

Middle Digits for Starting Digits 9, F

Palindromes starting with 9 or F are straightforward to analyze, so I’ll start with them. Each middle hex digit must stand alone as a leading-zero binary palindrome, so 0, 6, 9, and F are the choices.

The structure of these palindromes is easy to describe. The n+1 hex digit palindromes can be created from the n hex digit palindromes by inserting the digits 0, 6, 9, or F. When n is odd, one n+1 digit palindrome is spawned from each n digit palindrome, by replicating the middle hex digit (which will be 0, 6, 9 or F). When n is even, four n+1 digit palindromes are spawned from each n digit palindrome, by inserting the digits 0, 6, 9, and F in turn.

Middle Digits for Starting Digits 1, 3, 5, 7

The analysis of palindromes starting with 1, 3, 5, or 7 is based on the number of leading zeros in the binary representation of the ending hex digit; let’s define the three cases:

• 1 leading zero: 5 (0101) and 7 (0111).
• 2 leading zeros: 3 (0011).
• 3 leading zeros: 1 (0001).

Recall how palindrome generation works: each inserted hex digit takes an n digit palindrome and turns it into an n+1 digit palindrome. To ensure the result remains a binary palindrome, the inserted hex digit must maintain a binary palindrome around the “center”. Here’s how it’s done:

• The binary representation of the inserted hex digit must have the same number of leading zeros as the binary representation of the hex digit to its right.
• The binary representation of the inserted hex digit must be palindromic without the leading zeros.

In other words, the inserted leading zeros mirror the existing leading zeros, and the rest of the hex digit — which is between the sets of zeros — stands alone as a binary palindrome.

(There’s an alternate way to think of this: the inserted hex digit, with the one, two, or three leading binary zeros in the hex digit to its right, is a leading zero palindrome. The left side of this palindrome replaces the leading zeros used from the right.)

So what are the allowable middle digits? Hex digits 0-7 are the candidates, since they’re the only 4-bit hex digits that have leading zeros in their binary representations. But after you strip away the required number of leading zeros, only 0, 1, 2, 3, 5, and 7 stand alone as binary palindromes:

• 1 leading zero: 0 (000), 2 (010), 5 (101), 7 (111).
• 2 leading zeros: 0 (00) or 3 (11).
• 3 leading zeros: 0 (0) or 1 (1).

The insertion of middle digits can continue indefinitely, since the number of binary leading zeros in each group is the same for each digit. Any middle digit in each group can be adjacent to any other. The number of leading zeros in the ending digit is the number of leading zeros maintained throughout.

Example

This diagram shows an example of binary/hexadecimal palindrome generation:

Example Binary/Hexadecimal Palindrome Generation

Summary

In summary, the (nonzero) binary/hexadecimal palindromes are

• The single digit hexadecimal palindromes 1, 3, 5, 7, 9, and F.
• All hexadecimal palindromes that start and end with 1 and have only 0s and 1s between.
• All hexadecimal palindromes that start and end with 3 and have only 0s and 3s between.
• All hexadecimal palindromes that start and end with 5 or 7 and have only 0s, 2s, 5s, and 7s between.
• All hexadecimal palindromes that start and end with 9 or F and have only 0s, 6s, 9s, and Fs between.

(And now that we know their structure we can count them — see my article “Counting Binary/Hexadecimal Palindromes”.)

By Rick Regan (Copyright © 2008-2012 Exploring Binary)

The Structure of Binary/Hexadecimal Palindromes

• When n is even: 9·10^n/2-1
• When n is odd: 9·10^(n+1)/2-1

How many nonzero, decimal number palindromes are there, consisting of n-digits or less? These two formulas give the answer:

• When n is even: 2(10^n/2 – 1)
• When n is odd: 11·10^(n-1)/2 – 2

So for example, there are 900 5-digit decimal palindromes, 9,000 8-digit decimal palindromes, 1,098 decimal palindromes of 5 digits or less, and 19,998 decimal palindromes of 8 digits or less.

In this article, I will derive similar formulas to count binary and hexadecimal number palindromes.

Binary Palindromes

Number palindromes have a simple structure: n-digit palindromes are related to n-1 digit palindromes. You can think of generating palindromes as an iterative process, where you start with single-digit palindromes and work your way through palindromes of an increasing number of digits. Here’s an example of the process, using binary numbers:

1. From the only (nonzero) one-digit palindrome, 1, make the two-digit palindrome 11.
2. From 11, make the two three-digit palindromes 101 and 111.
3. From 101, make 1001; from 111, make 1111.
4. From 1001, make 10001 and 10101; from 1111, make 11011 and 11111.
5. From 10001, make 100001; from 10101, make 101101; from 11011, make 110011; from 11111 make 111111.
6. …

From each odd-length palindrome, you can generate one even-length palindrome; you have to replicate the middle digit in order to keep it palindromic. From each even-length palindrome, you can generate two odd-length palindromes, by inserting a 0 or 1 in the middle.

This table illustrates the structure better — it shows all 1 through 8 digit binary palindromes:

Counting Binary Palindromes

As typical with things binary, there is a pattern in the palindromes involving powers of two. In this case, it’s easy to see why: each set of odd-length palindromes is double the size of the preceding set of even-length palindromes, and each set of even-length palindromes is the same size as the preceding set of odd-length palindromes. These two formulas capture this relationship, giving the number of n-digit binary palindromes:

• When n is even: 2^n/2-1
• When n is odd: 2^(n+1)/2-1

For n = 1 to 8, you can verify these formulas match the counts in the table: 1, 1, 2, 2, 4, 4, 8, 8.

(The formula can be stated in one expression as , which is the base 2 version of , the formula stated here. I rewrote it into two parts to remove the slightly cumbersome “floor” function, and to be consistent with the formulas below.)

Number of Binary Palindromes of n Digits or Less

You can further derive a formula for the total number of palindromes of n digits or less, by adding the terms 1, 1, 2, 2, 4, 4, 8, 8, … . Recognizing this sequence as two interleaved sequences of 1, 2, 4, 8, … — that is, sequences of nonnegative powers of two — the derivation of the formula is straightforward.

Here’s the formula to express the sum of the first m nonnegative powers of two:

= 2^m – 1

We can use this expression for each of the interleaved series, and then add them together. There are two cases:

• The number of digits n is even

  The sum consists of two identical series of n/2 terms each:

  = 2^n/2 – 1.

  Added together, they are 2(2^n/2 – 1).

• The number of digits n is odd

  The sum consists of two identical series of (n-1)/2 terms each, plus an extra term. Each series looks like this:

  = 2^(n-1)/2 – 1.

  Added together, they are 2(2^(n-1)/2 – 1).

  The extra term is 2^(n-1)/2, what would have been the next term in one of the series. Adding this to the two series we get 2(2^(n-1)/2 – 1) + 2^(n-1)/2, which simplifies to 3·2^(n-1)/2 – 2.

For n = 1 to 8, you can verify these formulas match the total counts in the table: 1, 2, 4, 6, 10, 14, 22, 30.

Hexadecimal Palindromes

Using a similar analysis, here are the two formulas to count n-digit hexadecimal palindromes:

• When n is even: 15·16^n/2-1
• When n is odd: 15·16^(n+1)/2-1

For n = 1 to 8, the value of these formulas is 15, 15, 240, 240, 3840, 3840, 61440, 61440.

(The formula can also be stated in one expression as .)

To count the number of hexadecimal palindromes of n digits or less, we can add series just as we did for binary palindromes. If you factor out 15 from each term in the sequence above, you’re left with this sequence: 1, 1, 16, 16, 256, 256, 4096, 4096. Those are interleaved sequences of nonnegative powers of sixteen.

Here’s the formula to express the sum of the first m nonnegative powers of sixteen:

= (16^m – 1)/15

We can use this expression for each of the interleaved sequences, and then add them together. There are two cases:

• The number of digits n is even

  The sum consists of two identical series of n/2 terms each:

  = 16^n/2 – 1.

  Added together, they are 2(16^n/2 – 1).

• The number of digits n is odd

  The sum consists of two identical series of (n-1)/2 terms each, plus an extra term. Each series looks like this:

  = 16^(n-1)/2 – 1.

  Added together, they are 2(16^(n-1)/2 – 1).

  The extra term is 15·16^(n-1)/2, what would have been the next term in one of the series. Adding this to the two series we get 2(16^(n-1)/2 – 1) + 15·16^(n-1)/2, which simplifies to 17·16^(n-1)/2 – 2.

For n = 1 to 8, these formulas return these values: 15, 30, 270, 510, 4350, 8190, 69630, 131070.

Trying These Formulas in PARI/GP

In this section, I’ll demonstrate the formulas for counting binary palindromes, using PARI/GP.

Print the number of 1-digit to 20-digit binary palindromes, using the “floor” form of the expression:

? for (i=1,20,print(2^(floor((i-1)/2))))
1
1
2
2
4
4
8
8
16
16
32
32
64
64
128
128
256
256
512
512

Print the number of 1-digit to 20-digit binary palindromes, using the even and odd case palindrome counting expressions:

? for(i=1,20,if(i%2==1,print(2^((i+1)/2-1)),print(2^(i/2-1))))
1
1
2
2
4
4
8
8
16
16
32
32
64
64
128
128
256
256
512
512

Print the total number of binary palindromes of n digits or less, for n = 1 to 20:

? for(i=1,20,if(i%2==1,print(3*2^((i-1)/2)-2),print(2*(2^(i/2)-1))))
1
2
4
6
10
14
22
30
46
62
94
126
190
254
382
510
766
1022
1534
2046

Summary

Here is a summary of the binary palindrome counting formulas:

Here is a summary of the hexadecimal palindrome counting formulas:

Discussion

These formulas can be extended to any base, like octal. (You can see the pattern they follow, although that in itself is not a proof they hold for all bases.)

In my article “Finding Numbers That Are Palindromic In Multiple Bases” I showed how to generate palindromes by iterating through a counter. The analysis of palindromes in this article suggests another algorithm: generating n-digit palindromes from n-1 digit palindromes. (It’s probably not a better way though, at least not for large n, because the required storage space grows exponentially.)

What About Zero?

The number 0 is defined to be a palindrome, although you could make an argument against it. No palindrome can start with zero, yet 0 is a palindrome. In any case, it is not counted in the formulas above, simply because it makes the derivations easier. To count zero, add one to each formula.

By Rick Regan (Copyright © 2008-2012 Exploring Binary)

Counting Binary and Hexadecimal Palindromes

Here they are in dd/mm/yy format:

2011

The same days also look like binary in 2011:

Here they are in dd/mm/yy format:

And in case you were wondering, 2010 = 11111011010 in binary, and 2011 = 11111011011 in binary.

(If this blog existed in 2000 — if blogs existed in 2000 period — I would have made tables for the years 2000 and 2001 as well.)

Palindromes

Considering dates as numbers leads you to wonder which are number palindromes. Numbers written with leading zeros are not palindromes, so numbers ending with zeros are not palindromes either. This means no dates in 2010 are palindromic. In 2011 however, there are palindromic dates. There are several consisting of all 1s, like 1/1/11, but those are not interesting. That leaves two palindromic dates made up of both 0s and 1s:

• January 10th, 2011, in mm/dd/yy format: 1/10/11.
• October 1st, 2011, in dd/mm/yy format: 1/10/11.

Both are the same binary number: 11011 (27 decimal).

Binary Times

People have also been tweeting about binary times. There are binary times every day, but they’ll seem more significant on binary days. There are 12, not including seconds and duplicates for AM/PM: 1:00, 1:01, 1:10, 1:11, 10:00, 10:01, 10:10, 10:11, 11:00, 11:01, 11:10, 11:11. (I’ll leave it as an exercise to compute these as decimal values.)

Now having thrown time into the mix, we can consider some new palindromes. For example, 1/1/10 (mm/dd/yy) at 1:11 AM is 1110111.

By Rick Regan (Copyright © 2008-2012 Exploring Binary)

Binary Dates in 2010 and 2011

In “Nines in Binary”, I derived an expression for 10ⁿ – 1 that shows its structure as a binary number:

10ⁿ – 1 = (5ⁿ – 1) 2ⁿ + (2ⁿ – 1)

Pat derived a similar expression for 10ⁿ – 1 that shows its structure as a quinary number:

10ⁿ – 1 = (2ⁿ – 1) 5ⁿ + (5ⁿ – 1)

In essence, he swapped the 2s and 5s, making it the “dual” of my formula, if you will.

I’ll show the details of the derivation and prove why the formula works.

Deriving the Expression

To derive the formula for the “binary expression” of 10ⁿ – 1, I worked backwards from the patterns I saw in its binary representation:

(5ⁿ – 1) 2ⁿ + (2ⁿ – 1) = 5ⁿ2ⁿ – 2ⁿ + 2ⁿ – 1 = 10ⁿ – 1

Pat derived the formula for the “quinary expression” of 10ⁿ – 1 without having to look at its representation in quinary — he simply modified the algebra that I presented. He observed that - 2ⁿ + 2ⁿ could be replaced with - 5ⁿ + 5ⁿ, since both equal 0. This allowed him to rearrange the expression as follows:

10ⁿ – 1 = 2ⁿ5ⁿ – 5ⁿ + 5ⁿ – 1 = (2ⁿ – 1) 5ⁿ + (5ⁿ – 1)

What the Expression Shows

The quinary expression has a leading part, 2ⁿ – 1 shifted left n places in base 5, and a trailing part, 5ⁿ – 1. The trailing part shows that there are at least n trailing 4s, since 5ⁿ – 1 is n 4s in quinary (like 2ⁿ – 1 is n 1s in binary, 10ⁿ – 1 is n 9s in decimal, etc.). The leading part shows that there are exactly n trailing 4s, since 2ⁿ – 1 does not end with the digit 4 in quinary. Let’s see why.

To show that 2ⁿ – 1, when expressed in base 5, does not end in 4, we can use modular arithmetic. Let’s start by analyzing the possible ending digits of the positive powers of two:

• 
• 
• 
• 
• 
• …

This shows the numbers 2ⁿ (n ≥ 1) mod 5 cycle through the ending digits 2, 4, 3, and 1. This means that the numbers 2ⁿ – 1 cycle through the ending digits 1, 3, 2, and 0. The digit 4 is not on the list!

Nonnegative Powers of Ten in Quinary

In my article “A Pattern in Powers of Ten and Their Binary Equivalents”, I showed that the trailing digits of nonnegative powers of ten, in binary, match the power of ten; in other words, a 1 is followed by n trailing 0s. For example, 100₁₀ = 1100100₂.

A similar, though slightly weaker property, holds for nonnegative powers of ten in quinary: 10ⁿ ends with n 0s. A nonnegative power of ten is a multiple of a power of two and a power of five: 10ⁿ = 2ⁿ * 5ⁿ. A power of two in base 5 ends in 1, 2, 3, or 4 — never 0 — as I showed above. When you multiply a power of two by a power of five, you shift the power of two left by n places in base 5, which adds n trailing 0s. So the quinary representation ends with a nonzero digit followed by n 0s — exactly n trailing 0s!

By Rick Regan (Copyright © 2008-2012 Exploring Binary)

Nines in Quinary

A number can be palindromic in any base, not just decimal. For example, 101101 is a palindrome in binary. A number can also be palindromic in more than one base, like decimal 719848917, which is 101010111010000000010111010101 in binary and 5272002725 in octal.

An efficient way to find palindromes in a single base is to generate them, iterating through each integer and constructing palindromes from them. An efficient way to find numbers that are palindromic in multiple bases is to take a palindrome in one base and test if it’s a palindrome in one or more additional bases.

In this article, I’ll show you C code I wrote that finds multi-base numeric palindromes. I used this code to generate tables of numbers that are palindromic in decimal and binary, decimal and hexadecimal, and decimal and octal. I also used this code to solve Euler problem 36, which asks for the sum of all numbers, less than one million, that are palindromic in decimal and binary.

Checking Whether a Number is a Palindrome

In general, a palindrome can be any string of characters; for example, “j4$4j”, “radar”, and “9009”. The algorithm to check whether a string is palindromic is simple: just reverse the string and compare it to itself.

If you’re interested only in number palindromes, you can use a more efficient, numeric algorithm instead of a string-based one. Here’s how it works:

1. Convert the integer to be checked from a string to numeric binary; for example, using strtol(), scanf(), or simply, a compiler constant.
2. Isolate the digits of the numeric binary value by repeatedly dividing it by the number’s base.
3. Construct, from the isolated digits, a new numeric binary integer that represents the original number written in reverse.
4. Compare the original number to the reversed number — if they are equal, the number is a palindrome.

Here is a C function that implements steps 2 through 4 (step 1, the conversion of the string to numeric binary, is done outside this function, if necessary) — it is my implementation of an algorithm that appears several places on the Web (for example, at stackoverflow.com):

int isPalindrome(unsigned long long number, unsigned char base)
{
 unsigned long long forward = number;
 unsigned long long reversed = 0;
 unsigned char digit;

 while (number > 0)
 {
  digit = number % base;
  reversed = reversed * base + digit;
  number = number / base;
 }
 return (forward == reversed);
}

This function combines two base conversion algorithms: the numeric binary integer to string algorithm and the string to numeric binary integer algorithm. The “numeric to string” algorithm isolates digits of a binary integer and appends them to a string, from least to most significant digit. The “string to numeric” algorithm isolates digits of a string and sums their place values in a binary integer, from most to least significant digit. If you fuse the two together, pipelining the digits from the “numeric to string” algorithm to the “string to numeric” algorithm, you reverse the original number — without requiring an intermediate string!

Single-digit numbers, including 0, are trivially palindromic, so this function will classify them as such.

Generating Number Palindromes

For any positive integer in base b, b+1 palindromes can be made from it. For example, the following 11 decimal palindromes can be made from the number 1: 11, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191. There is one even length palindrome, and b odd length palindromes — one per base b digit.

Decimal Palindromes Generated from the Number 1

Here is a C function that generates palindromes in this manner:

void makePalindromes(
       unsigned long long number,
       unsigned char base,
       unsigned long long* palindromes)
{
 /* Returns an array of size base+1 palindrome numbers (one even
    length palindrome followed by 'base' odd length palindromes) */

 unsigned long long upper = number;
 unsigned long long lower = 0;
 unsigned char digit;
 unsigned int i;
 unsigned long long power = 1;

 /* Form upper and lower portions of the new palindromes */
 while (number > 0)
 {
  upper = upper * base;  /* Shift left for each digit */
  digit = number % base;
  lower = lower * base + digit;
  number = number / base;
  power*=base;
 }

 /* Construct the even length palindrome */
 palindromes[0] = upper + lower;

 /* Construct the odd length palindromes */
 palindromes[1] = upper * base + lower; /* Middle digit: 0 */
 for (i=1; i<base; i++)
 {
  palindromes[i+1] = palindromes[1] + i*power;/* Middle digit: i */
 }
}

The core of palindrome creation is the same as palindrome checking: a number must be reversed. However, instead of comparing the reversed number to the original, the reversed number is “concatenated” to the original. Mathematically, the original number is shifted left by a power of the base, becoming the upper portion of the palindrome; the reversed number is then added in to become the lower portion.

This function generates palindromes out of numeric order — odd length palindromes are one digit longer than their corresponding even length ones. And, perhaps not intuitively, it will make single-digit palindromes — all of them — when called with the number 0. This is despite the algorithm’s “upper/lower portion” and “even/odd length” concepts not fitting single-digit numbers — the computations work out regardless. There’s one catch though: 0 is generated twice.

Be aware that, as unsigned long longs, palindromes cannot exceed 2⁶⁴ – 1. This means that the maximum number from which you can make palindromes is less than 2³². How much less depends on the base of the number.

Finding Multi-Base Palindromes

You can combine the functions makePalindromes() and isPalindrome() to make an efficient search for palindromes in multiple bases. This function does so for two bases:

void find_multi_base_palindromes(
       unsigned char base1,
       unsigned char base2,
       unsigned long long max_number,
       unsigned long long* multi_base_palindromes,
       unsigned int* multi_base_count)
{
 unsigned int i;
 unsigned long long counter = 0;
 unsigned long long* base1_palindromes;
 unsigned int max_palindromes = *multi_base_count;

 base1_palindromes = (unsigned long long*)
    malloc((base1+1)*sizeof(unsigned long long));

 *multi_base_count = 0;
 while (1)
 {
  /* Construct palindromes in base1 */
  makePalindromes(counter,base1,base1_palindromes);

  if (base1_palindromes[0] > max_number)
    break; /* Quit when even palindrome exceeds max */

  /* Test if base1 palindromes are also palindromic in base2 */
  for (i=0; i <= base1; i++)
  {
   if (base1_palindromes[i] > max_number)
     break; /* Exit "for" loop if (odd) palindrome exceeds max */

   if (isPalindrome(base1_palindromes[i],base2))
   {
    if (*multi_base_count == max_palindromes)
      assert(0); /* Error: not enough room in array */
    else
    {
     multi_base_palindromes[*multi_base_count] =
       base1_palindromes[i];
     (*multi_base_count)++;
    }
   }
  }
  counter++;
 }
}

This function constructs palindromes repeatedly, from a counter that is incremented after each iteration. Since makePalindromes() generates palindromes out of order, knowing when to stop is a little tricky. The easy stopping case is when an even length palindrome exceeds the requested maximum — no palindromes beyond that can be smaller. The more difficult case is checking the odd length palindromes. Once one of them, from a given set, exceeds the requested maximum, the rest of that set’s palindromes do not have to be checked. However, checking must proceed to the next set of palindromes.

The parameter multi_base_count is input/output. On input, it represents the maximum number of palindromes the output array can hold. On output, it holds the number of palindromes found.

Tables of Multi-Base Palindromes

Using calls to find_multi_base_palindromes(), I created tables of multi-base palindromes in the following combinations:

• Decimal and binary
• Decimal and hexadecimal
• Decimal and octal

I used additional code (not shown) to sort the palindromes, remove the duplicate 0, and print them in various bases.

Each respective table lists all copalindromic numbers less than 10¹². The list of palindromes in each table took 6 seconds or less to find — on an Intel 1.60 GHz, Core Duo T2050 processor running Windows XP.

Palindromes in Decimal and Binary

Here are all 39 decimal/binary palindromes less than 10¹²:

Observe: Palindromes in binary, except 0 itself, cannot end in 0 — leading 0s are not counted as part of a palindrome. This means that all binary palindromes are odd numbers. This also means that any number in a base copalindromic with binary is odd, and thus must start with an odd-valued digit.

I used the following call to generate the decimal/binary table:

 find_multi_base_palindromes
   (2,10,999999999999ULL,palindromes,&count);

Swapping bases 2 and 10 gives the same results, but putting base 2 first makes it run faster. No even palindromes will be generated and thus not needlessly checked!

Palindromes in Decimal and Hexadecimal

Here are all 53 decimal/hexadecimal palindromes less than 10¹²:

Palindromes in Decimal and Octal

Here are all 45 decimal/octal palindromes less than 10¹²:

Palindromes In Decimal and Two Other Bases

I searched for palindromes in the following three-base combinations, using a modifed version of find_multi_base_palindromes() (I added a parameter called base3 and an extra palindrome check):

• Decimal, binary, and hexadecimal
• Decimal, binary, and octal
• Decimal, hexadecimal, and octal

The only combination that produced multi-digit palindromes in three bases was decimal/binary/octal. I found two less than 10¹²:

• 585₁₀ = 1001001001₂ = 1111₈
• 719848917₁₀ = 101010111010000000010111010101₂ = 5272002725₈

In addition, I used this big table of binary/decimal palindromes to determine that

• There are no numbers less than 10³⁹ that are multi-digit copalindromic in decimal, binary and hexadecimal.
• The numbers 585₁₀ and 719848917₁₀ are the only numbers less than 10³⁸ that are multi-digit copalindromic in decimal, binary and octal.

I simply converted each entry in that table to hex and octal — none, besides the two examples above, were palindromes in those bases.

(Update: I’ve written a program capable of searching beyond 2⁶⁴ for decimal/binary/hexadecimal palindromes; none have been found to date.)

Solution to Euler Problem 36

You can use the above functions to solve Euler problem 36. Here’s the code:

void euler36()
{
 unsigned int decimal_binary_count = 50; /* (Room to spare) */
 unsigned long long decimal_binary_palindromes[50];
 unsigned int i;
 unsigned long long sum = 0;

 find_multi_base_palindromes
   (2,10,999999,decimal_binary_palindromes,&decimal_binary_count); 

 for (i=1; i < decimal_binary_count; i++) /* i=1 skips dupe 0 */
   sum+=decimal_binary_palindromes[i];

 printf("The answer to Euler problem 36: %lld\n",sum);
}

(I won’t do all the work for you. You’ll have to at least run this code to get the answer — that or add values manually from the decimal/binary palindrome table above.)

This function runs in well under 1 second.

Application to Other Euler Problems

There are other Euler problems that involve number palindromes: Euler problem 4, Euler problem 55, and Euler problem 125. Some of the above code could be used to solve them.

On Manipulating Other Bases In Binary

The thing I find most interesting about generating and testing palindromes numerically in software is this: conceptually, we’re manipulating numbers in different bases, but in reality, we’re representing them and calculating with them in binary.

By Rick Regan (Copyright © 2008-2012 Exploring Binary)

Finding Numbers That Are Palindromic In Multiple Bases

Binary Integers 0-11111111

A nice pattern, right? I generated it based on the image found on page 117 of Stephen Wolfram’s “A New Kind of Science”. I’ll discuss its structure in detail in this article.

A Visual Table of Binary Integers

If you were to list the first 16 nonnegative binary integers in a table like this,

Binary Integers 0-1111

the 0s and 1s would form a pattern, although it may be hard to see.

If you were to simply color in the 1 cells, the pattern would become much more obvious:

Binary Integers 0-1111

If you were to extend the table, the pattern would become more obvious still. Here it is extended through 11111111, as depicted in the opening of this article:

Binary Integers 0-11111111

Powers of Two Sized Patterns

The overall pattern in the table is based on vertical and horizontal sub patterns. Each sub pattern is based on nonnegative power of two sized units, which is a consequence of individual binary numbers being made up of powers of two.

Vertical Patterns

The basic pattern in the table is vertical, in the columns. Each column alternates between 2ⁿ 0s (blanks are considered 0s) and 2ⁿ 1s, with 2ⁿ being the value of that column’s place. This gives 2ⁿ⁺¹ sized blocks of 0s followed by 1s. For example, the pattern in the ones column is 01; the pattern in the twos column is 0011; the pattern in the fours column is 00001111; etc.

Here are the patterns isolated for the ones through sixteens column:

Patterns in First 5 Columns of Table

These patterns explain the toggle frequency of a binary counter, as discussed in my article What a Binary Counter Looks and Sounds Like.

Horizontal Patterns

The predominant pattern in the table is horizontal, in power of two sized groups of rows. The beauty in this pattern is the nesting. The first two rows start the pattern; the next two rows repeat the first two rows and then prefix them with a 1; the next four rows repeat the prior four rows (with leading 0s filled in first) and then prefix them with a 1; etc.

Here are the patterns isolated for the first five groups of rows:

Patterns in First 32 Rows of Table

In other words, each new group of rows is a copy of all prior rows with a leading 1 attached. Expressed mathematically, the group of rows 2ⁿ to 2ⁿ⁺¹ – 1 is the group of rows 0 to 2ⁿ – 1 with 2ⁿ added to the number in each row.

Horizontal Symmetry

If you fold the table on itself at its halfway point — for the 256 entry table, this is at the border between decimal numbers 127 and 128 — each half will be the negative, or complement, or “dual” of the other. That is, they are the same, except white and black, or 0s and 1s, are interchanged.

Related Binary Art

Ivars Peterson analyzes a piece of artwork by Arlene Stamp called the Binary Frieze. The Binary Frieze incorporates the imagery above, but with two minor differences: black and white are interchanged, and the table is transposed so that numbers are in columns instead of rows:

Binary Frieze Imagery

This image does not appear exactly this way in the Binary Frieze, but is cut up and transformed into a piece of art. Here are three pictures of it: Binary Frieze (Stretch), Binary Frieze (Squeeze), and Binary Frieze (Swing).

As for black and white being interchanged, here’s a different interpretation: perhaps it represents a countdown from 255 to 0.

By Rick Regan (Copyright © 2008-2012 Exploring Binary)

Visualizing Consecutive Binary Integers

There are four columns of 64 entries each, totaling 256 entries.

If you are using these values for storage in a computer word — for example, a byte — be sure to pad with leading 0s, as necessary.

By Rick Regan (Copyright © 2008-2012 Exploring Binary)

Decimal/Binary Conversion Table