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>