Help Needed: Finding the First 10 Apocalyptic Numbers

[Soff]

Hello!

I got a problem:

I want to find out the first ten apocalyptical numbers.By definition, a number of the form 2^n that contains the digits 666 (i.e., the beast number) is called an apocalyptic number.

I tried to write a short program with mathematica:

l := Table[2^n, {n, 1, 1000}]
a := IntegerDigits[l]
Select[a, MatchQ[a, {6, 6, 6}], 10]

However, the result is always {}
What's wrong with the program above?

Can somebody give me an advice?

 

[Crosson]

First a general comment: in this case the use of SetDelayed := will cause reduced performance, because it is unnecessary to recalculate the table each time it is referred to.

Now, notice that the second argument of Select should be a function. If you execute:

MatchQ[a,{6,6,6}]

It returns False, because a (a table of list of digits of integers) does not literally match {6,6,6}. What we really want is a function that compares each element of a with {6,6,6}, which could be given as:

l := Table[2^n, {n, 1, 1000}]
a := IntegerDigits[l]
Select[a, MatchQ[#, {6, 6, 6}]&, 10]

(the # is the formal parameter of the pure function and the & delimits its body).

Now executing the code I gave still returns the empty set, and this is because we are only checking for numbers that match 666, not those of the form:

*digits* 666 *more digits*

To do this in mathematica we use a BlankSequence (two underscores). This works to find your numbers:

l = Table[2^n, {n, 1, 1000}];
a = IntegerDigits[l];
Select[a, MatchQ[#, {__,6, 6, 6,__}]&, 10]

but since we are matching a pattern rather then testing a boolean, it makes more sense to use Cases:

l = Table[2^n, {n, 1, 1000}];
a = IntegerDigits[l];
Take[Cases[a, {__,6, 6, 6,__}], 10]

It might be nice to return the results as integers, rather then lists, and write the program in one line:

FromDigits/@Take[Cases[IntegerDigits@Table[2^n,{n,1,2000}],{__,6,6,6,__}],10]

 

[ravenprp]

Hi there! I can definitely help you with finding the first 10 apocalyptic numbers. First of all, the program you wrote is close, but there are a few things that need to be fixed. Here are some tips:

1. Instead of using the variable "l" to store the list of powers of 2, you can directly use the Table function in your Select statement. So your code will look like this:

Select[Table[2^n, {n, 1, 1000}], MatchQ[IntegerDigits[#], {6, 6, 6}] &, 10]

2. The issue with your code is that you are using the MatchQ function incorrectly. The first argument of MatchQ should be the pattern you are looking for, and the second argument should be the expression you want to match. So in this case, the pattern should be {6, 6, 6} and the expression is the list of digits in each number. Therefore, the correct code is:

Select[Table[2^n, {n, 1, 1000}], MatchQ[{6, 6, 6}, IntegerDigits[#]] &, 10]

3. Lastly, the reason why you are getting an empty list as a result is because there are no numbers between 2^1 and 2^1000 that contain the digits {6, 6, 6}. In fact, the first apocalyptic number is 2^6 = 64. So if you change the range in your Table statement to {n, 1, 10}, you will get the first 10 apocalyptic numbers.

I hope this helps! Let me know if you have any further questions. Good luck with your search!