计算整数小数长度的最快方法？（。净）-Fastestwaytocalculatethedecimallengthofaninteger?(.NET)

2  

Here's a binary-search version, which I have tested, which works on 64-bit integers using exactly five comparisons each time.

这是我测试过的二进制搜索版本,它每次只使用五次比较就可以使用64位整数。

int base10len(uint64_t n) {
  int len = 0;
  /* n <10^32 */
  if (n >= 10000000000000000ULL) { n /= 10000000000000000ULL; len += 16; }
  /* n <10^16 */
  if (n >= 100000000) { n /= 100000000; len += 8; }
  /* n <100000000 = 10^8 */
  if (n >= 10000) { n /= 10000; len += 4; }
  /* n <10000 */
  if (n >= 100) { n /= 100; len += 2; }
  /* n <100 */
  if (n >= 10) { return len + 2; }
  else         { return len + 1; }
}

I doubt this is going to be any faster than what you're already doing. But it's predictable.

我怀疑这会比你已经做的更快。但这是可以预测的。

2  

I did some testing, and this seems to be 2-4 times faster than the code that you have now:

我做了一些测试,这似乎比你现在的代码快2-4倍:

static int getLen(long x) {
    int len = 1;
    while (x > 9999) {
        x /= 10000;
        len += 4;
    }
    while (x > 99) {
        x /= 100;
        len += 2;
    }
    if (x > 9) len++;
    return len;
}

Edit:
Here is a version that uses more Int32 operations, that should work better if you don't have an x64 application:

编辑:这是一个使用更多Int32操作的版本,如果您没有x64应用程序,它应该可以更好地工作:

static int getLen(long x) {
    int len = 1;
    while (x > 99999999) {
        x /= 100000000;
        len += 8;
    }
    int y = (int)x;
    while (y > 999) {
        y /= 1000;
        len += 3;
    }
    while (y > 9) {
        y /= 10;
        len ++;
    }
    return len;
}

0  

You commented in code that 10 digits or more is very uncommon, so your original solution is not bad

您在代码中注释了10位数或更多位数是非常罕见的,因此您的原始解决方案也不错

0  

I haven't tested this, but the change of base law says:

我没有测试过这个,但基本法的变化说:

Log10(x) = Log2(x) / Log2(10)

Log10(x)= Log2(x)/ Log2(10)

Log2 should be a bit faster than Log10 if it's implemented right.

如果实现正确,Log2应该比Log10快一点。

0  

static int getDigitCount( int x )
    {
    int digits = ( x <0 ) ? 2 : 1; // '0' has one digit,negative needs space for sign
    while( x > 9 ) // after '9' need more
        {
        x /= 10; // divide and conquer
        digits++;
        }
    return digits;
    }

-1  

not sure if this is faster or not.. but you can always count...

不确定这是否更快..但你可以随时计算......

static int getLen(long x) {
    int len = 1;
    while (x > 0) {
        x = x/10;
        len++
    };
    return len
}

-1  

What do you mean by length? Number of zeros or everything? This does significant figures, but you get the general idea

你的长度是什么意思?零或一切的数量?这确实有重要的数字,但你得到了一般的想法

public static string SpecialFormat(int v, int sf)  
{  
     int k = (int)Math.Pow(10, (int)(Math.Log10(v) + 1 - sf));  
     int v2 = ((v + k/2) / k) * k;  
     return v2.ToString("0,0");  
}

-1  

It's a simple way.

这是一种简单的方法。

private static int GetDigitCount(int number)
{
    int digit = 0;

    number = Math.Abs(number);

    while ((int)Math.Pow(10, digit++) <= number);

    return digit - 1;
}

If number is unsigned int then "Math.Abs(number)" not necessary.

如果number是unsigned int,那么“Math.Abs​​(number)”不是必需的。

I made extension method with all numeric types.

我用所有数字类型制作了扩展方法。

    private static int GetDigitCount(dynamic number)
    {
        dynamic digit = 0;

        number = Math.Abs(number);

        while ((dynamic)Math.Pow(10, digit++) <= number)
            ;

        return digit - 1;
    }

    public static int GetDigit(this int number)
    {
        return GetDigitCount(number);
    }

    public static int GetDigit(this long number)
    {
        return GetDigitCount(number);
    }

then you use this.

然后你用这个。

int x = 100;
int digit = x.GetDigit();  // 3 expected.