Services & Resources / Wolfram Forums / MathGroup Archive
-----

MathGroup Archive 2011

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

Search the Archive

Re: count zeros in a number

  • To: mathgroup at smc.vnet.net
  • Subject: [mg121868] Re: count zeros in a number
  • From: Richard Fateman <fateman at eecs.berkeley.edu>
  • Date: Wed, 5 Oct 2011 04:02:44 -0400 (EDT)
  • Delivered-to: l-mathgroup@mail-archive0.wolfram.com
  • References: <201110020636.CAA28027@smc.vnet.net> <j6brvm$8om$1@smc.vnet.net> <201110040530.BAA20698@smc.vnet.net> <op.v2t544pxtgfoz2@bobbys-imac.local> <4E8B733A.8050506@eecs.berkeley.edu> <op.v2ujibmqtgfoz2@bobbys-imac.local>

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
>>
>>
>>
>
>




  • Prev by Date: Re: Fully vectorized system of ODE's - any advantage of C?
  • Next by Date: Re: A collection of Mathematica learning resources
  • Previous by thread: Re: count zeros in a number
  • Next by thread: Re: count zeros in a number