Services & ResourcesWolfram ForumsMathGroup Archive

[Date Index] [Thread Index] [Author Index]

Re: count zeros in a number

• To: mathgroup at smc.vnet.net
• Subject: [mg121869] Re: count zeros in a number
• From: DrMajorBob <btreat1 at austin.rr.com>
• Date: Wed, 5 Oct 2011 04:02:55 -0400 (EDT)
• Delivered-to: l-mathgroup@mail-archive0.wolfram.com
• References: <201110020636.CAA28027@smc.vnet.net> <j6brvm$8om$1@smc.vnet.net>
• Reply-to: drmajorbob at yahoo.com

This does the same thing as your code, essentially:

x = 24^24*55^55;
xd = IntegerDigits@x;
Length@xd - Length@IntegerDigits@FromDigits@Reverse@xd

55

and there's no reason for ToString to be faster than IntegerDigits, so...

Do[xd = IntegerDigits@x;
   Length@xd -
    Length@IntegerDigits@FromDigits@Reverse@xd, {1000}] // Timing

{0.029022, Null}

versus

Do[(xs = ToString[x];
    StringLength[xs] -
     StringLength[
      ToString[ToExpression[StringReverse[xs]]]]), {1000}] // Timing

{0.032321, Null}

Bobby

On Tue, 04 Oct 2011 17:19:44 -0500, Richard Fateman  
<fateman at eecs.berkeley.edu> wrote:

> On 10/4/2011 2:33 PM, DrMajorBob wrote:
>> I'm guessing that I got zero because I ran some of the code with an  
>> undefined x. My bad!
>
>
> I think that you (me too)  might not have noticed that one of my methods  
> changed x.  Here is a safer version.
>
> savedx= 24^24*55^55;
>
>
> Well, here's another method..
>
> (xs = ToString[savedx];
>   StringLength[xs] -    
> StringLength[ToString[ToExpression[StringReverse[xs]]]])
>
> Let's time it, running 1000 times.
>
> Do[ (xs = ToString[savedx];
>     StringLength[xs] -
>      StringLength[
>       ToString[ToExpression[StringReverse[xs]]]]), {1000}] // Timing
>
> {0.063,Null}
>
> This bizarre hack  is reasonably fast, indeed twice as fast  as your  
> method, on my system.
>
> Do[Replace[
>     IntegerDigits@x, {__, zeroes : 0 ..} :>
>      Length@{zeroes}], {1000}] // Timing
>
> {0.141, Null}
>
> and seven times as fast as my older simple arithmetic method which uses  
> iteration,
>
>
> Do[(n = 0; x = savedx; While[Mod[x, 10] == 0, (x = x/10; n++)];
>     n), {1000}] // Timing
>
> {0.438, Null}
>
> and which (as I contended) was inefficient in Mathematica.  While you  
> seem to think that this method is ancient and outmoded, I think it is  
> not the method, but the implementation of iteration. Or perhaps of  
> arithmetic?
>
> Another implementation of this arithmetical method on the same computer  
> takes 0.063 seconds.
>
> RJF
>
>>
>> Correcting that, I find the esoteric method faster than your ancient,  
>> outmoded ones:
>>
>> x = 24^24*55^55;
>> Replace[IntegerDigits@x, {__, zeroes : 0 ..} :>
>>    Length@{zeroes}] // Timing
>>
>> {0.000198, 55}
>>
>> (n = 0; While[GCD[x, 10^n] == 10^n, n++]; n - 1) // Timing
>>
>> {0.000417, 55}
>>
>> (n = 0; While[Mod[x, 10] == 0, (x = x/10; n++)]; n) // Timing
>>
>> {0.000228, 55}
>>
>> Bobby
>>
>> On Tue, 04 Oct 2011 15:57:30 -0500, Richard Fateman  
>> <fateman at eecs.berkeley.edu> wrote:
>>
>>> On 10/4/2011 9:44 AM, DrMajorBob wrote:
>>>> There's nothing "esoteric" about IntegerDigits, Replace, or Repeated,  
>>>> as in:
>>>>
>>>> x = 24^24*55^55;
>>>> Replace[IntegerDigits@x, {__, zeroes : 0 ..} :>
>>>>    Length@{zeroes}] // Timing
>>>>
>>>> {0.000185, 55}
>>>
>>> My feeling is that these ARE esoteric.  A person just introduced to  
>>> Mathematica would probably not encounter IntegerDigits, Repeated, or  
>>> patterns other than the trivial one used in pseudo function  
>>> definitions as
>>> f[x_]:=   x+1.
>>>
>>>
>>>>
>>>> If we wanted brute-force arithmetic, we might use Fortran.
>>>>
>>>> Your suggested solutions are NOT greatly hindered by "the slow  
>>>> implementation of looping constructs in Mathematica", on the other  
>>>> hand:
>>>>
>>>> (n = 0; While[GCD[x, 10^n] == 10^n, n++]; n - 1) // Timing
>>>>
>>>> {0.000029, 0}
>>>
>>> huh?   I got  {0., 55}.   Perhaps my computer is faster or has a lower  
>>> resolution timer, but we should both get 55.
>>>
>>>>
>>>> (n = 0; While[Mod[x, 10] == 0, (x = x/10; n++)]; n) // Timing
>>>>
>>>> {0.000018, 0}
>>>
>>> I mention the slow implementation of looping constructs simply to warn  
>>> people that if you can resolve your computation by simple composition  
>>> of built-in functions e.g. F[G[H[x]]]   and don't rely on Mathematica
>>> to efficiently execute loops written as While[] For[]  etc, you are  
>>> probably going to run faster.  Let Mathematica's operation on compound  
>>> objects like lists do the job.  Length[] is a lot faster than counting  
>>> with a While etc.
>>>
>>> In my timings, doing the operations 1000 times..
>>> Do[.....,{1000}]//Timing
>>>
>>> I found that my solutions were about 10X faster than the IntegerDigits  
>>> one, on this particular value of x.
>>>
>>> Fortran can't be used unless you manage arbitrary precision integers...
>>>
>>> RJF
>>>
>>>
>>>
>>
>>
>


-- 
DrMajorBob at yahoo.com

• References:
  • count zeros in a number
    • From: dimitris <dimmechan@yahoo.com>