Integer to Integer Array C #

Question

Мне пришлось разделить int "123456" каждое его значение на Int [], и у меня уже есть решение, но я не знаю, есть ли лучший способ: Мое решение было:

public static int[] intToArray(int num){
    String holder = num.ToString();
    int[] numbers = new int[Holder.ToString().Length]; 
    for(int i=0;i<numbers.length;i++){
        numbers[i] = Convert.toInt32(holder.CharAt(i));
    }
    return numbers;
}

Answer 1

Простое решение с использованием LINQ

 int[] result = yourInt.ToString().Select(o=> Convert.ToInt32(o)).ToArray()

Answer 2

Я считаю, что это будет лучше, чем конвертировать туда и обратно.В отличие от ответа JBSnorro, я переворачиваюсь после преобразования в массив и поэтому избегаю IEnumerable, что, я думаю, будет способствовать немного более быстрому коду.Этот метод работает для неотрицательных чисел, поэтому 0 вернет new int[1] { 0 }.

Если он будет работать для отрицательных чисел, вы могли бы сделать n = Math.Abs(n), но я не думаю, что это имеет смысл.

Кроме того, если бы он был более производительным, я мог бы создать окончательный массив для начала, сделав комбинацию операторов if в виде бинарного поиска, чтобы определить количество цифр.

public static int[] digitArr(int n)
{
    if (n == 0) return new int[1] { 0 };

    var digits = new List<int>();

    for (; n != 0; n /= 10)
        digits.Add(n % 10);

    var arr = digits.ToArray();
    Array.Reverse(arr);
    return arr;
}

Обновление 2018:

public static int numDigits(int n) {
    if (n < 0) {
        n = (n == Int32.MinValue) ? Int32.MaxValue : -n;
    }
    if (n < 10) return 1;
    if (n < 100) return 2;
    if (n < 1000) return 3;
    if (n < 10000) return 4;
    if (n < 100000) return 5;
    if (n < 1000000) return 6;
    if (n < 10000000) return 7;
    if (n < 100000000) return 8;
    if (n < 1000000000) return 9;
    return 10;
}

public static int[] digitArr2(int n)
{
    var result = new int[numDigits(n)];
    for (int i = result.Length - 1; i >= 0; i--) {
        result[i] = n % 10;
        n /= 10;
    }
    return result;
}

Answer 3

int[] outarry = Array.ConvertAll(num.ToString().ToArray(), x=>(int)x);

но если вы хотите преобразовать его в 1,2,3,4,5:

int[] outarry = Array.ConvertAll(num.ToString().ToArray(), x=>(int)x - 48);

Answer 4

Использование преобразования из int в строку и обратно, вероятно, не так быстро. Я бы использовал следующее

public static int[] ToDigitArray(int i)
{
    List<int> result = new List<int>();
    while (i != 0)
    {
        result.Add(i % 10);
        i /= 10;
    }
    return result.Reverse().ToArray();
}

Я должен отметить, что это работает только для строго положительных целых чисел.

EDIT:

Я придумал альтернативу. Если производительность действительно является проблемой, это, вероятно, будет быстрее, хотя вы можете быть уверены, только проверив ее самостоятельно для своего конкретного использования и применения.

public static int[] ToDigitArray(int n)
{
    int[] result = new int[GetDigitArrayLength(n)];
    for (int i = 0; i < result.Length; i++)
    {
        result[result.Length - i - 1] = n % 10;
        n /= 10;
    }
    return result;
}
private static int GetDigitArrayLength(int n)
{
    if (n == 0)
        return 1;
    return 1 + (int)Math.Log10(n);
}

Это работает, когда n неотрицательно.

Answer 5

Я бы сделал это так:

var result = new List<int>();
while (num != 0) {
    result.Insert(0, num % 10);
    num = num / 10;
}
return result.ToArray();

Немного менее производительно, но, возможно, более элегантно:

return num.ToString().Select(c => Convert.ToInt32(c.ToString())).ToArray();

Обратите внимание, что оба возвращают 1,2,3,45,6 вместо 49,50,51,52,53,54 (т.е. байтовые коды для символов «1», «2», «3», «4», «5», «6») кактвой код делает.Я предполагаю, что это фактическое намерение?

Answer 6

У меня было похожее требование ... я взял много хороших идей и добавил пару недостающих частей ... где многие люди не обрабатывали нулевые или отрицательные значения.это то, что я придумал:

    public static int[] DigitsFromInteger(int n)
    {
        int _n = Math.Abs(n);
        int length = ((int)Math.Log10(_n > 0 ? _n : 1)) + 1;
        int[] digits = new int[length];
        for (int i = 0; i < length; i++)
        {
            digits[(length - i) - 1] = _n % 10 * ((i == (length - 1) && n < 0) ? -1 : 1);
            _n /= 10;
        }
        return digits;
    }

я думаю, что это довольно чисто ... хотя, это правда, что мы делаем условную проверку и несколько посторонних вычислений с каждой итерацией ... хотя я думаю, что онив этом случае вы можете оптимизировать шаг следующим образом:

    public static int[] DigitsFromInteger(int n)
    {
        int _n = Math.Abs(n);
        int length = ((int)Math.Log10(_n > 0 ? _n : 1)) + 1;
        int[] digits = new int[length];
        for (int i = 0; i < length; i++)
        {
            //digits[(length - i) - 1] = _n % 10 * ((i == (length - 1) && n < 0) ? -1 : 1);
            digits[(length - i) - 1] = _n % 10;
            _n /= 10;
        }
        if (n < 0)
            digits[0] *= -1;
        return digits;
    }

Answer 7

string DecimalToBase(int iDec, int numbase)
        {
            string strBin = "";
            int[] result = new int[32];
            int MaxBit = 32;
            for(; iDec > 0; iDec/=numbase)
            {
                int rem = iDec % numbase;
                    result[--MaxBit] = rem;
            } 
            for (int i=0;i<result.Length;i++)
                if ((int)result.GetValue(i) >= base10)
                    strBin += cHexa[(int)result.GetValue(i)%base10];
                else
                    strBin += result.GetValue(i);
            strBin = strBin.TrimStart(new char[] {'0'});
            return strBin;
        }
        int BaseToDecimal(string sBase, int numbase)
        {
            int dec = 0;
            int b;
            int iProduct=1;
            string sHexa = "";
            if (numbase > base10)
                for (int i=0;i<cHexa.Length;i++)
                    sHexa += cHexa.GetValue(i).ToString();
            for(int i=sBase.Length-1; i>=0; i--,iProduct *= numbase)
            {
                string sValue = sBase[i].ToString();
                if (sValue.IndexOfAny(cHexa) >=0)
                    b=iHexaNumeric[sHexa.IndexOf(sBase[i])];
                else 
                    b= (int) sBase[i] - asciiDiff;
                dec += (b * iProduct);
            } 
            return dec; 
        }

Answer 8

Вы можете сделать это без преобразования в строку и обратно:

public static int[] intToArray(int num) {
  List<int> numbers = new List<int>();
  do {
    numbers.Insert(0, num % 10);
    num /= 10;
  } while (num > 0);
  return numbers.ToArray();
}

Конечно, это работает только для положительных значений, но ваш исходный код также имеет это ограничение.

Answer 9

public static int[] intToArray(int num)
{
    num = Math.Abs(num);
    int length = num.ToString().Length;
    int[] arr = new int[length];
    do
    {
        arr[--length] = num % 10;
        num /= 10;
    } while (num != 0);

    return arr;
}

При делении на основание системы (в данном случае десятичное) удаляется самая правая цифра, и мы получаем эту цифру оператором остатка.Мы продолжаем повторять, пока не получим ноль.Каждый раз, когда удаляется цифра, она будет сохраняться в массиве, начиная с конца массива и обратно, чтобы избежать необходимости обращения массива в конце.Функция Math.Abs ​​() предназначена для обработки отрицательного ввода, также создается экземпляр массива с тем же размером, что и длина ввода.

Answer 10

Благодаря ASCII таблица символов . Простой ответ с использованием LINQ выше дает ответ + 48.

Либо

int[] result = youtInt.ToString().Select(o => Convert.ToInt32(o) - 48).ToArray();

или

int[] result = youtInt.ToString().Select(o => int.Parse(o.ToString())).ToArray();

можно использовать