text panel java

¿Cómo obtener los dígitos separados de un número int?

Question

Tengo números como 1100, 1002, 1022, etc. Me gustaría tener los dígitos individuales, por ejemplo, para el primer número 1100 quiero tener 1, 1, 0, 0.

¿Cómo puedo obtenerlo en Java?

Answer 1

¿Qué tal esto?

public static void printDigits(int num) {
    if(num / 10 > 0) {
        printDigits(num / 10);
    }
    System.out.printf("%d ", num % 10);
}

o en lugar de imprimir en la consola, podemos recopilarla en una matriz de enteros y luego imprimir la matriz:

public static void main(String[] args) {
    Integer[] digits = getDigits(12345);
    System.out.println(Arrays.toString(digits));
}

public static Integer[] getDigits(int num) {
    List<Integer> digits = new ArrayList<Integer>();
    collectDigits(num, digits);
    return digits.toArray(new Integer[]{});
}

private static void collectDigits(int num, List<Integer> digits) {
    if(num / 10 > 0) {
        collectDigits(num / 10, digits);
    }
    digits.add(num % 10);
}

Answer 2

Algo como esto devolverá el char[] :

public static char[] getTheDigits(int value){
    String str = "";
    int number = value;
    int digit = 0;
    while(number>0){
        digit = number%10;
        str = str + digit;
        System.out.println("Digit:" + digit);
        number = number/10;     

    }
    return str.toCharArray();
}

Answer 3

Aquí está mi respuesta, lo hice por mí mismo y espero que sea lo suficientemente simple para aquellos que no quieran usar el enfoque String o necesiten una solución matemática más:

public static void reverseNumber2(int number) {

    int residual=0;
    residual=number%10;
    System.out.println(residual);

    while (residual!=number)  {
          number=(number-residual)/10;
          residual=number%10;
          System.out.println(residual);
    }
}

Así que acabo de obtener las unidades, imprimirlas, restarlas del número, luego dividir ese número por 10, que siempre es sin elementos flotantes, ya que las unidades se han ido, repita.

Answer 4

Como no veo un método en esta pregunta que use Java 8, lo incluiré. Suponiendo que empiezas con un String y quieres obtener un List<Integer> , entonces puedes transmitir los elementos como así .

List<Integer> digits = digitsInString.chars().map(Character::getNumericValue)
                            .collect(Collectors.toList());

Esto obtiene los caracteres en String como IntStream , asigna esas representaciones enteras de caracteres a un valor numérico y luego los recopila en una lista.

Answer 5

Convierta a String y use String#toCharArray() o String#split() .

String number = String.valueOf(someInt);

char[] digits1 = number.toCharArray();
// or:
String[] digits2 = number.split("(?<=.)");

En caso de que ya esté en Java 8 y desee realizar algunas operaciones agregadas posteriormente, considere usar String#chars() para obtener un IntStream fuera de él.

IntStream chars = number.chars();

Answer 6

Creo que esta será la forma más útil de obtener dígitos:

public int[] getDigitsOf(int num)
{        
    int digitCount = Integer.toString(num).length();

    if (num < 0) 
        digitCount--;           

    int[] result = new int[digitCount];

    while (digitCount-- >0) {
        result[digitCount] = num % 10;
        num /= 10;
    }        
    return result;
}

Entonces puedes obtener los dígitos de una manera simple:

int number = 12345;
int[] digits = getDigitsOf(number);

for (int i = 0; i < digits.length; i++) {
    System.out.println(digits[i]);
}

o más simplemente:

int number = 12345;
for (int i = 0; i < getDigitsOf(number).length; i++) {
    System.out.println(  getDigitsOf(number)[i]  );
}

Tenga en cuenta que el último método llama demasiado al método getDigitsOf. Entonces será más lento. Debería crear una matriz int y luego llamar al método getDigitsOf una vez, al igual que en el segundo bloque de código.

En el siguiente código, puede invertir para procesar. Este código junta todos los dígitos para hacer el número:

public int digitsToInt(int[] digits)
{
    int digitCount = digits.length;
    int result = 0;

    for (int i = 0; i < digitCount; i++) {
        result = result * 10;
        result += digits[i];
    }

    return result;
}

Ambos métodos que he proporcionado también funcionan para números negativos.

Answer 7

Escribí un programa que demuestra cómo separar los dígitos de un entero usando un enfoque más simple y comprensible que no involucra arreglos, recurrencias y toda esa fantasia sofisticada. Aquí está mi código:

int year = sc.nextInt(), temp = year, count = 0;

while (temp>0)
{
  count++;
  temp = temp / 10;
}

double num = Math.pow(10, count-1);
int i = (int)num;

for (;i>0;i/=10)
{
  System.out.println(year/i%10);
}

Suponga que su entrada es el número entero 123 , la salida resultante será la siguiente:

1
2
3

Answer 8

Esto usa el método del módulo 10 para descubrir cada dígito en un número mayor que 0, luego esto invertirá el orden de la matriz. Esto supone que no estás usando "0" como dígito inicial.

Esto se modifica para recibir la entrada del usuario. Esta matriz está originalmente insertada hacia atrás, así que tuve que usar la llamada Collections.reverse() para volver a colocarla en el orden del usuario.

    Scanner scanNumber = new Scanner(System.in);
    int userNum = scanNumber.nextInt(); // user''s number

    // divides each digit into its own element within an array
    List<Integer> checkUserNum = new ArrayList<Integer>();
    while(userNum > 0) {
        checkUserNum.add(userNum % 10);
        userNum /= 10;
    }

    Collections.reverse(checkUserNum); // reverses the order of the array

    System.out.print(checkUserNum);

Answer 9

La manera más fácil, creo, es convertir el número a cadena y usar la substring para extraer y luego convertir a entero.

Algo como esto:

int digits1 =Integer.parseInt( String.valueOf(201432014).substring(0,4));
    System.out.println("digits are: "+digits1);

la salida es 2014

Answer 10

No he visto a nadie usar este método, pero funcionó para mí y es breve y dulce:

int num = 5542;
String number = String.valueOf(num);
for(int i = 0; i < number.length(); i++) {
    int j = Character.digit(number.charAt(i), 10);
    System.out.println("digit: " + j);
}

Esto dará como resultado:

digit: 5
digit: 5
digit: 4
digit: 2

Answer 11

Noté que hay pocos ejemplos de cómo usar Java 8 para resolver su problema, pero creo que este es el más simple:

int[] intTab = String.valueOf(number).chars().map(Character::getNumericValue).toArray();

Para que quede claro: String.valueOf(number) para convertir int a String, luego el método chars() para obtener un IntStream (cada char de tu cadena es ahora un número Ascii), entonces necesitas ejecutar el método map() para obtener un valor numérico del número Ascii. Al final, utilizas el método toArray() para cambiar tu flujo en una matriz int [].

Answer 12

Prueba esto:

int num= 4321
int first  =  num % 10;
int second =  ( num - first ) % 100 / 10;
int third  =  ( num - first - second ) % 1000 / 100;
int fourth =  ( num - first - second - third ) % 10000 / 1000;

Obtendrás primero = 1, segundo = 2, tercero = 3 y cuarto = 4 ...

Answer 13

Solo para construir sobre el tema, he aquí cómo confirmar que el número es un entero palindrómico en Java:

public static boolean isPalindrome(int input) {
List<Integer> intArr = new ArrayList();
int procInt = input;

int i = 0;
while(procInt > 0) {
    intArr.add(procInt%10);
    procInt = procInt/10;
    i++;
}

int y = 0;
int tmp = 0;
int count = 0;
for(int j:intArr) {
    if(j == 0 && count == 0) {
    break;
    }

    tmp = j + (tmp*10);
    count++;
}

if(input != tmp)
    return false;

return true;
}

Estoy seguro de que puedo simplificar este algo más. Sin embargo, aquí es donde estoy. Y ha funcionado en todos mis casos de prueba.

Espero que esto ayude a alguien.

Answer 14

Solución Java 8 para obtener dígitos como int [] de un entero que tiene como cadena:

int[] digits = intAsString.chars().map(i -> i - ''0'').toArray();

Answer 15

en Java, así es como puede separar los dígitos de los números y almacenarlos en una matriz.

public static void main(String[] args) {
        System.out.println("Digits Array:: "+Arrays.toString(getNumberArr(1100)));
}

private static Integer[] getNumberArr(int number) {
    //will get the total number of digits in the number
    int temp = number;
    int counter = 0;

    while (temp > 0) {
        temp /= 10;
        counter++;
    }
    //reset the temp
    temp = number;

    // make an array
    int modulo;     //modulo is equivalent to single digit of the number.
    Integer[] numberArr = new Integer[counter];
    for (int i = counter - 1; i >= 0; i--) {
        modulo = temp % 10;
        numberArr[i] = modulo;  
        temp /= 10;
    }

    return numberArr;
}

Salida:

Digits Array:: [1, 1, 0, 0]

Answer 16

ver abajo mi propuesta con comentarios

          int size=i.toString().length(); // the length of the integer (i) we need to split;
           ArrayList<Integer> li = new ArrayList<Integer>(); // an ArrayList in whcih to store the resulting digits

        Boolean b=true; // control variable for the loop in which we will reatrive step by step the digits
        String number="1"; // here we will add the leading zero depending on the size of i
        int temp;  // the resulting digit will be kept by this temp variable

    for (int j=0; j<size; j++){
                        number=number.concat("0");
                    }

Integer multi = Integer.valueOf(number); // the variable used for dividing step by step the number we received 
                while(b){

                    multi=multi/10;
                    temp=i/(multi);
                    li.add(temp);
                    i=i%(multi);
                                        if(i==0){
                                        b=false;
                                        }


                }

                for(Integer in: li){
                    System.out.print(in.intValue()+ " ");
                }

Answer 17

Integer.toString (1100) le da el número entero como una cadena. Integer.toString (1100) .getBytes () para obtener una matriz de bytes de los dígitos individuales.

Editar:

Puede convertir los dígitos de los caracteres en dígitos numéricos, por lo tanto:

  String string = Integer.toString(1234);
  int[] digits = new int[string.length()];

  for(int i = 0; i<string.length(); ++i){
    digits[i] = Integer.parseInt(string.substring(i, i+1));
  }
  System.out.println("digits:" + Arrays.toString(digits));

Answer 18

Para hacer esto, usará el operador % (mod).

int number; // = some int

while (number > 0) {
    print( number % 10);
    number = number / 10;
}

El operador de mod le dará el resto de la división int en un número.

Asi que,

10012 % 10 = 2

Porque:

10012 / 10 = 1001, remainder 2

Nota: Como señaló Paul, esto le dará los números en orden inverso. Tendrá que empujarlos a una pila y abrirlos en orden inverso.

Código para imprimir los números en el orden correcto:

int number; // = and int
LinkedList<Integer> stack = new LinkedList<Integer>();
while (number > 0) {
    stack.push( number % 10 );
    number = number / 10;
}

while (!stack.isEmpty()) {
    print(stack.pop());
}

Answer 19

// could be any num this is a randomly generated one
int num = (int) (Math.random() * 1000);

// this will return each number to a int variable
int num1 = num % 10;
int num2 = num / 10 % 10;
int num3 = num /100 % 10;

// you could continue this pattern for 4,5,6 digit numbers
// dont need to print you could then use the new int values man other ways
System.out.print(num1);
System.out.print("/n" + num2);
System.out.print("/n" + num3);

Answer 20

import java.util.Scanner;

class  Test 
{  
    public static void main(String[] args)   
    {  
        Scanner sc = new Scanner(System.in); 


    int num=sc.nextInt(); 
    System.out.println("Enter a number (-1 to end):"+num);
    int result=0;
    int i=0;
    while(true) 
    { 
      int n=num%10;
      if(n==-1){
        break;
      }
      i++;
      System.out.println("Digit"+i+" = "+n);
      result=result*10+n;
      num=num/10; 


      if(num==0) 
      { 
        break; 
      } 
    }
    }
}

Answer 21

import java.util.Scanner;

public class SeparatingDigits {

    public static void main( String[] args )
    {

        System.out.print( "Enter the digit to print separately :- ");
        Scanner scan = new Scanner( System.in );

        int element1 = scan.nextInt();
        int divider;

        if( ( element1 > 9999 ) && ( element1 <= 99999 ) )
        {
            divider = 10000;
        }
        else if( ( element1 > 999 ) && ( element1 <= 9999 ) )
        {
            divider = 1000;
        }
        else if ( ( element1 > 99) && ( element1 <= 999 ) )
        {
            divider = 100;
        }
        else if( ( element1 > 9 ) && ( element1 <= 99 ) )
        {
            divider = 10;
        }
        else 
        {
            divider = 1;
        }

        quotientFinder( element1, divider );




    }

     public static void quotientFinder( int elementValue, int dividerValue )
     {
         for( int count = 1;  dividerValue != 0; count++)
         {
            int quotientValue = elementValue / dividerValue ;
            elementValue = elementValue % dividerValue ;
            System.out.printf( "%d  ", quotientValue );

            dividerValue /= 10;

         }
     }
    }

Sin usar matrices y cadenas. (dígitos 1-99999)

salida:

Ingrese el dígito para imprimir por separado: 12345

1 2 3 4 5

Answer 22

int number = 12344444; // or it Could be any valid number

int temp = 0;
int divider = 1;

for(int i =1; i< String.valueOf(number).length();i++)
 {

    divider = divider * 10;

}

while (divider >0) {

    temp = number / divider;
    number = number % divider;
    System.out.print(temp +" ");
    divider = divider/10;
}

Answer 23

public int[] getDigitsOfANumber(int number) {
    String numStr = String.valueOf(number);
    int retArr[] = new int[numStr.length()];

    for (int i = 0; i < numStr.length(); i++) {
        char c = numStr.charAt(i);
        int digit = c;
        int zero = (char) ''0'';
        retArr[i] = digit - zero;

    }
    return retArr;
}