¿Cómo extraer cada dígito de un número?

Question

Esta no es una pregunta para la tarea. Todo lo que puedo pensar es dividir el número repetidamente por 10 (hasta que el número sea menor a 10) y mantener un conteo, pero ¿hay algún truco para este tipo de cosas?

Answer 1

Si se trata de un número entero, podría convertir la representación de cadena en una matriz de caracteres, y luego convertir eso en una matriz de bytes (0-9)

Answer 2

Sí, que bastante tienen la forma matemática a hazlo allí mismo.

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

al final de este, num contendrá el último dígito.

Aquí hay una aplicación Javascript:

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

Tenga en cuenta que sólo funciona para los números enteros no negativos.

Answer 3

código Python usando su enfoque:

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

Usando convertation de cadena:

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

Answer 4

¿Por qué implementar la conversión a sí mismo cuando ya hay una forma muy fiable para hacerlo? (Y dado que no es tarea).

En pseudo-C:

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

Ahora sus dígitos matriz de caracteres (string) debe consistir de cada dígito del número. La mayoría de los otros lenguajes de scripting también contienen una función sprintf.

Esto funcionará si quiere base 8 o base 16 o binario, etc. Simplemente use un especificador de formato diferente.

Answer 5

La respuesta matemática es modificar por 10 y agregar cada resultado a una lista, luego invertir el orden de la lista. He aquí un C# algoritmo básico que va a hacer esto:

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; 
} 

Otros "trucos" por lo general implican una conversión de cadenas.He aquí un C# de una sola línea usando LINQ que dará el mismo resultado que el anterior:

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

Answer 6

un algoritmo más eficiente, si sus números de entrada pueden ser grandes, es dividir por una potencia de 10, por ejemplo 1000, y utilizar una tabla de búsqueda:

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 7

la solución pitón dado se podría optimizar adicionalmente usando

zerostr = ord('0') 
def digits(n): 
    return map(lambda x: ord(x)-zerostr, str(n)) 

De hecho, donde elLa conversiónestá probablemente optimizada, para obtener el valor numérico es mucho mejor usar el valor de carácter intrínseco de la cadena de dígitos, que en cada codificación (incluido EBCDIC) da el valor numérico mediante una resta int en lugar de un análisis str.

Answer 8

Aquí hay un arreglo de funciones reversibles en JavaScript que manejan números enteros o cadenas:

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; 
} 

Una vez que tenga los dígitos como una matriz, se puede revertir la matriz fácil de obtener los dígitos a partir de la izquierda o de la derecha

La función de cadena es más versátil porque puede encontrar cualquier dígito en una cadena, mientras que la función entera está limitada a enteros.

Puntos de referencia: http://jsperf.com/todigitsarray

Los puntos de referencia entre las dos funciones muestran que en Firefox 10 y Chrome 12, la función de cadena es de 30% a 60% más rápido que la función de número entero. En Opera 12, la función entera es ligeramente más rápida en aproximadamente un 10%.

Answer 9

No

segura de haber entendido correctamente lo que quiere ...

haría el siguiente trabajo para usted ?? Está escrito en 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; 
} 

Espero haber sido de ayuda.

Answer 10

El siguiente programa funcionaría también.

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 11

JavaScript:

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