blocks|key|1597749|text|不确定这是不是更快..但你总能数到...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1597750|static+int+getLen(long+x)+{
++++int+len+=+1;
++++while+(x+>+0)+{
++++++++x+=+x/10;
++++++++len%2B%2B
++++};
++++return+len
}|code-block|syntax|javascript|1597751|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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

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

blocks|key|1597786|text|你说的长度是什么意思？0的个数还是所有的数字？This做的是有意义的数字，但您得到的是大体概念|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1597787|public+static+string+SpecialFormat(int+v,+int+sf)++
{++
+++++int+k+=+(int)Math.Pow(10,+(int)(Math.Log10(v)+%2B+1+-+sf));++
+++++int+v2+=+((v+%2B+k/2)+/+k)+*+k;++
+++++return+v2.ToString("0,0");++
}|code-block|syntax|javascript|1597788|entityMap|0|LINK|mutability|MUTABLE|url|http://www.shrinkrays.net/articles/dotnet-formatting-strings.aspx^0|N|4|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

What do you mean by length? Number of zeros or everything? <a href="http://www.shrinkrays.net/articles/dotnet-formatting-strings.aspx" rel="nofollow noreferrer">This</a> does significant figures, but you get the general idea

<pre><code>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"); 
}
</code></pre>

blocks|key|1597856|text|这是一个二进制搜索版本，我已经测试过了，它在64位整数上工作，每次只使用五次比较。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1597857|int+base10len(uint64_t+n)+{
++int+len+=+0;
++/*+n+<+10%5E32+*/
++if+(n+>=+10000000000000000ULL)+{+n+/=+10000000000000000ULL;+len+%2B=+16;+}
++/*+n+<+10%5E16+*/
++if+(n+>=+100000000)+{+n+/=+100000000;+len+%2B=+8;+}
++/*+n+<+100000000+=+10%5E8+*/
++if+(n+>=+10000)+{+n+/=+10000;+len+%2B=+4;+}
++/*+n+<+10000+*/
++if+(n+>=+100)+{+n+/=+100;+len+%2B=+2;+}
++/*+n+<+100+*/
++if+(n+>=+10)+{+return+len+%2B+2;+}
++else+++++++++{+return+len+%2B+1;+}
}|code-block|syntax|javascript|1597858|我怀疑这会比你已经做的更快。但这是可以预测的。|1597859|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

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

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

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

blocks|key|1382825|text|您在代码中评论说10位或更多的数字非常不常见，所以您最初的解决方案还不错|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1382826|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

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

blocks|key|1382907|text|我做了一些测试，这似乎比你现在的代码快2-4倍：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1382908|static+int+getLen(long+x)+{
++++int+len+=+1;
++++while+(x+>+9999)+{
++++++++x+/=+10000;
++++++++len+%2B=+4;
++++}
++++while+(x+>+99)+{
++++++++x+/=+100;
++++++++len+%2B=+2;
++++}
++++if+(x+>+9)+len%2B%2B;
++++return+len;
}|code-block|syntax|javascript|1382909|编辑：|1382910|下面是一个使用了更多Int32操作的版本，如果您没有x64应用程序，它应该会工作得更好：|1382911|static+int+getLen(long+x)+{
++++int+len+=+1;
++++while+(x+>+99999999)+{
++++++++x+/=+100000000;
++++++++len+%2B=+8;
++++}
++++int+y+=+(int)x;
++++while+(y+>+999)+{
++++++++y+/=+1000;
++++++++len+%2B=+3;
++++}
++++while+(y+>+9)+{
++++++++y+/=+10;
++++++++len+%2B%2B;
++++}
++++return+len;
}|1382912|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

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

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

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

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

blocks|key|1597997|text|我还没有测试过，但是基准法的变化是这样说的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1597998|Log10(x)+=+Log2(x)+/+Log2(10)|1597999|如果实现得当，Log2应该比Log10快一点。|1598000|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

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

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

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

blocks|key|1382962|text|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%2B%2B;
++++++++}
++++return+digits;
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1382963|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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

blocks|key|1598054|text|这是一种简单的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1598055|private+static+int+GetDigitCount(int+number)
{
++++int+digit+=+0;

++++number+=+Math.Abs(number);

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

++++return+digit+-+1;
}|code-block|syntax|javascript|1598056|如果number是无符号整数，则不需要"Math.Abs(number)“。|1598057|我做了所有数值类型的扩展方法。|1598058|++++private+static+int+GetDigitCount(dynamic+number)
++++{
++++++++dynamic+digit+=+0;

++++++++number+=+Math.Abs(number);

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

++++++++return+digit+-+1;
++++}

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

++++public+static+int+GetDigit(this+long+number)
++++{
++++++++return+GetDigitCount(number);
++++}|1598059|然后你可以使用这个。|1598060|int+x+=+100;
int+digit+=+x.GetDigit();++//+3+expected.|1598061|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

It's a simple way.

<pre><code>private static int GetDigitCount(int number)
{
 int digit = 0;

 number = Math.Abs(number);

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

 return digit - 1;
}
</code></pre>

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

I made extension method with all numeric types.

<pre><code> private static int GetDigitCount(dynamic number)
 {
 dynamic digit = 0;

 number = Math.Abs(number);

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

 return digit - 1;
 }

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

 public static int GetDigit(this long number)
 {
 return GetDigitCount(number);
 }
</code></pre>

then you use this.

<pre><code>int x = 100;
int digit = x.GetDigit(); // 3 expected.
</code></pre>

I have some code that does a lot of comparisons of 64-bit integers, however it must take into account the length of the number, as if it was formatted as a string. I can't change the calling code, only the function.

The easiest way (besides .ToString().Length) is:

<pre><code>(int)Math.Truncate(Math.Log10(x)) + 1;
</code></pre>

However that performs rather poorly. Since my application only sends positive values, and the lengths are rather evenly distributed between 2 and 9 (with some bias towards 9), I precomputed the values and have if statements:

<pre><code>static int getLen(long x) {
 if (x &lt; 1000000) {
 if (x &lt; 100) return 2;
 if (x &lt; 1000) return 3;
 if (x &lt; 10000) return 4;
 if (x &lt; 100000) return 5;
 return 6;
 } else {
 if (x &lt; 10000000) return 7;
 if (x &lt; 100000000) return 8;
 if (x &lt; 1000000000) return 9; 
 return (int)Math.Truncate(Math.Log10(x)) + 1; // Very uncommon
 }
}
</code></pre>

This lets the length be computed with an average of 4 compares. 

So, are there any other tricks I can use to make this function faster?

Edit: This will be running as 32-bit code (Silverlight).

Update:

I took Norman's suggestion and changed the ifs around a bit to result in an average of only 3 compares. As per Sean's comment, I removed the Math.Truncate. Together, this boosted things about 10%. Thanks!

Fastest way to calculate the decimal length of an integer? (.NET)

我有一些代码对64位整数进行了大量的比较，但是它必须考虑数字的长度，就好像它被格式化为字符串一样。我不能更改调用代码，只能更改函数。最简单的方法(除了.ToString().Length)是：(int)Math.Truncate(Math.Log10(x)) + 1;然而，这表现得相当糟糕。因为我的应用程序只发送正值，...

问计算整数小数长度的最快方法？(.NET)
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问计算整数小数长度的最快方法？(.NET)EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问计算整数小数长度的最快方法？(.NET)
EN