Take the 2-minute tour ×
Mathematica Stack Exchange is a question and answer site for users of Mathematica. It's 100% free, no registration required.

My code is:

nonine[x_] := If[StringMatchQ[IntegerString[x], "*9*"], False, True];
SetAttribute[nonine, Listable];

tbl = Select[Range[10^2, 888], nonine[#] &];

Total[1.0/tbl]

got out of memory problem.

share|improve this question
2  
Welcome to mma.se by the way! This looks like a project Euler question, is that right? –  Jacob Akkerboom Mar 13 at 10:56
1  
I found it on zhihu, which is a copycat of Quora in China. –  user2218402 Mar 13 at 11:47
    
@ErikE there are more numbers containing 9 than numbers that are free of 9. There only has to be one 9 in the entire number. –  Jacob Akkerboom Mar 14 at 1:35
    
@JacobAkkerboom There is a way to do in microseconds the mere summing of all the numbers: 36 * 11111111 * 9 ^ 7 - 36 * 1111111 * 9 ^ 4. However, I missed that the request was for the sum of 1/x for each number, which is not so simple. My apologies for the mistake. –  ErikE Mar 14 at 15:09
    
@ErikE, no problem, I appreciate the discussion :). If you follow up your comment with more thinking of your own, you are open minded and you are careful to delete any comments that turn out to have little relevance to the Q&A, like you did/have, then by all means post away (I'd say) :). Not saying you should always remove silly comments, but in a nice Q&A like this it is nice to keep things tidy IMO :). (temporary message) –  Jacob Akkerboom Mar 14 at 15:22
add comment

8 Answers 8

You can compute it in chunks, and then sum the values of the chunks. For example, something like

Total[1.0/Select[Range[k, k + chunk - 1], nonine[#] &]]
share|improve this answer
add comment

You are asking Mathematica to compute approximately 80,000,000 rational numbers with large numerators and denominators. It not too surprising that you ran out of memory. If machine precision reals are good enough, then you might try

Plus @@ (1/N @ Select[Range[10000000, 88888888], Not @ MemberQ[IntegerDigits[#], 9] &])

1.07145

% // FullForm

1.0714523172876622

share|improve this answer
1  
This is incorrect. Opposite of what OP is asking for... –  rasher Mar 13 at 7:45
    
@rasher. Thanks for pointing out my error. I've fixed it. –  m_goldberg Mar 13 at 12:00
add comment

Here is a simple For loop that doesn't cost you any memory:

(x = 0.; For[i = 10000000, i <= 88888888, i++, 
  If[StringMatchQ[IntegerString[i], "*9*"] == False, x += 1./i]]; x)

You should get:

1.07145232

Edit

I initially wrote my answer to solve the memory problem, but I guess if speed is also an issue as it usually is with Mathematica one can compile my code easily by changing the predicate. So here is a compiled version:

f = Compile[{{x, _Integer}, {y, _Integer}}, 
  Module[{sum = 0., i}, 
   For[i = x, i <= y, i++, If[MemberQ[IntegerDigits[i], 9] == False, sum += Divide[1., i]]]; sum],
 CompilationTarget -> "C"]

So

f[10000000, 88888888] // AbsoluteTiming

{10.618008, 1.07145232}

share|improve this answer
add comment

You're creating much more work than needed, try something like:

Sum[1/FromDigits[IntegerDigits[x, 9]], {x, 4782969, 43046720}]

This should complete on any machine with decent memory size (I'm on netbook at moment, can't verify that). Use N inside sum if arbitrary precision is not needed.

The structure of the digits in your query should be a clue...

Edit: This completed (took a while) on my netbook using machine precision, so should certainly be fine on a "real" machine at arbitrary precision. Using the clue, probably even a more direct way to get this. Of course, compile away if a precise answer is not needed.

Another way of doing this directly without the wasted work of a naive solution is:

Total@(1/FromDigits /@ Tuples[Join[{Range[8]}, ConstantArray[Range[0, 8], 7]]])

This again only operates on the numbers that matter, generated rather than filtered and wasting time. A similar construct can trivially be adapted to any conditions, e.g. "No nines anywhere and no 6 in the sixth digit", etc.

Neat question, and a good example of speed via thinking about the characteristics of the problem (naive brute-force is doing over double the work needed to solve this) vs speeding up unneeded work.

share|improve this answer
add comment

All the functions you need are compilable, so you might just Compile your code to gain some speed :

sum = Compile[{{start, _Integer}, {end, _Integer}, {digit, _Integer}},
        Module[{out = 0., counter = start},
          While[counter <= end, 
                out = out + (1./counter)  Boole[Not[MemberQ[IntegerDigits[counter], digit]]];   
                counter++] ;
           out
         ]
        ]

sum[10000000, 88888888, 9] // AbsoluteTiming
(* {18.919000, 1.07145} *)

Compiling to "C" (just add , CompilationTarget -> "C" to the above) :

sumC[10000000, 88888888, 9] // AbsoluteTiming
(* {11.663000, 1.07145} *)

As it is, the code by @RunnyKine is not compilable, so the comparison is not favorable :

(x = 0.; 
 For[i = 10000000, 
     i <= 88888888, 
     i++, 
     If[StringMatchQ[IntegerString[i], "*9*"] == False,  x += 1./i]
 ]; 
 x) // AbsoluteTiming
(* {275.261000, 1.07145} *)
share|improve this answer
    
Nice answer, it seems we get the same results. You are hardcore for waiting the 275 seconds :) –  Jacob Akkerboom Mar 13 at 10:29
    
@JacobAkkerboom Thanks, but I just left it running and did something else. It probably took you longer to write your (better) code. –  b.gatessucks Mar 13 at 10:33
    
Yeah, I guess so, it took me a while to get it right. I always take long, that's my secret :P. I have to make up for it with fast code ;). By the way it was nice to see we had exactly the same code for testing if the IntegerDigits contained a 9. –  Jacob Akkerboom Mar 13 at 10:39
add comment

With the definitions

a = 10000000;
b = 88888888;

createLookUp[nn_] := 
 Boole[! MemberQ[IntegerDigits[#], 9]] & /@ Range[nn]

unless9Rec = Function[If[! MemberQ[IntegerDigits[#], 9], 1/#, 0]]

cfu =
  Compile[
   {{a, _Integer}, {b, _Integer}, {lookup, _Integer, 1}}
   ,
   Block[
    {sum, len, largeFixedInt, min, max, nn},
    largeFixedInt = 0;
    sum = 0.;
    nn = Length@lookup;
    min = Quotient[a, nn, 1] + 1;
    max = Quotient[b, nn];
    Do[
     largeFixedInt = nn*ii;
     If[
      lookup[[ii]] == 1
      ,
      Do[
        If[
         lookup[[jj]] == 1,
         sum += 1/(largeFixedInt + jj)
         ]
        ,
        {jj, nn}
        ];

      ]
     ,
     {ii, min, max}

     ];
    sum

    ]

   ,
   CompilationTarget -> "C"
   ];

We have

(
  nn = 1*^4;
  lookup = createLookUp[nn]; ;
  unless9Rec[a] + cfu[a, b, lookup] - unless9Rec[Ceiling[b, nn]])
  ) // Timing

{0.358173, 1.07145}

share|improve this answer
    
It would be a performance hit to always access the lookup table by first subtracting 1. This code should translate to C relatively easily, where arrays start at 0. –  Jacob Akkerboom Mar 13 at 10:27
add comment

A functional version is not that terrible in 29 seconds:

AbsoluteTiming@
 Fold[#1 + If[MemberQ[IntegerDigits[#2], 9], 0., 1./#2] &, 0., 
  Range[10000000, 88888888]]

{28.718411, 1.07145}

but if you go to arbitrary precision arithmetic it becomes prohibitive I think.

share|improve this answer
add comment

Update

This runs in about half a second:

Total[1.0 ~Divide~ Flatten@Outer[Plus,
     Range[0, 8],
     Range[0, 80, 10],
     Range[0, 800, 100],
     Range[0, 8000, 1000],
     Range[0, 80000, 10000],
     Range[0, 800000, 100000],
     Range[0, 8000000, 1000000],
     Range[10000000, 80000000, 10000000]]]

(* 1.07145 *)

Original

This is far from elegant, but runs in a couple of seconds:

Compile[{},
  Block[{s = 0.},
   Do[s += 1./(a + b + c + d + e + f + g + h),
    {a, 0, 8},
    {b, 0, 80, 10},
    {c, 0, 800, 100},
    {d, 0, 8000, 1000},
    {e, 0, 80000, 10000},
    {f, 0, 800000, 100000},
    {g, 0, 8000000, 1000000},
    {h, 10000000, 80000000, 10000000}];
   s]][]

(* 1.07145 *)
share|improve this answer
    
You beat me to adding Outer. :-) –  Mr.Wizard Mar 13 at 13:39
1  
@Mr.Wizard, I tried Outer originally but kept getting an out of memory crash. The problem was using / for the division, as soon as I put Divide in instead it worked. –  Simon Woods Mar 13 at 13:47
    
This is amazing (+1)- can you explain why Flatten@Outer[10^8 #1 + 10^7 #2 + 10^6 #3 + 10^5 #4 + 10^4 #5 + 10^3 #6 +10^2 #2 + 10 #1 &, Range[1, 8], Range[0, 8], Range[0, 8], Range[0, 8], Range[0, 8], Range[0, 8], Range[0, 8], Range[0, 8]] takes that much longer? –  gpap Mar 13 at 15:23
    
@gpap, all those extra multiplications make a difference! That pure function is called nearly 79 million times... –  Simon Woods Mar 13 at 16:35
    
@SimonWoods ah, I am being daft. Thanks! –  gpap Mar 13 at 16:45
show 3 more comments

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.