Schnellster Weg, um die Ziffern einer int in ein Array in NET zu trennen?
https://stackoverflow.com/questions/1613317
-
06-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Ich möchte die Ziffern einer ganzen Zahl trennen, sagen 12345, in ein Array von Bytes {1,2,3,4,5}, aber ich möchte die Leistung effektiver Weg, das zu tun, weil mein Programm tut, Millionen mal.
Irgendwelche Vorschläge? Danke.
Lösung
Wie wäre:
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 % 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;
}
Beachten Sie, dass dies nicht mit negativen Zahlen fertig zu werden ... Sie brauchen es?
EDIT: Hier ist eine Version, die die Ergebnisse für unter 10000 memoizes, wie Eric vorgeschlagen. Wenn Sie absolut garantieren , dass Sie nicht den Inhalt des zurückgegebenen Arrays ändern wird, könnten Sie den Clone Anruf entfernen. Es hat auch die praktische Eigenschaft die Anzahl der Kontrollen reduziert die Länge der „großen“ Zahlen zu bestimmen - und kleine Zahlen werden nur einmal auf jeden Fall durch diesen Code gehen:)
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 % 10;
value = value / 10;
}
return digits;
}
Beachten Sie, dass diese nicht versuchen, Thread-sicher im Moment zu sein. Möglicherweise müssen Sie eine Speicherbarriere hinzufügen, um sicherzustellen, dass das Schreiben in die memoized Ergebnisse nicht sichtbar ist, bis die Schreibvorgänge im Einzelergebnis sichtbar sind. Ich habe es aufgegeben, diese Dinge zur Vernunft zu, wenn ich nicht unbedingt haben. Ich bin sicher, Sie können es mit Mühe sperren frei machen, aber Sie sollten wirklich jemand bekommen sehr intelligent , dies zu tun, wenn Sie wirklich benötigen.
EDIT: Ich habe gerade realisiert, dass der „große“ Fall der Verwendung des „kleinen“ Falles machen kann - teilen Sie die große Zahl in zwei Kabinetten und die memoised Ergebnisse verwenden. Ich gebe, dass ein zu gehen nach dem Abendessen und schreiben Sie eine Benchmark ...
EDIT: Okay, bereit für eine riesige Menge an Code? Ich erkennen, dass für gleichmäßig zufällig Zahlen zumindest, werden Sie „große“ Zahlen viel häufiger als kleine bekommen - so dass Sie für die Optimierung benötigen. Natürlich, das ist nicht der Fall für reale Daten sein könnte, aber trotzdem ... es bedeutet, dass ich meine Größe Tests in der umgekehrten Reihenfolge jetzt tun, zunächst für große Zahlen der Hoffnung.
Ich habe eine Benchmark für den originalen Code, der einfach memoization bekam, und dann wird der extrem-abgerollt Code.
Ergebnisse (in ms):
Simple: 3168
SimpleMemo: 3061
UnrolledMemo: 1204
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<int, int[]> candidate)
{
Random rng = new Random(0);
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < 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 >= 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 < 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) % 10,
(value / 10) % 10, value % 10 }
: value >= 100 ? new[] { value / 100, (value / 10) % 10,
value % 10 }
: value >= 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 >= 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 < 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 % 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 >= 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 >= 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 >= 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 >= 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 >= 1000 ? new[] { value / 1000, (value / 100) % 10,
(value / 10) % 10, value % 10 }
: value >= 100 ? new[] { value / 100, (value / 10) % 10,
value % 10 }
: value >= 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
}
Andere Tipps
1 + Math.Log10 (num) wird die Anzahl der Stellen ohne Suche / Looping geben:
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 > 0) {
byte digit = (byte) (num % 10);
digits[index] = digit;
num = num / 10;
index = index - 1;
}
return digits;
}
Edit: Möglicherweise hübschere:
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;
}
integer zu Zeichenfolge konvertieren und dann String.Chars verwenden []
Millionen Zeiten ist nicht so viel.
// input: int num >= 0
List<byte> digits = new List<byte>();
while (num > 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();
Beachten Sie, dass dies mit negativen Zahlen zu bewältigen geändert werden könnte, wenn Sie Byte für num != 0 sbyte und Test ändern.
'Will' vs 'Does'? Ich bin ein großer Fan Code zu optimieren, nachdem es geschrieben ist, profiliert, und es wird festgestellt, der Engpass sein.
Just for fun, hier ist ein Weg, um alle Ziffern zu trennen # Aussage mit nur einem C. Es funktioniert so:. Der reguläre Ausdruck verwendet die String-Version der Zahl, ihre Ziffern in einen String-Array spaltet auseinander, und schließlich die äußeree ConvertAll Methode erstellt einen int-Array aus dem String-Array
int num = 1234567890;
int [] arrDigits = Array.ConvertAll<string, int>(
System.Text.RegularExpressions.Regex.Split(num.ToString(), @"(?!^)(?!$)"),
str => int.Parse(str)
);
// resulting array is [1,2,3,4,5,6,7,8,9,0]
Effizienz-weise? ... Ich bin nicht sicher, im Vergleich zu einigen der anderen schnellen Antworten, die ich hier zu sehen. Jemand würde es testen.
Eine kleine Schleife Abrollen vielleicht?
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();
Durch die oben für die Log 10 thingy ..;)
Es ist schon die Rede von Benchmarking ...
ich die Schleifen vollständig abgerollt habe, und im Vergleich mit der akzeptierten memoized Variante von Jons, und ich bekomme eine konsequent schnelle Zeit mit diesem: -
static int[] ConvertToArrayOfDigits_unrolled(int num)
{
if (num < 10)
{
return new int[1]
{
(num % 10)
};
}
else if (num < 100)
{
return new int[2]
{
(num / 10 % 10),
(num % 10)
};
}
else if (num < 1000)
{
return new int[3] {
(num / 100 % 10),
(num / 10 % 10),
(num % 10)};
}
else if (num < 10000)
{
return new int[4] {
(num / 1000 % 10),
(num / 100 % 10),
(num / 10 % 10),
(num % 10)};
}
else if (num < 100000)
{
return new int[5] {
(num / 10000 % 10),
(num / 1000 % 10),
(num / 100 % 10),
(num / 10 % 10),
(num % 10)};
}
else if (num < 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 < 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 < 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 < 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)};
}
}
Es kann ich irgendwo verkorkste sein habe - ich habe nicht viel Zeit für Spiel und Spaß haben, aber ich war Timing dies als 20% schneller
.Wenn Sie mit führenden Nullen erhalten, indem können, ist es viel einfacher.
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; ++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 < 10; ++i)
{
digits[10 - i - 1] = val % 10;
val /= 10;
}
}
EDIT: Hier ist eine schnellere Version. Auf meinem Computer getestet es schneller als zwei von Jon Skeet-Algorithmen, mit Ausnahme seiner memoized Version:
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;
}
divide und mod neigen langsam Operationen zu sein. Ich wollte herausfinden, ob eine Lösung mehrfach mit und Subtraktion wäre schneller und es scheint zu sein (auf meinem Computer):
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;
}
}
ich in einem Array bin vorbei, anstatt sie jedes Mal der Verteilung der Speicherzuordner und Länge aus der Gleichung heraus zu nehmen. Diese Version wird führende Nullen erzeugen, wenn das Array länger ist als die Zahl ist. Im Vergleich zu einer ähnlich konvertierte Version von Jons Beispiel:
public static void ConvertToArrayOfDigits(int value, int[] digits){
for (int index = digits.Length - 1; index >= 0; index--) {
digits[index] = value % 10;
value = value / 10;
}
}
die keine Trennung / mod Version etwa 50 mehr Zeit in Anspruch nahm, alle Anordnungen zu erzeugen, bis zu einer bestimmten Anzahl. Ich habe auch versucht schwimmt und es war nur etwa 5-10% langsamer (die Doppel-Version war schneller als die Schwimmer-Version) verwendet wird.
Nur weil es mich stört, ist hier eine abgerollt Version, die schneller gerade wieder leicht ist:
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;
}
}
Die Zuweisung eines neuen int [] nimmt jedes Mal eine erhebliche Menge der Zeit, bis nach meinen Tests. Wenn Sie diese Werte kennen, bevor das nächste Gespräch einmal geworfen werden entfernt, könnte man stattdessen ein statisches Array für eine signifikante Verbesserung der Geschwindigkeit wiederverwendet werden:
private static readonly int[] _buffer = new int[10];
public static int[] ConvertToArrayOfDigits(int value)
{
for (int index = 9; index >= 0; index--)
{
_buffer[index] = value % 10;
value = value / 10;
}
return _buffer;
}
Sie den Code klein zu halten, ich bin wieder für kleinere Zahlen Nullen Hinter, aber dies leicht mit 9 verschiedenen statischen Arrays anstelle geändert werden könnte (oder ein Array von Arrays).
Alternativ 2 seperate ConvertToArrayOfDigits Methoden könnten vorgesehen werden, man eine precreated int array als zusätzliche Parameter genommen wird, und eine ohne dass die die sich ergebende Puffer vor dem Aufruf des ersten Verfahrens erzeugt.
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;
}
Auf diese Weise würde es den Anrufer sein, um möglicherweise einen statischen wieder verwendbaren Puffer zu erstellen, wenn ihre usecase es zulässt.
Ich habe nicht dieses oder irgendetwas gebenchmarkt, aber ich denke, das ist die einfachste Antwort wäre. Korrigieren Sie mich, wenn ich falsch bin.
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
** EDIT **
überarbeitete die Funktion, weil Exponenten scheinen sehr teuer zu sein.
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
Dieses Benchmarks auf rund 775k / sec (Nummern 9 Ziffern oder weniger). Lassen Sie die maximalen Ziffern 7 und Bänke bei 885k / s. 5 Stellen bei 1,1m / s.
