Как извлечь каждую цифру из числа?

Question

Это не домашнее задание.Все, что я могу придумать, - это многократно делить число на 10 (пока число не станет меньше 10) и вести счет, но есть ли хитрость для такого рода вещей?

Answer 1

Да, у вас в значительной степени есть математический способ сделать это прямо там.

while (num >= 10)
    digit = num MOD 10   // and save this into an array or whatever
    num = num / 10

в конце этого, num будет содержать последнюю цифру.

Вот реализация Javascript:

function getDigits(num) {
    var digits = [];
    while (num >= 10) {
        digits.unshift(num % 10);
        num = Math.floor(num / 10);
    }
    digits.unshift(num);
    return digits;
}

Обратите внимание, что это работает только для неотрицательных целых чисел.

Answer 2

Зачем реализовывать преобразование самостоятельно, когда уже есть очень надежный способ сделать это?(И поскольку это не домашняя работа).

В псевдо-C:

char digits[10];
sprintf(digits, "%d", number);

Теперь ваш массив цифр (строка) должен состоять из каждой цифры числа.Большинство других языков сценариев также содержат функцию sprintf.

Это будет работать, если вы хотите использовать base 8 или base 16 или двоичный файл и т. Д. Просто используйте другой спецификатор формата.

Answer 3

Математический ответ - изменить на 10 и добавить каждый результат в список, а затем изменить порядок в списке.Вот основной алгоритм C #, который будет делать это:

List<byte> digits = new List<byte>();

while(number > 10)
{
   digits.Add(number % 10);
   number %= 10;
}
//add the last digit
digits.Add(number);

byte temp;
for(var i=0;i<digits.Count/2;i++)
{
   temp = digits[i];
   digits[i] = digits[digits.Count-(i+1)];
   digits[digits.Count-(i+1)] = temp;
}

Другие «трюки» обычно включают преобразование строк.Вот одна строчка C # с использованием Linq, которая даст тот же результат, что и выше:

var digits = number.ToString().Select(c=>byte.Parse(c)).ToList();

Answer 4

Python-код, использующий ваш подход:

def digits(n):
  ds = []
  while n > 0:
    ds.append(n % 10)
    n /= 10
  ds.reverse()
  return ds

Использование преобразования в строку:

def digits(n):           
  return map(int, str(n))

Answer 5

Более эффективный алгоритм, если ваши входные числа могут быть большими, состоит в делении на степень 10, скажем 1000, и использовании справочной таблицы:

s = ""; // or use a string builder appropriate to your language...
table = {"000", "001", ..., "999"};
tableInitial = {"unused", "1", "2", ..., "9", "10", ..., "999"};
while(n >= 1000) {
  m = n%1000;
  n /= 1000;
  s = table[m] + s;
}
s = tableInitial[n] + s;

Answer 6

Если это целое число, вы можете преобразовать строковое представление в массив символов, а затем преобразовать его в массив байтов (0-9)

Answer 7

JavaScript:

function digits(num) {
  return String(num).split('').map(v => +v);
}

Answer 8

Следующая программа также будет работать.

public class Main {
    public static void main(String[] args) {
        int i1 =123456;
        String s =new StringBuilder(String.valueOf(i1)).toString();
        char a[]=s.toCharArray();
        for(char c : a) {
            Integer i = Integer.parseInt(c+"");
            System.out.println(i);
        }
    }
}

Answer 9

Не уверен, правильно ли я понял, что вы хотите ...

Подойдет ли вам следующее? Это написано на C # ...

public static List<int> ExtractDigit()
{
    // Input example
    int number = 12345;

    // Convert Integer to string   
    string numberedString = number.ToString();

    // Create a list of integers
    var numList = new List<int>();

    // Convert each character in string back to int and add to list.
    foreach (char c in numberedString)
    {
        numList.Add(Convert.ToInt32(c.ToString()));
    }

    return numList;
}

Надеюсь, я вам помог.

Answer 10

Вот функции обратимого массива в JavaScript, которые обрабатывают целые числа или строки:

function reverse(array)
{
    var left = null;
    var right = null;
    var length = array.length;
    for (left = 0, right = length - 1; left < right; left += 1, right -= 1)
    {
        var temporary = array[left];
        array[left] = array[right];
        array[right] = temporary;
    }
    return array;
}

function toDigitsArrayFromInteger(integer, isReverse)
{
    var digits = [];

    if (integer > 0)
    {
        var floor = window.Math.floor;
        while (integer > 0)
        {
            digits.push(floor(integer % 10));
            integer = floor(integer / 10);
        }

        // Array is populated in reverse order. Un-reverse it to make it normal.
        if (!isReverse)
        {
            digits = reverse(digits);
        }
    }
    else if (integer < 0)
    {
        digits = toDigitsArrayFromInteger(-integer, isReverse);
    }
    else if (integer === 0)
    {
        digits.push(0);
    }

    return digits;
}

function toDigitsArrayFromString(string, isReverse)
{
    var digits = [];

    string += ""; // Coerce to string.

    var i = null;
    var length = string.length;
    for (i = 0; i < length; i += 1)
    {
        var integer = parseInt(string.charAt(i), 10);
        if (isFinite(integer))
        {
            digits.push(integer);
        }
    }

    if (isReverse)
    {
        digits = reverse(digits);
    }

    return digits;
}

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

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

Тесты: http://jsperf.com/todigitsarray

Сравнительные тесты между двумя функциями показывают, что в Firefox 10 и Chrome 12 строковая функция на 30–60% быстрее, чем целочисленная функция.В Opera 12 целочисленная функция немного быстрее примерно на 10%.