Efficient way to determine number of digits in an integer

Question

What is a very efficient way of determining how many digits there are in an integer in C

User · Answer

int numberOfDigits double number       if number  lt  0           number  -1            int i 0          while number  gt  pow 10  i               i            cout  lt  lt   This number has    lt  lt  i  lt  lt    digits   lt  lt  endl      return i

User · Answer

A previous poster suggested a loop that divides by 10  Since multiplies on modern machines are a lot faster  I d recommend the following code instead    int digits   1  pten 10  while   pten  lt   number     digits    pten  10

User · Answer

Here s a different approach   digits   sprintf numArr    d   num         where numArr is a char array if  num  lt  0      digits--    This may not be efficient  just something different than what others suggested

User · Answer

int x   1000  int numberOfDigits   x   static cast lt int gt  log10 abs x      1   1

User · Answer

If faster is more efficient  this is a improvement on andrei alexandrescu s improvement  His version was already faster than the naive way  dividing by 10 at every digit   The version below is constant time and faster at least on x86-64 and ARM for all sizes  but occupies twice as much binary code  so it is not as cache-friendly   Benchmarks for this version vs alexandrescu s version on my PR on facebook folly   Works on unsigned  not signed   inline uint32 t digits10 uint64 t v      return  1            std  uint32 t  v gt  10             std  uint32 t  v gt  100             std  uint32 t  v gt  1000             std  uint32 t  v gt  10000             std  uint32 t  v gt  100000             std  uint32 t  v gt  1000000             std  uint32 t  v gt  10000000             std  uint32 t  v gt  100000000             std  uint32 t  v gt  1000000000             std  uint32 t  v gt  10000000000ull             std  uint32 t  v gt  100000000000ull             std  uint32 t  v gt  1000000000000ull             std  uint32 t  v gt  10000000000000ull             std  uint32 t  v gt  100000000000000ull             std  uint32 t  v gt  1000000000000000ull             std  uint32 t  v gt  10000000000000000ull             std  uint32 t  v gt  100000000000000000ull             std  uint32 t  v gt  1000000000000000000ull             std  uint32 t  v gt  10000000000000000000ull

User · Answer

int num dig quant   0  cout lt  lt   n n t t--Count the digits in Number-- n n   cout lt  lt  Enter Number     cin gt  gt num  for int i   1  i lt  num  i  10       if num   i   gt  0         dig quant    1           cout lt  lt   n  lt  lt number lt  lt   include   lt  lt dig quant lt  lt   digit   cout lt  lt   n nGoodbye    n n

User · Answer

C  11 update of preferred solution    include  lt limits gt   include  lt type traits gt          template  lt typename T gt          typename std  enable if lt std  numeric limits lt T gt   is integer  unsigned int gt   type         numberDigits T value                unsigned int digits   0              if  value  lt  0  digits   1              while  value                    value    10                    digits                            return digits              prevents template instantiation with double  et  al

User · Answer

This is my way to do that       int digitcount int n                int count   1          int temp   n          while  true                        temp    10              if  temp    0    count              if  temp    0  break                     return count

User · Answer

The ppc architecture has a bit counting instruction   With that  you can determine the log base 2 of a positive integer in a single instruction   For example  32 bit would be    define log 2 32 ppc x   31-  cntlzw x     If you can handle a small margin of error on large values you can convert that to log base 10 with another few instructions    define log 10 estimate 32 ppc x   9-     cntlzw x  1233  1545  gt  gt 12     This is platform specific and slightly inaccurate  but also involves no branches  division or conversion to floating point   All depends on what you need   I only know the ppc instructions off hand  but other architectures should have similar instructions

User · Answer

I like Ira Baxter s answer   Here is a template variant that handles the various sizes and deals with the maximum integer values  updated to hoist the upper bound check out of the loop     include  lt boost integer traits hpp gt   template lt typename T gt  T max decimal         T t   1       for  unsigned i   boost  integer traits lt T gt   digits10  i  --i          t    10       return t     template lt typename T gt  unsigned digits T v        if  v  lt  0  v   -v       if  max decimal lt T gt     lt   v          return boost  integer traits lt T gt   digits10   1       unsigned digits   1      T boundary   10       while  boundary  lt   v            boundary    10            digits             return digits      To actually get the improved performance from hoisting the additional test out of the loop  you need to specialise max decimal   to return constants for each type on your platform   A sufficiently magic compiler could optimise the call to max decimal   to a constant  but specialisation is better with most compilers today   As it stands  this version is probably slower because max decimal costs more than the tests removed from the loop   I ll leave all that as an exercise for the reader

User · Answer

convert to string and then use built-in functions  unsigned int i  cout lt  lt  to string i  length   lt  lt endl

User · Answer

See Bit Twiddling Hacks for a much shorter version of the answer you accepted   It also has the benefit of finding the answer sooner if your input is normally distributed  by checking the big constants first    v  gt   1000000000  catches 76  of the values  so checking that first will on average be faster

User · Answer

Determine the number of digits for a 64 bit integer      - Uses at most 5 comparisons      -  cX  2014 adolfo dimare gmail com     -  see http   stackoverflow com questions 1489830  27670035       d    Number length vs Number of comparisons     c       code           d    c    d    c      d    c    d    c          --- ---   --- ---     --- ---   --- ---          20   5    15   5      10   5     5   5          19   5    14   5       9   5     4   5          18   4    13   4       8   4     3   4          17   4    12   4       7   4     2   4          16   4    11   4       6   4     1   4       endcode    unsigned NumDigits64bs uint64 t x        return    Num- gt   Digits- gt  0-9  64- gt bits bs- gt Binary Search       x  gt   10000000000ul     11-20   1-10                  x  gt   1000000000000000ul     16-20   11-15                  16-20                x  gt   100000000000000000ul     18-20   16-17                      18-20                    x  gt   1000000000000000000ul     19-20   18                        19-20                        x  gt    10000000000000000000ul     20   19                          20                         19                                         18                                       16-17                    x  gt    10000000000000000ul     17   16                      17                     16                                                 11-15                x  gt   1000000000000ul     13-15   11-12                      13-15                    x  gt   10000000000000ul     14-15   13                        14-15                        x  gt    100000000000000ul     15   14                          15                         14                                         13                                       11-12                    x  gt    100000000000ul     12   11                      12                     11                                                       1-10            x  gt   100000ul     6-10   1-5                  6-10                x  gt   10000000ul     8-10   6-7                      8-10                    x  gt   100000000ul     9-10   8                        9-10                        x  gt    1000000000ul     10   9                          10                          9                                         8                                       6-7                    x  gt    1000000ul     7   6                      7                     6                                                 1-5                x  gt   100ul     3-5   1-2                      3-5                    x  gt   1000ul     4-5   3                        4-5                        x  gt    10000ul     5   4                          5                         4                                         3                                       1-2                    x  gt    10ul     2   1                      2                     1

User · Answer

Practical joke  This is the most efficient way  number of digits is calculated at compile-time    template  lt unsigned long long N  size t base 10 gt  struct numberlength       enum   value   1   numberlength lt N base  base gt   value        template  lt size t base gt  struct numberlength lt 0  base gt        enum   value   0         May be useful to determine the width required for number field in formatting  input elements etc

User · Answer

Meta-program to calculate number of digits in  unsigned   N       template  lt unsigned long long N  unsigned base 10 gt  struct numberlength        http   stackoverflow com questions 1489830      enum   value     1 lt  N  amp  amp  N lt base   1   1 numberlength lt N base  base gt   value          template  lt unsigned base gt  struct numberlength lt 0  base gt        enum   value   1              assert   1    numberlength lt 0 10 gt   value       assert   1    numberlength lt 1 10 gt   value     assert   1    numberlength lt 5 10 gt   value     assert   1    numberlength lt 9 10 gt   value      assert   4    numberlength lt 1000 10 gt   value     assert   4    numberlength lt 5000 10 gt   value     assert   4    numberlength lt 9999 10 gt   value

User · Answer

include  lt stdint h gt     uint32 t  available since C99       Determine the number of digits for a 32 bit integer      - Uses at most 4 comparisons      -  cX  2014 adolfo dimare gmail com     -  see http   stackoverflow com questions 1489830  27669966       d    Number length vs Number of comparisons     c       code           d    c    d    c          --- ---   --- ---          10   4     5   4           9   4     4   4           8   3     3   3           7   3     2   3           6   3     1   3       endcode    unsigned NumDigits32bs uint32 t x        return    Num- gt   Digits- gt  0-9  32- gt bits bs- gt Binary Search       x  gt   100000u     6-10   1-5              6-10            x  gt   10000000u     8-10   6-7                  8-10                x  gt   100000000u     9-10   8                    9-10                    x  gt    1000000000u     10   9                      10                      9                                 8                               6-7                x  gt    1000000u     7   6                  7                 6                                     1-5            x  gt   100u     3-5   1-2                  3-5                x  gt   1000u     4-5   3                    4-5                    x  gt    10000u     5   4                      5                     4                                 3                               1-2                x  gt    10u     2   1                  2                 1

User · Answer

include  lt iostream gt    include  lt math h gt    using namespace std    int main           double num       int result       cout lt  lt  Enter a number to find the number of digits   not including decimal places          cin gt  gt num       result     num lt  1   1   log10 num  1        cout lt  lt  Number of digits   lt  lt result lt  lt endl       return 0       This is probably the simplest way of solving your problem  assuming you only care about digits before the decimal and assuming anything less than 10 is just 1 digit

User · Answer

Perhaps I misunderstood the question but doesn t this do it   int NumDigits int x            x   abs x         return  x  lt  10   1               x  lt  100   2               x  lt  1000   3               x  lt  10000   4               x  lt  100000   5               x  lt  1000000   6               x  lt  10000000   7              x  lt  100000000   8              x  lt  1000000000   9             10

User · Answer

template  lt typename type gt  class number of decimal digits          const powers and max lt type gt  mPowersAndMax  public      number of decimal digits                 inline size t ndigits  type i  const           if i lt 0                i     i    std  numeric limits lt type gt   min                  i -i                    const type  begin    amp  mPowersAndMax begin            const type  end   begin mPowersAndMax size            return 1   std  lower bound begin end i  - begin            inline size t string ndigits const type amp  i  const           return  i lt 0    ndigits i             inline size t operator   const type amp  i  const          return string ndigits i              where in powers and max we have  10 n -1 for all n such that    10 n   lt  std  numeric limits lt type gt   max     and std  numeric limits lt type gt   max   in an array   template  lt typename type gt  struct powers and max   protected std  vector lt type gt       typedef std  vector lt type gt  super      using super  const iterator      using super  size      type amp  operator   size t i const return super  operator   i        const iterator begin  const  return super  begin          const iterator end  const  return super  end          powers and max            const int size    int  log10 double std  numeric limits lt type gt   max              int j   0         type i   10         for    j lt size    j              push back i-1    9 99 999 9999 etc             i  10                  ASSERT back   lt std  numeric limits lt type gt   max            push back std  numeric limits lt type gt   max               here s a simple test   number of decimal digits lt int gt   ndd  ASSERT ndd 0   1   ASSERT ndd 9   1   ASSERT ndd 10   2   ASSERT ndd -10   3   ASSERT ndd -1   2   ASSERT ndd -9   2   ASSERT ndd 1000000000   10   ASSERT ndd 0x7fffffff   10   ASSERT ndd -1000000000   11   ASSERT ndd 0x80000000   11     Of course any other implementation of an ordered set might be used for powers and max and if there was knowledge that there would be clustering but no knowledge of where the cluster might be perhaps a self adjusting tree implementation might be best

User · Answer

for integer  X  you want to know the number of digits    alright without using any loop   this solution act in one formula in one line only so this is the most  optimal solution i have ever seen to this problem      int x   1000     cout lt  lt numberOfDigits   1 floor log10 x   lt  lt endl

User · Answer

int digits   0  while  number    0    number    10  digits        Note   0  will have 0 digits  If you need 0 to appear to have 1 digit  use   int digits   0  do   number    10  digits      while  number    0      Thanks Kevin Fegan   In the end  use a profiler to know which of all the answers here will be faster on your machine

User · Answer

I was working on a program that required me to check if the user correctly answered how many digits were in a number  so i had to develop a way to check the amount of digits in an integer  It ended up being a relatively easy thing to solve   double check 0  exponent 1000   while check lt  1        check number pow 10  exponent       exponent--     exponent exponent 2  cout lt  lt exponent lt  lt endl    This ended up being my answer which currently works with numbers with less than 10 1000 digits  can be changed by changing the value of exponent     P S  I know this answer is ten years late but I got here on 2020 so other people might use it

User · Answer

Well  the most efficient way  presuming you know the size of the integer  would be a lookup   Should be faster than the much shorter logarithm based approach   If you don t care about counting the  -   remove the   1      generic solution template  lt class T gt  int numDigits T number        int digits   0      if  number  lt  0  digits   1     remove this line if  -  counts as a digit     while  number            number    10          digits              return digits        partial specialization optimization for 32-bit numbers template lt  gt  int numDigits int32 t x        if  x    MIN INT  return 10   1      if  x  lt  0  return numDigits -x    1       if  x  gt   10000            if  x  gt   10000000                if  x  gt   100000000                    if  x  gt   1000000000                      return 10                  return 9                            return 8                    if  x  gt   100000                if  x  gt   1000000                  return 7              return 6                    return 5            if  x  gt   100            if  x  gt   1000              return 4          return 3            if  x  gt   10          return 2      return 1        partial-specialization optimization for 8-bit numbers template  lt  gt  int numDigits char n           if you have the time  replace this with a static initialization to avoid        the initial overhead  amp  unnecessary branch     static char x 256     0       if  x 0     0            for  char c   1  c    0  c                x c    numDigits  int32 t c           x 0    1            return x n

User · Answer

effective way  int num  int count   0  while num       num    10       count         include  lt iostream gt   int main        int num     std  cin  gt  gt  num      std  cout  lt  lt   number of digits for    lt  lt  num  lt  lt            int count   0     while num             num    10          count           std  cout  lt  lt  count  lt  lt    n       return 0

User · Answer

in case the number of digits AND the value of each digit position is needed use this   int64 t   number  digitValue  digits   0        or  int  for 32bit  while  number    0        digitValue   number   10      digits         number    10      digit gives you the value at the number postition which is currently processed in the loop  for example for the number 1776 the digit value is  6 in the 1st loop 7 in the 2nd loop 7 in the 3rd loop 1 in the 4th loop

User · Answer

The simplest way is to do   unsigned GetNumberOfDigits  unsigned i        return i  gt  0    int  log10   double  i    1   1      log10 is defined in  lt cmath gt  or  lt math h gt   You d need to profile this to see if it s faster than any of the others posted here  I m not sure how robust this is with regards to float point precision  Also  the argument is unsigned as negative values and log don t really mix

User · Answer

sample console output long long num   123456789  int digit   1  int result   1   while  result    0         result   num   10      if  result    0                  digit            num   result     cout  lt  lt   quot Your number has  quot   lt  lt  digit  lt  lt   quot digits quot   lt  lt  endl

User · Answer

Yet another code snippet  doing basically the same as Vitali s but employs binary search  Powers array is lazy initialized once per unsigned type instance  Signed type overload takes care of minus sign    include  lt limits gt   include  lt type traits gt   include  lt array gt   template  lt class T gt   size t NumberOfDecPositions   T v  typename std  enable if lt std  is unsigned lt T gt   value gt   type    0         typedef std  array lt T std  numeric limits lt T gt   digits10 1 gt  array type      static array type powers of 10      if   powers of 10 front      0                 T n   1          for   T amp  i  powers of 10                         i   n              n    10                       size t l   0  r   powers of 10 size    p      while   l 1  lt  r                 p    l r  2          if   powers of 10 p   lt   v               l   p          else             r   p            return l   1      template  lt class T gt   size t NumberOfDecPositions   T v  typename std  enable if lt std  is signed lt T gt   value gt   type    0         typedef typename std  make unsigned lt T gt   type unsigned type      if   v  lt  0           return NumberOfDecPositions   static cast lt unsigned type gt  -v      1      else         return NumberOfDecPositions   static cast lt unsigned type gt  v         If anybody cares of further optimization  please note that the first element of powers array is never used  and the l appears with  1 2 times

User · Answer

int numberOfDigits int n        if n lt  9           return 1            return 1   numberOfDigits n 10       This is what i would do  if you want it for base 10 Its pretty fast and you prolly wont get a stack overflock buy counting integers

[c++] Efficient way to determine number of digits in an integer

Examples related to c++

Examples related to integer

Examples related to digits