blocks|key|1737927|text|‘'Will’vs+'Does'？我是一个巨大的粉丝，在编写、分析代码后对其进行优化，这被确定为瓶颈。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737928|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|$]]

'Will' vs 'Does'? I'm a huge fan of optimizing code after it's wrote, profiled, and it's been determined to be the bottleneck.

blocks|key|1730894|text|这样如何：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1730895|public+static+int[]+ConvertToArrayOfDigits(int+value)
{
++++int+size+=+DetermineDigitCount(value);
++++int[]+digits+=+new+int[size];
++++for+(int+index+=+size+-+1;+index+>=+0;+index--)
++++{
++++++++digits[index]+=+value+%25+10;
++++++++value+=+value+/+10;
++++}
++++return+digits;
}

private+static+int+DetermineDigitCount(int+x)
{
++++//+This+bit+could+be+optimised+with+a+binary+search
++++return+x+<+10+?+1
+++++++++:+x+<+100+?+2
+++++++++:+x+<+1000+?+3
+++++++++:+x+<+10000+?+4
+++++++++:+x+<+100000+?+5
+++++++++:+x+<+1000000+?+6
+++++++++:+x+<+10000000+?+7
+++++++++:+x+<+100000000+?+8
+++++++++:+x+<+1000000000+?+9
+++++++++:+10;
}|code-block|syntax|javascript|1730896|请注意，这不能处理负数...你需要这样做吗？|1730897|编辑:根据Eric的建议，这是一个版本，它记录了低于10000的结果。如果您绝对可以保证不会更改返回数组的内容，则可以删除Clone调用。它还具有方便的特性，可以减少检查次数以确定“大”数字的长度-而小数字无论如何只会通过该代码一次:)|offset|length|style|CODE|1730898|private+static+readonly+int[][]+memoizedResults+=+new+int[10000][];

public+static+int[]+ConvertToArrayOfDigits(int+value)
{
++++if+(value+<+10000)
++++{
++++++++int[]+memoized+=+memoizedResults[value];
++++++++if+(memoized+==+null)+{
++++++++++++memoized+=+ConvertSmall(value);
++++++++++++memoizedResults[value]+=+memoized;
++++++++}
++++++++return+(int[])+memoized.Clone();
++++}
++++//+We+know+that+value+>=+10000
++++int+size+=+value+<+100000+?+5
+++++++++:+value+<+1000000+?+6
+++++++++:+value+<+10000000+?+7
+++++++++:+value+<+100000000+?+8
+++++++++:+value+<+1000000000+?+9
+++++++++:+10;

++++return+ConvertWithSize(value,+size);
}

private+static+int[]+ConvertSmall(int+value)
{
++++//+We+know+that+value+<+10000
++++int+size+=+value+<+10+?+1
+++++++++++++:+value+<+100+?+2
+++++++++++++:+value+<+1000+?+3+:+4;
++++return+ConvertWithSize(value,+size);
}

private+static+int[]+ConvertWithSize(int+value,+int+size)
{
++++int[]+digits+=+new+int[size];
++++for+(int+index+=+size+-+1;+index+>=+0;+index--)
++++{
++++++++digits[index]+=+value+%25+10;
++++++++value+=+value+/+10;
++++}
++++return+digits;
}|1730899|请注意，目前这并不是线程安全的。您可能需要添加一个内存屏障，以确保在单个结果中的写入可见之前，对已存储结果的写入是不可见的。除非万不得已，否则我已经放弃了对这些事情的推理。我相信你可以通过努力让它没有锁，但如果你真的需要的话，你真的应该找一个非常聪明的人来做这件事。|1730900|编辑:我刚刚意识到“大”案例可以利用“小”案例-将大数字分成两个小数字，并使用记忆中的结果。我会在晚餐后试一试，然后写一个基准测试...|1730901|编辑:好的，准备好大量的代码了吗？我意识到，至少对于均匀随机数，你会得到更多的“大”数字而不是小数字-所以你需要对此进行优化。当然，真实数据可能不是这样的，但不管怎样...这意味着我现在以相反的顺序做我的大小测试，希望首先是大数字。|1730902|我有一个原始代码的基准，简单的memoization，然后是极其展开的代码。|1730903|结果(毫秒)：|1730904|Simple:+3168
SimpleMemo:+3061
UnrolledMemo:+1204|1730905|代码：|1730906|using+System;
using+System.Diagnostics;

class+DigitSplitting
{
++++static+void+Main()++++++++
++++{
++++++++Test(Simple);
++++++++Test(SimpleMemo);
++++++++Test(UnrolledMemo);
++++}

++++const+int+Iterations+=+10000000;

++++static+void+Test(Func<int,+int[]>+candidate)
++++{
++++++++Random+rng+=+new+Random(0);
++++++++Stopwatch+sw+=+Stopwatch.StartNew();
++++++++for+(int+i+=+0;+i+<+Iterations;+i%2B%2B)
++++++++{
++++++++++++candidate(rng.Next());
++++++++}
++++++++sw.Stop();
++++++++Console.WriteLine("{0}:+{1}",
++++++++++++candidate.Method.Name,+(int)+sw.ElapsedMilliseconds);++++++++++++
++++}

++++#region+Simple
++++static+int[]+Simple(int+value)
++++{
++++++++int+size+=+DetermineDigitCount(value);
++++++++int[]+digits+=+new+int[size];
++++++++for+(int+index+=+size+-+1;+index+>=+0;+index--)
++++++++{
++++++++++++digits[index]+=+value+%25+10;
++++++++++++value+=+value+/+10;
++++++++}
++++++++return+digits;
++++}

++++private+static+int+DetermineDigitCount(int+x)
++++{
++++++++//+This+bit+could+be+optimised+with+a+binary+search
++++++++return+x+<+10+?+1
+++++++++++++:+x+<+100+?+2
+++++++++++++:+x+<+1000+?+3
+++++++++++++:+x+<+10000+?+4
+++++++++++++:+x+<+100000+?+5
+++++++++++++:+x+<+1000000+?+6
+++++++++++++:+x+<+10000000+?+7
+++++++++++++:+x+<+100000000+?+8
+++++++++++++:+x+<+1000000000+?+9
+++++++++++++:+10;
++++}
++++#endregion+Simple++++

++++#region+SimpleMemo
++++private+static+readonly+int[][]+memoizedResults+=+new+int[10000][];

++++public+static+int[]+SimpleMemo(int+value)
++++{
++++++++if+(value+<+10000)
++++++++{
++++++++++++int[]+memoized+=+memoizedResults[value];
++++++++++++if+(memoized+==+null)+{
++++++++++++++++memoized+=+ConvertSmall(value);
++++++++++++++++memoizedResults[value]+=+memoized;
++++++++++++}
++++++++++++return+(int[])+memoized.Clone();
++++++++}
++++++++//+We+know+that+value+>=+10000
++++++++int+size+=+value+>=+1000000000+?+10
+++++++++++++++++:+value+>=+100000000+?+9
+++++++++++++++++:+value+>=+10000000+?+8
+++++++++++++++++:+value+>=+1000000+?+7
+++++++++++++++++:+value+>=+100000+?+6
+++++++++++++++++:+5;

++++++++return+ConvertWithSize(value,+size);
++++}

++++private+static+int[]+ConvertSmall(int+value)
++++{
++++++++//+We+know+that+value+<+10000
++++++++return+value+>=+1000+?+new[]+{+value+/+1000,+(value+/+100)+%25+10,
+++++++++++++++++++++++++++++++++++++++++++(value+/+10)+%25+10,+value+%25+10+}
++++++++++++++:+value+>=+100+?+new[]+{+value+/+100,+(value+/+10)+%25+10,+
+++++++++++++++++++++++++++++++++++++++++value+%25+10+}
++++++++++++++:+value+>=+10+?+new[]+{+value+/+10,+value+%25+10+}
++++++++++++++:+new+int[]+{+value+};
++++}

++++private+static+int[]+ConvertWithSize(int+value,+int+size)
++++{
++++++++int[]+digits+=+new+int[size];
++++++++for+(int+index+=+size+-+1;+index+>=+0;+index--)
++++++++{
++++++++++++digits[index]+=+value+%25+10;
++++++++++++value+=+value+/+10;
++++++++}
++++++++return+digits;
++++}
++++#endregion

++++#region+UnrolledMemo
++++private+static+readonly+int[][]+memoizedResults2+=+new+int[10000][];
++++private+static+readonly+int[][]+memoizedResults3+=+new+int[10000][];
++++static+int[]+UnrolledMemo(int+value)
++++{
++++++++if+(value+<+10000)
++++++++{
++++++++++++return+(int[])+UnclonedConvertSmall(value).Clone();
++++++++}
++++++++if+(value+>=+1000000000)
++++++++{
++++++++++++int[]+ret+=+new+int[10];
++++++++++++int+firstChunk+=+value+/+100000000;
++++++++++++ret[0]+=+firstChunk+/+10;
++++++++++++ret[1]+=+firstChunk+%25+10;
++++++++++++value+-=+firstChunk+*+100000000;
++++++++++++int[]+secondChunk+=+ConvertSize4(value+/+10000);
++++++++++++int[]+thirdChunk+=+ConvertSize4(value+%25+10000);
++++++++++++ret[2]+=+secondChunk[0];
++++++++++++ret[3]+=+secondChunk[1];
++++++++++++ret[4]+=+secondChunk[2];
++++++++++++ret[5]+=+secondChunk[3];
++++++++++++ret[6]+=+thirdChunk[0];
++++++++++++ret[7]+=+thirdChunk[1];
++++++++++++ret[8]+=+thirdChunk[2];
++++++++++++ret[9]+=+thirdChunk[3];
++++++++++++return+ret;
++++++++}+
++++++++else+if+(value+>=+100000000)
++++++++{
++++++++++++int[]+ret+=+new+int[9];
++++++++++++int+firstChunk+=+value+/+100000000;
++++++++++++ret[0]+=+firstChunk;
++++++++++++value+-=+firstChunk+*+100000000;
++++++++++++int[]+secondChunk+=+ConvertSize4(value+/+10000);
++++++++++++int[]+thirdChunk+=+ConvertSize4(value+%25+10000);
++++++++++++ret[1]+=+secondChunk[0];
++++++++++++ret[2]+=+secondChunk[1];
++++++++++++ret[3]+=+secondChunk[2];
++++++++++++ret[4]+=+secondChunk[3];
++++++++++++ret[5]+=+thirdChunk[0];
++++++++++++ret[6]+=+thirdChunk[1];
++++++++++++ret[7]+=+thirdChunk[2];
++++++++++++ret[8]+=+thirdChunk[3];
++++++++++++return+ret;
++++++++}
++++++++else+if+(value+>=+10000000)
++++++++{
++++++++++++int[]+ret+=+new+int[8];
++++++++++++int[]+firstChunk+=+ConvertSize4(value+/+10000);
++++++++++++int[]+secondChunk+=+ConvertSize4(value+%25+10000);
++++++++++++ret[0]+=+firstChunk[0];
++++++++++++ret[1]+=+firstChunk[0];
++++++++++++ret[2]+=+firstChunk[0];
++++++++++++ret[3]+=+firstChunk[0];
++++++++++++ret[4]+=+secondChunk[0];
++++++++++++ret[5]+=+secondChunk[1];
++++++++++++ret[6]+=+secondChunk[2];
++++++++++++ret[7]+=+secondChunk[3];
++++++++++++return+ret;
++++++++}
++++++++else+if+(value+>=+1000000)
++++++++{
++++++++++++int[]+ret+=+new+int[7];
++++++++++++int[]+firstChunk+=+ConvertSize4(value+/+10000);
++++++++++++int[]+secondChunk+=+ConvertSize4(value+%25+10000);
++++++++++++ret[0]+=+firstChunk[1];
++++++++++++ret[1]+=+firstChunk[2];
++++++++++++ret[2]+=+firstChunk[3];
++++++++++++ret[3]+=+secondChunk[0];
++++++++++++ret[4]+=+secondChunk[1];
++++++++++++ret[5]+=+secondChunk[2];
++++++++++++ret[6]+=+secondChunk[3];
++++++++++++return+ret;
++++++++}
++++++++else+if+(value+>=+100000)
++++++++{
++++++++++++int[]+ret+=+new+int[6];
++++++++++++int[]+firstChunk+=+ConvertSize4(value+/+10000);
++++++++++++int[]+secondChunk+=+ConvertSize4(value+%25+10000);
++++++++++++ret[0]+=+firstChunk[2];
++++++++++++ret[1]+=+firstChunk[3];
++++++++++++ret[2]+=+secondChunk[0];
++++++++++++ret[3]+=+secondChunk[1];
++++++++++++ret[4]+=+secondChunk[2];
++++++++++++ret[5]+=+secondChunk[3];
++++++++++++return+ret;
++++++++}
++++++++else
++++++++{
++++++++++++int[]+ret+=+new+int[5];
++++++++++++int[]+chunk+=+ConvertSize4(value+%25+10000);
++++++++++++ret[0]+=+value+/+10000;
++++++++++++ret[1]+=+chunk[0];
++++++++++++ret[2]+=+chunk[1];
++++++++++++ret[3]+=+chunk[2];
++++++++++++ret[4]+=+chunk[3];
++++++++++++return+ret;
++++++++}
++++}

++++private+static+int[]+UnclonedConvertSmall(int+value)
++++{
++++++++int[]+ret+=+memoizedResults2[value];
++++++++if+(ret+==+null)
++++++++{
++++++++++++ret+=+value+>=+1000+?+new[]+{+value+/+1000,+(value+/+100)+%25+10,
+++++++++++++++++++++++++++++++++++++++++++(value+/+10)+%25+10,+value+%25+10+}
++++++++++++++:+value+>=+100+?+new[]+{+value+/+100,+(value+/+10)+%25+10,+
+++++++++++++++++++++++++++++++++++++++++value+%25+10+}
++++++++++++++:+value+>=+10+?+new[]+{+value+/+10,+value+%25+10+}
++++++++++++++:+new+int[]+{+value+};
++++++++++++memoizedResults2[value]+=+ret;
++++++++}
++++++++return+ret;
++++}

++++private+static+int[]+ConvertSize4(int+value)
++++{
++++++++int[]+ret+=+memoizedResults3[value];
++++++++if+(ret+==+null)
++++++++{
++++++++++++ret+=+new[]+{+value+/+1000,+(value+/+100)+%25+10,
+++++++++++++++++++++++++(value+/+10)+%25+10,+value+%25+10+};
++++++++++++memoizedResults3[value]+=+ret;
++++++++}
++++++++return+ret;
++++}
++++#endregion+UnrolledMemo
}|1730907|entityMap^0|0|0|0|1P|5|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1A|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1B|8|@$K|1C|L|1D|M|N]]|9|@]|A|$]]|$1|O|3|P|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1F|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1H|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1J|8|@]|9|@]|A|$]]|$1|10|3|11|5|D|7|1K|8|@]|9|@]|A|$E|F]]|$1|12|3|13|5|6|7|1L|8|@]|9|@]|A|$]]|$1|14|3|15|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|16|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|17|$]]

How about:

<pre><code>public static int[] ConvertToArrayOfDigits(int value)
{
 int size = DetermineDigitCount(value);
 int[] digits = new int[size];
 for (int index = size - 1; index &gt;= 0; index--)
 {
 digits[index] = value % 10;
 value = value / 10;
 }
 return digits;
}

private static int DetermineDigitCount(int x)
{
 // This bit could be optimised with a binary search
 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;
}
</code></pre>

Note that this won't cope with negative numbers... do you need it to?

EDIT: Here's a version which memoizes the results for under 10000, as suggested by Eric. If you can absolutely guarantee that you won't change the contents of the returned array, you could remove the <code>Clone</code> call. It also has the handy property of reducing the number of checks to determine the length of "large" numbers - and small numbers will only go through that code once anyway :)

<pre><code>private static readonly int[][] memoizedResults = new int[10000][];

public static int[] ConvertToArrayOfDigits(int value)
{
 if (value &lt; 10000)
 {
 int[] memoized = memoizedResults[value];
 if (memoized == null) {
 memoized = ConvertSmall(value);
 memoizedResults[value] = memoized;
 }
 return (int[]) memoized.Clone();
 }
 // We know that value &gt;= 10000
 int size = value &lt; 100000 ? 5
 : value &lt; 1000000 ? 6
 : value &lt; 10000000 ? 7
 : value &lt; 100000000 ? 8
 : value &lt; 1000000000 ? 9
 : 10;

 return ConvertWithSize(value, size);
}

private static int[] ConvertSmall(int value)
{
 // We know that value &lt; 10000
 int size = value &lt; 10 ? 1
 : value &lt; 100 ? 2
 : value &lt; 1000 ? 3 : 4;
 return ConvertWithSize(value, size);
}

private static int[] ConvertWithSize(int value, int size)
{
 int[] digits = new int[size];
 for (int index = size - 1; index &gt;= 0; index--)
 {
 digits[index] = value % 10;
 value = value / 10;
 }
 return digits;
}
</code></pre>

Note that this doesn't try to be thread-safe at the moment. You may need to add a memory barrier to make sure that the write to the memoized results isn't visible until the writes within the individual result are visible. I've given up trying to reason about these things unless I absolutely have to. I'm sure you can make it lock-free with effort, but you should really get someone very smart to do so if you really need to.

EDIT: I've just realised that the "large" case can make use of the "small" case - split the large number into two small ones and use the memoised results. I'll give that a go after dinner and write a benchmark...

EDIT: Okay, ready for a giant amount of code? I realised that for uniformly random numbers at least, you'll get "big" numbers much more often than small ones - so you need to optimise for that. Of course, that might not be the case for real data, but anyway... it means I now do my size tests in the opposite order, hoping for big numbers first.

I've got a benchmark for the original code, the simple memoization, and then the extremely-unrolled code.

Results (in ms):

<pre><code>Simple: 3168
SimpleMemo: 3061
UnrolledMemo: 1204
</code></pre>

Code:

<pre><code>using System;
using System.Diagnostics;

class DigitSplitting
{
 static void Main() 
 {
 Test(Simple);
 Test(SimpleMemo);
 Test(UnrolledMemo);
 }

 const int Iterations = 10000000;

 static void Test(Func&lt;int, int[]&gt; candidate)
 {
 Random rng = new Random(0);
 Stopwatch sw = Stopwatch.StartNew();
 for (int i = 0; i &lt; Iterations; i++)
 {
 candidate(rng.Next());
 }
 sw.Stop();
 Console.WriteLine("{0}: {1}",
 candidate.Method.Name, (int) sw.ElapsedMilliseconds); 
 }

 #region Simple
 static int[] Simple(int value)
 {
 int size = DetermineDigitCount(value);
 int[] digits = new int[size];
 for (int index = size - 1; index &gt;= 0; index--)
 {
 digits[index] = value % 10;
 value = value / 10;
 }
 return digits;
 }

 private static int DetermineDigitCount(int x)
 {
 // This bit could be optimised with a binary search
 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;
 }
 #endregion Simple 

 #region SimpleMemo
 private static readonly int[][] memoizedResults = new int[10000][];

 public static int[] SimpleMemo(int value)
 {
 if (value &lt; 10000)
 {
 int[] memoized = memoizedResults[value];
 if (memoized == null) {
 memoized = ConvertSmall(value);
 memoizedResults[value] = memoized;
 }
 return (int[]) memoized.Clone();
 }
 // We know that value &gt;= 10000
 int size = value &gt;= 1000000000 ? 10
 : value &gt;= 100000000 ? 9
 : value &gt;= 10000000 ? 8
 : value &gt;= 1000000 ? 7
 : value &gt;= 100000 ? 6
 : 5;

 return ConvertWithSize(value, size);
 }

 private static int[] ConvertSmall(int value)
 {
 // We know that value &lt; 10000
 return value &gt;= 1000 ? new[] { value / 1000, (value / 100) % 10,
 (value / 10) % 10, value % 10 }
 : value &gt;= 100 ? new[] { value / 100, (value / 10) % 10, 
 value % 10 }
 : value &gt;= 10 ? new[] { value / 10, value % 10 }
 : new int[] { value };
 }

 private static int[] ConvertWithSize(int value, int size)
 {
 int[] digits = new int[size];
 for (int index = size - 1; index &gt;= 0; index--)
 {
 digits[index] = value % 10;
 value = value / 10;
 }
 return digits;
 }
 #endregion

 #region UnrolledMemo
 private static readonly int[][] memoizedResults2 = new int[10000][];
 private static readonly int[][] memoizedResults3 = new int[10000][];
 static int[] UnrolledMemo(int value)
 {
 if (value &lt; 10000)
 {
 return (int[]) UnclonedConvertSmall(value).Clone();
 }
 if (value &gt;= 1000000000)
 {
 int[] ret = new int[10];
 int firstChunk = value / 100000000;
 ret[0] = firstChunk / 10;
 ret[1] = firstChunk % 10;
 value -= firstChunk * 100000000;
 int[] secondChunk = ConvertSize4(value / 10000);
 int[] thirdChunk = ConvertSize4(value % 10000);
 ret[2] = secondChunk[0];
 ret[3] = secondChunk[1];
 ret[4] = secondChunk[2];
 ret[5] = secondChunk[3];
 ret[6] = thirdChunk[0];
 ret[7] = thirdChunk[1];
 ret[8] = thirdChunk[2];
 ret[9] = thirdChunk[3];
 return ret;
 } 
 else if (value &gt;= 100000000)
 {
 int[] ret = new int[9];
 int firstChunk = value / 100000000;
 ret[0] = firstChunk;
 value -= firstChunk * 100000000;
 int[] secondChunk = ConvertSize4(value / 10000);
 int[] thirdChunk = ConvertSize4(value % 10000);
 ret[1] = secondChunk[0];
 ret[2] = secondChunk[1];
 ret[3] = secondChunk[2];
 ret[4] = secondChunk[3];
 ret[5] = thirdChunk[0];
 ret[6] = thirdChunk[1];
 ret[7] = thirdChunk[2];
 ret[8] = thirdChunk[3];
 return ret;
 }
 else if (value &gt;= 10000000)
 {
 int[] ret = new int[8];
 int[] firstChunk = ConvertSize4(value / 10000);
 int[] secondChunk = ConvertSize4(value % 10000);
 ret[0] = firstChunk[0];
 ret[1] = firstChunk[0];
 ret[2] = firstChunk[0];
 ret[3] = firstChunk[0];
 ret[4] = secondChunk[0];
 ret[5] = secondChunk[1];
 ret[6] = secondChunk[2];
 ret[7] = secondChunk[3];
 return ret;
 }
 else if (value &gt;= 1000000)
 {
 int[] ret = new int[7];
 int[] firstChunk = ConvertSize4(value / 10000);
 int[] secondChunk = ConvertSize4(value % 10000);
 ret[0] = firstChunk[1];
 ret[1] = firstChunk[2];
 ret[2] = firstChunk[3];
 ret[3] = secondChunk[0];
 ret[4] = secondChunk[1];
 ret[5] = secondChunk[2];
 ret[6] = secondChunk[3];
 return ret;
 }
 else if (value &gt;= 100000)
 {
 int[] ret = new int[6];
 int[] firstChunk = ConvertSize4(value / 10000);
 int[] secondChunk = ConvertSize4(value % 10000);
 ret[0] = firstChunk[2];
 ret[1] = firstChunk[3];
 ret[2] = secondChunk[0];
 ret[3] = secondChunk[1];
 ret[4] = secondChunk[2];
 ret[5] = secondChunk[3];
 return ret;
 }
 else
 {
 int[] ret = new int[5];
 int[] chunk = ConvertSize4(value % 10000);
 ret[0] = value / 10000;
 ret[1] = chunk[0];
 ret[2] = chunk[1];
 ret[3] = chunk[2];
 ret[4] = chunk[3];
 return ret;
 }
 }

 private static int[] UnclonedConvertSmall(int value)
 {
 int[] ret = memoizedResults2[value];
 if (ret == null)
 {
 ret = value &gt;= 1000 ? new[] { value / 1000, (value / 100) % 10,
 (value / 10) % 10, value % 10 }
 : value &gt;= 100 ? new[] { value / 100, (value / 10) % 10, 
 value % 10 }
 : value &gt;= 10 ? new[] { value / 10, value % 10 }
 : new int[] { value };
 memoizedResults2[value] = ret;
 }
 return ret;
 }

 private static int[] ConvertSize4(int value)
 {
 int[] ret = memoizedResults3[value];
 if (ret == null)
 {
 ret = new[] { value / 1000, (value / 100) % 10,
 (value / 10) % 10, value % 10 };
 memoizedResults3[value] = ret;
 }
 return ret;
 }
 #endregion UnrolledMemo
}
</code></pre>

blocks|key|1732619|text|上百万次并不是很多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1732620|//+input:+int+num+>=+0
List<byte>+digits+=+new+List<byte>();
while+(num+>+0)
{
+++byte+digit+=+(byte)+(num+%25+10);
+++digits.Insert(0,+digit);++//+Insert+to+preserve+order
+++num+=+num+/+10;
}

//+if+you+really+want+it+as+an+array
byte[]+bytedata+=+digits.ToArray();|code-block|syntax|javascript|1732621|请注意，如果您将字节更改为sbyte并测试num+!=+0，则可以对此进行更改以处理负数。|offset|length|style|CODE|1732622|entityMap^0|0|0|L|8|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|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Millions of times isn't that much.

<pre><code>// input: int num &gt;= 0
List&lt;byte&gt; digits = new List&lt;byte&gt;();
while (num &gt; 0)
{
 byte digit = (byte) (num % 10);
 digits.Insert(0, digit); // Insert to preserve order
 num = num / 10;
}

// if you really want it as an array
byte[] bytedata = digits.ToArray();
</code></pre>

Note that this could be changed to cope with negative numbers if you change byte to sbyte and test for <code>num != 0</code>.

blocks|key|1732628|text|将整数转换为字符串，然后使用String.Chars[]|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1732629|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|$]]

convert integer to string and then use String.Chars[]

blocks|key|1732651|text|如果你可以使用前导零，那就容易多了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1732652|++++void+Test()
++++{+
++++++++//+Note:+10+is+the+maximum+number+of+digits.
++++++++int[]+xs+=+new+int[10];
++++++++System.Random+r+=+new+System.Random();
++++++++for+(int+i=0;+i+<+10000000;+%2B%2Bi)
++++++++++++Convert(xs,+r.Next(int.MaxValue));
++++}

++++//+Notice,+I+don't+allocate+and+return+an+array+each+time.
++++public+void+Convert(int[]+digits,+int+val)
++++{
++++++++for+(int+i+=+0;+i+<+10;+%2B%2Bi)
++++++++{
++++++++++++digits[10+-+i+-+1]+=+val+%25+10;
++++++++++++val+/=+10;
++++++++}
++++}|code-block|syntax|javascript|1732653|编辑:这是一个更快的版本。在我的电脑上，它的测试速度比Jon+Skeet的两个算法都要快，除了他的记忆版本：|1732654|static+void+Convert(int[]+digits,+int+val)
{
++digits[9]+=+val+%25+10;+val+/=+10;
++digits[8]+=+val+%25+10;+val+/=+10;
++digits[7]+=+val+%25+10;+val+/=+10;
++digits[6]+=+val+%25+10;+val+/=+10;
++digits[5]+=+val+%25+10;+val+/=+10;
++digits[4]+=+val+%25+10;+val+/=+10;
++digits[3]+=+val+%25+10;+val+/=+10;
++digits[2]+=+val+%25+10;+val+/=+10;
++digits[1]+=+val+%25+10;+val+/=+10;
++digits[0]+=+val+%25+10;+val+/=+10;+++++
}+|1732655|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you can get by with leading zeros it is much easier. 

<pre><code> void Test()
 { 
 // Note: 10 is the maximum number of digits.
 int[] xs = new int[10];
 System.Random r = new System.Random();
 for (int i=0; i &lt; 10000000; ++i)
 Convert(xs, r.Next(int.MaxValue));
 }

 // Notice, I don't allocate and return an array each time.
 public void Convert(int[] digits, int val)
 {
 for (int i = 0; i &lt; 10; ++i)
 {
 digits[10 - i - 1] = val % 10;
 val /= 10;
 }
 }
</code></pre>

EDIT: Here is a faster version. On my computer it tested faster than two of Jon Skeet's algorithms, except for his memoized version:

<pre><code>static void Convert(int[] digits, int val)
{
 digits[9] = val % 10; val /= 10;
 digits[8] = val % 10; val /= 10;
 digits[7] = val % 10; val /= 10;
 digits[6] = val % 10; val /= 10;
 digits[5] = val % 10; val /= 10;
 digits[4] = val % 10; val /= 10;
 digits[3] = val % 10; val /= 10;
 digits[2] = val % 10; val /= 10;
 digits[1] = val % 10; val /= 10;
 digits[0] = val % 10; val /= 10; 
} 
</code></pre>

blocks|key|1738116|text|1%2B+Math.Log10(num)将在没有任何搜索/循环的情况下给出位数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1738117|public+static+byte[]+Digits(int+num)
{
++++int+nDigits+=+1+%2B+Convert.ToInt32(Math.Floor(Math.Log10(num)));
++++byte[]+digits+=+new+byte[nDigits];
++++int+index+=+nDigits+-+1;
++++while+(num+>+0)+{
++++++++byte+digit+=+(byte)+(num+%25+10);
++++++++digits[index]+=+digit;
++++++++num+=+num+/+10;
++++++++index+=+index+-+1;
++++}
++++return+digits;
}|code-block|syntax|javascript|1738118|编辑：可能更漂亮：|offset|length|style|BOLD|1738119|public+static+byte[]+Digits(int+num)
{
++++int+nDigits+=+1+%2B+Convert.ToInt32(Math.Floor(Math.Log10(num)));
++++byte[]+digits+=+new+byte[nDigits];

++++for(int+i+=+nDigits+-+1;+i+!=+0;+i--)
++++{
++++++++digits[i]+=+(byte)(num+%25+10);
++++++++num+=+num+/+10;
++++}
++++return+digits;
}+|1738120|entityMap^0|0|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

1 + Math.Log10(num) will give the number of digits without any searching/looping:

<pre><code>public static byte[] Digits(int num)
{
 int nDigits = 1 + Convert.ToInt32(Math.Floor(Math.Log10(num)));
 byte[] digits = new byte[nDigits];
 int index = nDigits - 1;
 while (num &gt; 0) {
 byte digit = (byte) (num % 10);
 digits[index] = digit;
 num = num / 10;
 index = index - 1;
 }
 return digits;
}
</code></pre>

Edit: Possibly prettier:

<pre><code>public static byte[] Digits(int num)
{
 int nDigits = 1 + Convert.ToInt32(Math.Floor(Math.Log10(num)));
 byte[] digits = new byte[nDigits];

 for(int i = nDigits - 1; i != 0; i--)
 {
 digits[i] = (byte)(num % 10);
 num = num / 10;
 }
 return digits;
} 
</code></pre>

blocks|key|331054|text|也许是一个小循环的展开？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|331055|int+num+=+147483647;
int+nDigits+=+1+%2B+Convert.ToInt32(Math.Floor(Math.Log10(num)));
byte[]+array+=+new+byte[10]+{
++++++++++++(byte)(num+/+1000000000+%25+10),
++++++++++++(byte)(num+/+100000000+%25+10),
++++++++++++(byte)(num+/+10000000+%25+10),
++++++++++++(byte)(num+/+1000000+%25+10),
++++++++++++(byte)(num+/+100000+%25+10),
++++++++++++(byte)(num+/+10000+%25+10),
++++++++++++(byte)(num+/+1000+%25+10),
++++++++++++(byte)(num+/+100+%25+10),
++++++++++++(byte)(num+/+10+%25+10),
++++++++++++(byte)(num+%25+10)};
byte[]+digits;//+=+new+byte[nDigits];
digits+=+array.Skip(array.Length-nDigits).ToArray();|code-block|syntax|javascript|331056|上面感谢Log10的东西..;)|331057|有一些关于基准的讨论……|331058|我已经完全展开了循环，并与Jons的已被接受的memoized变体进行了比较，并且我使用它的速度一直更快：|331059|++++static+int[]+ConvertToArrayOfDigits_unrolled(int+num)
++++{
++++++++if+(num+<+10)
++++++++{
++++++++++++return+new+int[1]+
++++++++++++{
++++++++++++++++(num+%25+10)+
++++++++++++};
++++++++}
++++++++else+if+(num+<+100)
++++++++{
++++++++++++return+new+int[2]+
++++++++++++{
++++++++++++++++(num+/+10+%25+10),
++++++++++++++++(num+%25+10)
++++++++++++};
++++++++}
++++++++else+if+(num+<+1000)
++++++++{
++++++++++++return+new+int[3]+{
++++++++++++(num+/+100+%25+10),
++++++++++++(num+/+10+%25+10),
++++++++++++(num+%25+10)};
++++++++}
++++++++else+if+(num+<+10000)
++++++++{
++++++++++++return+new+int[4]+{
++++++++++++(num+/+1000+%25+10),
++++++++++++(num+/+100+%25+10),
++++++++++++(num+/+10+%25+10),
++++++++++++(num+%25+10)};
++++++++}
++++++++else+if+(num+<+100000)
++++++++{
++++++++++++return+new+int[5]+{
++++++++++++(num+/+10000+%25+10),
++++++++++++(num+/+1000+%25+10),
++++++++++++(num+/+100+%25+10),
++++++++++++(num+/+10+%25+10),
++++++++++++(num+%25+10)};
++++++++}
++++++++else+if+(num+<+1000000)
++++++++{
++++++++++++return+new+int[6]+{
++++++++++++(num+/+100000+%25+10),
++++++++++++(num+/+10000+%25+10),
++++++++++++(num+/+1000+%25+10),
++++++++++++(num+/+100+%25+10),
++++++++++++(num+/+10+%25+10),
++++++++++++(num+%25+10)};
++++++++}
++++++++else+if+(num+<+10000000)
++++++++{
++++++++++++return+new+int[7]+{
++++++++++++(num+/+1000000+%25+10),
++++++++++++(num+/+100000+%25+10),
++++++++++++(num+/+10000+%25+10),
++++++++++++(num+/+1000+%25+10),
++++++++++++(num+/+100+%25+10),
++++++++++++(num+/+10+%25+10),
++++++++++++(num+%25+10)};
++++++++}
++++++++else+if+(num+<+100000000)
++++++++{
++++++++++++return+new+int[8]+{
++++++++++++(num+/+10000000+%25+10),
++++++++++++(num+/+1000000+%25+10),
++++++++++++(num+/+100000+%25+10),
++++++++++++(num+/+10000+%25+10),
++++++++++++(num+/+1000+%25+10),
++++++++++++(num+/+100+%25+10),
++++++++++++(num+/+10+%25+10),
++++++++++++(num+%25+10)};
++++++++}
++++++++else+if+(num+<+1000000000)
++++++++{
++++++++++++return+new+int[9]+{
++++++++++++(num+/+100000000+%25+10),
++++++++++++(num+/+10000000+%25+10),
++++++++++++(num+/+1000000+%25+10),
++++++++++++(num+/+100000+%25+10),
++++++++++++(num+/+10000+%25+10),
++++++++++++(num+/+1000+%25+10),
++++++++++++(num+/+100+%25+10),
++++++++++++(num+/+10+%25+10),
++++++++++++(num+%25+10)};
++++++++}
++++++++else
++++++++{
++++++++++++return+new+int[10]+{
++++++++++++(num+/+1000000000+%25+10),
++++++++++++(num+/+100000000+%25+10),
++++++++++++(num+/+10000000+%25+10),
++++++++++++(num+/+1000000+%25+10),
++++++++++++(num+/+100000+%25+10),
++++++++++++(num+/+10000+%25+10),
++++++++++++(num+/+1000+%25+10),
++++++++++++(num+/+100+%25+10),
++++++++++++(num+/+10+%25+10),
++++++++++++(num+%25+10)};
++++++++}
++++}|331060|可能是我搞砸了--我没有太多的时间玩游戏，但我的时间比以前快了20%25。|331061|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|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

A little loop unrolling perhaps? 

<pre><code>int num = 147483647;
int nDigits = 1 + Convert.ToInt32(Math.Floor(Math.Log10(num)));
byte[] array = new byte[10] {
 (byte)(num / 1000000000 % 10),
 (byte)(num / 100000000 % 10),
 (byte)(num / 10000000 % 10),
 (byte)(num / 1000000 % 10),
 (byte)(num / 100000 % 10),
 (byte)(num / 10000 % 10),
 (byte)(num / 1000 % 10),
 (byte)(num / 100 % 10),
 (byte)(num / 10 % 10),
 (byte)(num % 10)};
byte[] digits;// = new byte[nDigits];
digits = array.Skip(array.Length-nDigits).ToArray();
</code></pre>

Thanks above for the Log10 thingy.. ;)

There's been some talk of benchmarking...

I've fully unrolled the loops, and compared with the accepted memoized variant of Jons, and I get a consistently quicker time with this:-

<pre><code> static int[] ConvertToArrayOfDigits_unrolled(int num)
 {
 if (num &lt; 10)
 {
 return new int[1] 
 {
 (num % 10) 
 };
 }
 else if (num &lt; 100)
 {
 return new int[2] 
 {
 (num / 10 % 10),
 (num % 10)
 };
 }
 else if (num &lt; 1000)
 {
 return new int[3] {
 (num / 100 % 10),
 (num / 10 % 10),
 (num % 10)};
 }
 else if (num &lt; 10000)
 {
 return new int[4] {
 (num / 1000 % 10),
 (num / 100 % 10),
 (num / 10 % 10),
 (num % 10)};
 }
 else if (num &lt; 100000)
 {
 return new int[5] {
 (num / 10000 % 10),
 (num / 1000 % 10),
 (num / 100 % 10),
 (num / 10 % 10),
 (num % 10)};
 }
 else if (num &lt; 1000000)
 {
 return new int[6] {
 (num / 100000 % 10),
 (num / 10000 % 10),
 (num / 1000 % 10),
 (num / 100 % 10),
 (num / 10 % 10),
 (num % 10)};
 }
 else if (num &lt; 10000000)
 {
 return new int[7] {
 (num / 1000000 % 10),
 (num / 100000 % 10),
 (num / 10000 % 10),
 (num / 1000 % 10),
 (num / 100 % 10),
 (num / 10 % 10),
 (num % 10)};
 }
 else if (num &lt; 100000000)
 {
 return new int[8] {
 (num / 10000000 % 10),
 (num / 1000000 % 10),
 (num / 100000 % 10),
 (num / 10000 % 10),
 (num / 1000 % 10),
 (num / 100 % 10),
 (num / 10 % 10),
 (num % 10)};
 }
 else if (num &lt; 1000000000)
 {
 return new int[9] {
 (num / 100000000 % 10),
 (num / 10000000 % 10),
 (num / 1000000 % 10),
 (num / 100000 % 10),
 (num / 10000 % 10),
 (num / 1000 % 10),
 (num / 100 % 10),
 (num / 10 % 10),
 (num % 10)};
 }
 else
 {
 return new int[10] {
 (num / 1000000000 % 10),
 (num / 100000000 % 10),
 (num / 10000000 % 10),
 (num / 1000000 % 10),
 (num / 100000 % 10),
 (num / 10000 % 10),
 (num / 1000 % 10),
 (num / 100 % 10),
 (num / 10 % 10),
 (num % 10)};
 }
 }
</code></pre>

It may be I've messed up somewhere - I don't have much time for fun and games, but I was timing this as 20% quicker.

blocks|key|1738255|text|divide和mod往往是很慢的操作。我想知道使用乘法和减法的解决方案是否会更快，它似乎是(在我的电脑上)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1738256|++++public+static+void+ConvertToArrayOfDigits2(int+value,+int[]+digits)
++++{
++++++++double+v+=+value;
++++++++double+vby10+=+v+*+.1;

++++++++for+(int+index+=+digits.Length+-+1;+index+>=+0;+index--)
++++++++{
++++++++++++int+ivby10+=+(int)vby10;
++++++++++++digits[index]+=+(int)(v)-+ivby10*+10;
++++++++++++v+=+ivby10;
++++++++++++vby10+=+ivby10+*+.1;
++++++++}+++++++
++++}|code-block|syntax|javascript|1738257|我传入了一个数组，而不是每次都分配它，以便将内存分配器和长度从等式中去掉。如果数组长度大于数字，则此版本将生成前导零。与Jon示例的类似转换版本进行比较：|1738258|++++public+static+void+ConvertToArrayOfDigits(int+value,+int[]+digits){

++++++++for+(int+index+=+digits.Length+-+1;+index+>=+0;+index--)++++{+
++++++++++++digits[index]+=+value+%25+10;++++
++++++++++++value+=+value+/+10;++
++++++++}+++
++++}|1738259|no+divide/mod版本花了大约50多个时间来生成所有的数组，直到给定的数字。我也试过使用floats，它只慢了5-10%25+(+double版本比float版本快)。|1738260|只是因为它困扰了我，这里有一个展开的版本，只是稍微快了一点：|1738261|++++++++public+static+void+ConvertToArrayOfDigits3(int+value,+int[]+digits)
++++{
++++++++double+v+=+value;
++++++++double+vby10+=+v+*+.1;
++++++++int+ivby10;

++++++++switch(digits.Length+-1){
++++++++++++default:
++++++++++++++++throw+new+ArgumentOutOfRangeException();
++++++++++++case+10:
++++++++++++++++ivby10+=+(int)vby10;
++++++++++++++++digits[10]+=+(int)(v)+-+ivby10+*+10;
++++++++++++++++v+=+ivby10;
++++++++++++++++vby10+=+ivby10+*+.1;
++++++++++++++++goto+case+9;
++++++++++++case+9:
++++++++++++++++ivby10+=+(int)vby10;
++++++++++++++++digits[9]+=+(int)(v)+-+ivby10+*+10;
++++++++++++++++v+=+ivby10;
++++++++++++++++vby10+=+ivby10+*+.1;
++++++++++++++++goto+case+8;
++++++++++++case+8:
++++++++++++++++ivby10+=+(int)vby10;
++++++++++++++++digits[8]+=+(int)(v)+-+ivby10+*+10;
++++++++++++++++v+=+ivby10;
++++++++++++++++vby10+=+ivby10+*+.1;
++++++++++++++++goto+case+7;
++++++++++++case+7:
++++++++++++++++ivby10+=+(int)vby10;
++++++++++++++++digits[7]+=+(int)(v)+-+ivby10+*+10;
++++++++++++++++v+=+ivby10;
++++++++++++++++vby10+=+ivby10+*+.1;
++++++++++++++++goto+case+6;
++++++++++++case+6:
++++++++++++++++ivby10+=+(int)vby10;
++++++++++++++++digits[6]+=+(int)(v)+-+ivby10+*+10;
++++++++++++++++v+=+ivby10;
++++++++++++++++vby10+=+ivby10+*+.1;
++++++++++++++++goto+case+5;
++++++++++++case+5:
++++++++++++++++ivby10+=+(int)vby10;
++++++++++++++++digits[5]+=+(int)(v)+-+ivby10+*+10;
++++++++++++++++v+=+ivby10;
++++++++++++++++vby10+=+ivby10+*+.1;
++++++++++++++++goto+case+4;
++++++++++++case+4:
++++++++++++++++ivby10+=+(int)vby10;
++++++++++++++++digits[4]+=+(int)(v)+-+ivby10+*+10;
++++++++++++++++v+=+ivby10;
++++++++++++++++vby10+=+ivby10+*+.1;
++++++++++++++++goto+case+3;
++++++++++++case+3:
++++++++++++++++ivby10+=+(int)vby10;
++++++++++++++++digits[3]+=+(int)(v)+-+ivby10+*+10;
++++++++++++++++v+=+ivby10;
++++++++++++++++vby10+=+ivby10+*+.1;
++++++++++++++++goto+case+2;
++++++++++++case+2:
++++++++++++++++ivby10+=+(int)vby10;
++++++++++++++++digits[2]+=+(int)(v)+-+ivby10+*+10;
++++++++++++++++v+=+ivby10;
++++++++++++++++vby10+=+ivby10+*+.1;
++++++++++++++++goto+case+1;
++++++++++++case+1:
++++++++++++++++ivby10+=+(int)vby10;
++++++++++++++++digits[1]+=+(int)(v)+-+ivby10+*+10;
++++++++++++++++v+=+ivby10;
++++++++++++++++vby10+=+ivby10+*+.1;
++++++++++++++++goto+case+0;
++++++++++++case+0:
++++++++++++++++ivby10+=+(int)vby10;
++++++++++++++++digits[0]+=+(int)(v)+-+ivby10+*+10;
++++++++++++++++break;
++++++++}

++++}|1738262|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|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$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|$]]

divide and mod tend to be slow operations. I wanted to find out if a solution using multiply and subtraction would be faster and it seems to be (on my computer):

<pre><code> public static void ConvertToArrayOfDigits2(int value, int[] digits)
 {
 double v = value;
 double vby10 = v * .1;

 for (int index = digits.Length - 1; index &gt;= 0; index--)
 {
 int ivby10 = (int)vby10;
 digits[index] = (int)(v)- ivby10* 10;
 v = ivby10;
 vby10 = ivby10 * .1;
 } 
 }
</code></pre>

I am passing in an array instead of allocating it every time to take the memory allocator and length out of the equation. This version will produce leading zeros if the array is longer than the number. Compared to a similarly converted version of Jon's example:

<pre><code> public static void ConvertToArrayOfDigits(int value, int[] digits){

 for (int index = digits.Length - 1; index &gt;= 0; index--) { 
 digits[index] = value % 10; 
 value = value / 10; 
 } 
 }
</code></pre>

the no divide/mod version took about 50 more time to generate all the arrays up to a given number. I also tried using floats and it was only about 5-10% slower (the double version was quicker than the float version).

Just because it was bothering me, here is an unrolled version which is just slightly faster again:

<pre><code> public static void ConvertToArrayOfDigits3(int value, int[] digits)
 {
 double v = value;
 double vby10 = v * .1;
 int ivby10;

 switch(digits.Length -1){
 default:
 throw new ArgumentOutOfRangeException();
 case 10:
 ivby10 = (int)vby10;
 digits[10] = (int)(v) - ivby10 * 10;
 v = ivby10;
 vby10 = ivby10 * .1;
 goto case 9;
 case 9:
 ivby10 = (int)vby10;
 digits[9] = (int)(v) - ivby10 * 10;
 v = ivby10;
 vby10 = ivby10 * .1;
 goto case 8;
 case 8:
 ivby10 = (int)vby10;
 digits[8] = (int)(v) - ivby10 * 10;
 v = ivby10;
 vby10 = ivby10 * .1;
 goto case 7;
 case 7:
 ivby10 = (int)vby10;
 digits[7] = (int)(v) - ivby10 * 10;
 v = ivby10;
 vby10 = ivby10 * .1;
 goto case 6;
 case 6:
 ivby10 = (int)vby10;
 digits[6] = (int)(v) - ivby10 * 10;
 v = ivby10;
 vby10 = ivby10 * .1;
 goto case 5;
 case 5:
 ivby10 = (int)vby10;
 digits[5] = (int)(v) - ivby10 * 10;
 v = ivby10;
 vby10 = ivby10 * .1;
 goto case 4;
 case 4:
 ivby10 = (int)vby10;
 digits[4] = (int)(v) - ivby10 * 10;
 v = ivby10;
 vby10 = ivby10 * .1;
 goto case 3;
 case 3:
 ivby10 = (int)vby10;
 digits[3] = (int)(v) - ivby10 * 10;
 v = ivby10;
 vby10 = ivby10 * .1;
 goto case 2;
 case 2:
 ivby10 = (int)vby10;
 digits[2] = (int)(v) - ivby10 * 10;
 v = ivby10;
 vby10 = ivby10 * .1;
 goto case 1;
 case 1:
 ivby10 = (int)vby10;
 digits[1] = (int)(v) - ivby10 * 10;
 v = ivby10;
 vby10 = ivby10 * .1;
 goto case 0;
 case 0:
 ivby10 = (int)vby10;
 digits[0] = (int)(v) - ivby10 * 10;
 break;
 }

 }
</code></pre>

blocks|key|1738309|text|为了好玩，这里有一种只使用一条C#语句就可以分隔所有数字的方法。它是这样工作的:正则表达式使用数字的字符串版本，将数字拆分成字符串数组，最后外部的ConvertAll方法从字符串数组创建一个整型数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1738310|++++int+num+=+1234567890;

++++int+[]+arrDigits+=+Array.ConvertAll<string,+int>(
++++++++System.Text.RegularExpressions.Regex.Split(num.ToString(),+@"(?!%5E)(?!$)"),
++++++++str+=>+int.Parse(str)
++++++++);

++++//+resulting+array+is+[1,2,3,4,5,6,7,8,9,0]|code-block|syntax|javascript|1738311|效率方面？...与我在这里看到的其他一些快速答案相比，我不确定。总得有人来测试一下。|1738312|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|$]]

Just for fun, here's a way to separate all the digits using just one C# statement. It works this way: the regular expression uses the string version of the number, splits apart its digits into a string array, and finally the outer ConvertAll method creates an int array from the string array.

<pre><code> int num = 1234567890;

 int [] arrDigits = Array.ConvertAll&lt;string, int&gt;(
 System.Text.RegularExpressions.Regex.Split(num.ToString(), @"(?!^)(?!$)"),
 str =&gt; int.Parse(str)
 );

 // resulting array is [1,2,3,4,5,6,7,8,9,0]
</code></pre>

Efficiency-wise?... I'm unsure compared to some of the other fast answers I see here. Somebody would have to test it.

blocks|key|431679|text|我没有对此或任何东西进行基准测试，但我认为这将是最简单的答案。如果我错了，请纠正我。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|431680|++++Dim+num+As+Integer+=+147483647
++++Dim+nDigits+As+Integer+=+1+%2B+Convert.ToInt32(Math.Floor(Math.Log10(num)))
++++Dim+result(nDigits+-+1)+As+Integer

++++For+a+As+Integer+=+1+To+nDigits
++++++++result(a+-+1)+=+Int(num+/+(10+%5E+(nDigits+-+a)))+Mod+10
++++Next|code-block|syntax|javascript|431681|**编辑**|431682|修改了函数，因为指数似乎非常昂贵。|431683|Private+Function+Calc(ByVal+num+As+Integer)+As+Integer()
++++Dim+nDigits+As+Int64+=+1+%2B+Convert.ToInt64(Math.Floor(Math.Log10(num)))
++++Dim+result(nDigits+-+1)+As+Integer
++++Dim+place+As+Integer+=+1

++++For+a+As+Integer+=+1+To+nDigits
++++++++result(nDigits+-+a)+=+Int(num+/+place)+Mod+10
++++++++place+=+place+*+10
++++Next

++++Return+result
End+Function|431684|这一基准测试大约为775k/秒(对于9位或更少的数字)。将最大位数降至7，它将以885k/s的速度工作。5位数以1.1m/s的速度工作。|431685|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I haven't benchmarked this or anything, but I think this would be the simplest answer. Correct me if I'm wrong.

<pre><code> Dim num As Integer = 147483647
 Dim nDigits As Integer = 1 + Convert.ToInt32(Math.Floor(Math.Log10(num)))
 Dim result(nDigits - 1) As Integer

 For a As Integer = 1 To nDigits
 result(a - 1) = Int(num / (10 ^ (nDigits - a))) Mod 10
 Next
</code></pre>

** EDIT **

Revised the function because exponents seem to be very expensive.

<pre><code>Private Function Calc(ByVal num As Integer) As Integer()
 Dim nDigits As Int64 = 1 + Convert.ToInt64(Math.Floor(Math.Log10(num)))
 Dim result(nDigits - 1) As Integer
 Dim place As Integer = 1

 For a As Integer = 1 To nDigits
 result(nDigits - a) = Int(num / place) Mod 10
 place = place * 10
 Next

 Return result
End Function
</code></pre>

This benchmarks to around 775k/sec (for numbers 9 digits or less). Drop the maximum digits to 7 and it benches at 885k/s. 5 digits at 1.1m/s.

blocks|key|331267|text|根据我的测试，每次分配一个新的int[]都会占用大量的时间。如果您知道这些值将被使用一次，并在下一次调用之前被丢弃，那么您可以改为重用静态数组来显著提高速度：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|331268|++++private+static+readonly+int[]+_buffer+=+new+int[10];
++++public+static+int[]+ConvertToArrayOfDigits(int+value)
++++{
++++++++for+(int+index+=+9;+index+>=+0;+index--)
++++++++{
++++++++++++_buffer[index]+=+value+%25+10;
++++++++++++value+=+value+/+10;
++++++++}
++++++++return+_buffer;
++++}|code-block|syntax|javascript|331269|为了保持代码较小，我为较小的数字返回尾随零，但这可以通过使用9个不同的静态数组(或一个数组数组)轻松地更改。|331270|或者，可以提供两个独立的ConvertToArrayOfDigits方法，一个接受预先创建的整数数组作为额外参数，另一个不接受在调用第一个方法之前创建结果缓冲区的方法。|331271|++++public+static+void+ConvertToArrayOfDigits(int+value,+int[]+digits)+{+...+}
++++public+static+int[]+ConvertToArrayOfDigits(int+value)
++++{
++++++++int+size+=+DetermineDigitCount(value);
++++++++int[]+digits+=+new+int[size];
++++++++ConvertToArrayOfDigits(value,+digits);
++++++++return+digits;
++++}|331272|这样，如果他们的用例允许的话，它将由调用者潜在地创建一个静态的可重用缓冲区。|331273|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

The allocation of a new int[] every time takes up a significant amount of the time according to my testing. If you know these values will be used once and thrown away before the next call, you could instead reuse a static array for a significant speed improvement:

<pre><code> private static readonly int[] _buffer = new int[10];
 public static int[] ConvertToArrayOfDigits(int value)
 {
 for (int index = 9; index &gt;= 0; index--)
 {
 _buffer[index] = value % 10;
 value = value / 10;
 }
 return _buffer;
 }
</code></pre>

to keep the code small, I am returning trailing zero's for smaller numbers, but this could easily be changed by using 9 different static arrays instead (or an array of arrays).

Alternatively, 2 seperate ConvertToArrayOfDigits methods could be provided, one taking a precreated int array as an extra parameter, and one without that which creates the resulting buffer prior to calling the first method.

<pre><code> public static void ConvertToArrayOfDigits(int value, int[] digits) { ... }
 public static int[] ConvertToArrayOfDigits(int value)
 {
 int size = DetermineDigitCount(value);
 int[] digits = new int[size];
 ConvertToArrayOfDigits(value, digits);
 return digits;
 }
</code></pre>

This way, it would be up to the caller to potentially create a static reusable buffer if their usecase allows for it.

I want to separate the digits of an integer, say 12345, into an array of bytes {1,2,3,4,5}, but I want the most performance effective way to do that, because my program does that millions of times.

Any suggestions? Thanks.

Fastest way to separate the digits of an int into an array in .NET?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想把一个整数的数字，比如12345，分成一个字节数组{1,2,3,4,5}，但是我想要的是最有效的性能方法，因为我的程序会几百万次这样做。有什么建议吗？谢谢。

问在.NET中，将整数的数字分隔到数组中的最快方法是什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在.NET中，将整数的数字分隔到数组中的最快方法是什么？EN