Как получить отдельные цифры числа int?


155

У меня есть такие числа, как 1100, 1002, 1022 и т. Д. Я хотел бы иметь отдельные цифры, например, для первого числа 1100 я хочу иметь 1, 1, 0, 0.

Как я могу получить это на Java?

Ответы:


210

Для этого вы воспользуетесь %оператором (mod).

int number; // = some int

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

Оператор mod предоставит вам остаток от деления числа на int.

Так,

10012 % 10 = 2

Так как:

10012 / 10 = 1001, remainder 2

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

Код для печати чисел в правильном порядке:

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

4
Это приведет к тому, что числа будут расположены в неправильном порядке, поэтому вам нужно обязательно поместить их в стек или просто поместить в массив в обратном порядке.
Пол Томблин,

4
Обратите внимание, что это дает им направление справа налево. (Пример OP показывает их слева направо). Достаточно прост в обращении, но следует отметить.
Джеймс Карран

1
@ Дон, на практике нет. Я бы не одобрил этого. Однако это намного быстрее, чем версия на основе строк. Я бы посмотрел на ответ Маримуту, хотя бы для быстрого и короткого кода.
jjnguy 02

3
Отличное решение, но похоже, что оно не справляется со сценарием, когда число начинается с ведущих нулей. например - 001122. Если я воспользуюсь приведенной выше логикой, я получу только 1,1,2,2. Начальные нули удаляются% и / operations. Пожалуйста, поправьте меня, если я ошибаюсь.
goyalshub1509

2
как насчет отрицательных целых чисел здесь? если я пропущу -3432, вывод будет -2-3-4-3, что неверно.
Нодир Насиров

77

Преобразуйте его в Stringи используйте String#toCharArray()или String#split().

String number = String.valueOf(someInt);

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

В случае, если вы уже используете Java 8 и впоследствии захотите выполнить с ним некоторые агрегированные операции, подумайте об использовании, String#chars()чтобы выйти IntStreamиз этого.

IntStream chars = number.chars();

7
Это быстрый и грязный способ.
jjnguy 02

8
Если split("")первым элементом массива является "". Используйте другое регулярное выражение, например split("(?<=.)").
True Soft

3
toCharArray НАМНОГО быстрее, чем split. Я просто поместил оба цикла в цикл 1000 раз, и toCharArray занял 20 мс, а разделение заняло 1021 мс. Я также сделал это математически, используя разделение на десять с модулем (%), и это заняло 50 мсек, поэтому toCharArray кажется быстрее, чем два других.
Джерри Дестремпс

2
Изменить: я просто сделал это снова, на этот раз, чтобы быть уверенным, с более длинными циклами (10000 итераций). toCharArray примерно в 100 раз быстрее, чем split, а toCharArray примерно в 5 раз быстрее, чем математический метод модуля.
Джерри Дестремпс

9
@BalusC number.chars()вернет результат в виде значений Ascii, а не числовых. Таким образом, число «1234» будет разделено на «49», «50», «51», «52» вместо «1», «2», «3», «4». Чтобы все было правильно, он должен выглядеть так:IntStream chars = number.chars().map(Character::getNumericValue);
Коин Араб

31

Как насчет этого?

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

или вместо вывода на консоль мы можем собрать его в массив целых чисел и затем распечатать массив:

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

Если вы хотите сохранить порядок цифр от наименее значимого (индекс [0]) до наиболее значимого (индекс [n]), вам понадобится следующий обновленный getDigits ():

/**
 * split an integer into its individual digits
 * NOTE: digits order is maintained - i.e. Least significant digit is at index[0]
 * @param num positive integer
 * @return array of digits
 */
public static Integer[] getDigits(int num) {
    if (num < 0) { return new Integer[0]; }
    List<Integer> digits = new ArrayList<Integer>();
    collectDigits(num, digits);
    Collections.reverse(digits);
    return digits.toArray(new Integer[]{});
}

1
Это хороший способ распечатать вещи в правильном порядке с помощью мода. +1
jjnguy 02

1
Это прекрасно. Я подумал: «Должен быть способ изменить порядок без использования Коллекции ....» +1
bobndrew

Безупречный. Возможно, вы захотите добавить следующий код в getDigits (int num), чтобы сделать его невосприимчивым к неверным входным данным: if (number < 0) { return new Integer[0]; } Протестировано со следующими входными данными:Integer[] samples = {11111, 123457, 0, -13334, 93846, 87892, 9876543, -1234, 012455};
realPK

24

Я не видел, чтобы кто-нибудь использовал этот метод, но он сработал для меня и краток и приятен:

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

Это выведет:

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

Это потрясающе. Спасибо
Marwa Eltayeb

По какой-то причине эта логика дает неправильный вывод для чисел, отличных от 5542. Попробуйте, например: 0142323
tavalendo

@tavalendo 0142323- это восьмеричная константа, равная 50387из-за ведущего нуля, точно так же, как 0x100шестнадцатеричная константа, равная 256из-за начала 0x, и 0b1011двоичная константа, равная 11из-за ведущего 0b. Остерегайтесь начинать нули в целочисленных константах!
AJNeufeld 03

12

Я заметил, что есть несколько примеров использования потока Java 8 для решения вашей проблемы, но я думаю, что это самый простой:

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

Чтобы быть ясным: вы используете String.valueOf(number)для преобразования int в String, затем chars()метод для получения IntStream (каждый char из вашей строки теперь является числом Ascii), затем вам нужно запустить map()метод для получения числовых значений числа Ascii. В конце вы используете toArray()метод для преобразования вашего потока в массив int [].


11

Я вижу, что все ответы уродливы и не очень чисты.

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

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

Выход:

Input: 12345

Output: 1   2   3   4   5 

Черт возьми, ты о том, что ответы некрасивы Спасибо.
парсер

6
// 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);

Ява Тип int имеет минимальное значение -2 ^ 31 и максимальное значение 2 ^ 31-1. Как вышеуказанное решение может работать для всех значений + ve, которые подходят для типа int?
realPK 04

4

простое решение

public static void main(String[] args) {
    int v = 12345;
    while (v > 0){
        System.out.println(v % 10);
        v /= 10;
    }
}

3

Я думаю, что более простой способ - преобразовать число в строку и использовать substring для извлечения, а затем преобразовать в целое число.

Что-то вроде этого:

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

выпуск 2014


здесь преобразование типов будет стоить дороже или операции разделения?
Рахул

3

В Java 9 появился новый Stream.iterateметод, который можно использовать для генерации потока и остановки при определенном условии. Это можно использовать для получения всех цифр числа, используя подход по модулю.

int[] a = IntStream.iterate(123400, i -> i > 0, i -> i / 10).map(i -> i % 10).toArray();

Обратите внимание, что это приведет к получению цифр в обратном порядке, но это может быть решено либо путем перебора массива в обратном направлении (к сожалению, перевернуть массив не так просто ), либо путем создания другого потока:

int[] b = IntStream.iterate(a.length - 1, i -> i >= 0, i -> i - 1).map(i -> a[i]).toArray();

или

int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length - i]).toArray();

Например, этот код:

int[] a = IntStream.iterate(123400, i -> i > 0, i -> i / 10).map(i -> i % 10).toArray();
int[] b = IntStream.iterate(a.length - 1, i -> i >= 0, i -> i - 1).map(i -> a[i]).toArray();
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));

Напечатаем:

[0, 0, 4, 3, 2, 1]
[1, 2, 3, 4, 0, 0]

А теперь решение без излишеств! По крайней мере, 000123и -123есть забавные результаты :-)
Каплан

@Kaplan Речь идет о цифрах числа, а "-" не цифра. Кроме того, число «000123» такое же, как просто «123», если только вы не утверждаете, что оно написано в восьмеричной системе или что-то в этом роде, но в этом случае это будет совершенно другое число.
Саймон Форсберг

Как уже было подробно обсуждено, любой подход к решению %имеет недостаток, заключающийся в том, что опускаются ведущие нули (например 000123). Только на бис мое решение тоже корректно работает и для знаков. Кстати: ваше решение подходит [8, 3]для 000123.
Каплан

@Kaplan Этот вопрос касается получения отдельных цифр для числа int , а не числа String . И естественно 000123делается 83потому, что 123 OCT = 83 DEC.
Саймон Форсберг

Единственная задача - получить цифры числа и не делать никаких непонятных преобразований чисел. Так 000123поступает [0, 0, 0, 1, 2, 3]. Никто на странице не понял эту задачу неправильно.
Каплан

2

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

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

Предположим, ваш ввод - целое число 123, результат будет следующим:

1
2
3

2

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

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

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


2

Поскольку я не вижу в этом вопросе метода, который использует Java 8, я добавлю его. Предполагая, что вы начинаете с a Stringи хотите получить a List<Integer>, вы можете передавать такие элементы в потоковом режиме.

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

Это получает символы в Stringas IntStream, сопоставляет эти целочисленные представления символов с числовым значением, помещает их в коробку, а затем собирает их в список.


Интересно, что chars () возвращает IntStream, поэтому, если вы вызываете boxed () и collect (), вы можете немедленно вернуть список целых чисел.
Джейсон

1
Вы получаете обратно значения ASCII. Итак, 1 соответствует 49.
ifly6 06

Интересно! Не знал этого, ты.
Джейсон

Не компилируется: Collectors.toList()→ « Несоответствие типов: невозможно преобразовать из Collector <Object, capture # 3-of?, List <Object>> в Supplier <R> », collect→ « Method collect (Supplier <R>, ObjIntConsumer <R >, BiConsumer <R, R>) в типе IntStream неприменимо для аргументов (Collector <Object,?, List <Object>>) »
Герольд Брозер

Отредактировано. Перед сбором их нужно упаковать. См., Например, repl.it/@ifly6/HeftyAffectionateHertz#Main.java
ifly6

1

Решение Java 8 для получения цифр как int [] из целого числа, которое у вас есть как String:

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

Вместо использования i - '0'есть также такие методы Character.toDigit, которые лучше использовать IMO.
Саймон Форсберг

@SimonForsberg, можете ли вы сослаться на метод в документации и дать фрагмент кода, как это будет работать? Я буду рад обновить свой ответ, если есть более элегантный способ.
qben,

@qben "0123456789".chars().map(i -> Character.digit(i, 10)).toArray() Character # digit (один для char и один для int codePoints)
Саймон Форсберг,

1

ни chars() ни codePoints() - другая лямбда

String number = Integer.toString( 1100 );

IntStream.range( 0, number.length() ).map( i -> Character.digit( number.codePointAt( i ), 10 ) ).toArray();  // [1, 1, 0, 0]

0

Integer.toString (1100) дает вам целое число в виде строки. Integer.toString (1100) .getBytes (), чтобы получить массив байтов отдельных цифр.

Редактировать:

Вы можете преобразовать символьные цифры в числовые, таким образом:

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

Это немного вводит в заблуждение. Это даст вам массив байтов, представляющих char '1'или '0'. Значения байтов не будут 1, или 0.
jjnguy 02

Вводят в заблуждение? Это немного жестковато. Вопрос был неоднозначным. Это действительно зависит от того, что он хочет делать с цифрами. Вы предполагаете, что он хочет произвести вычисления. Мой ответ предполагает обработку текста. Любое предположение частично верно, но я не собирался вводить в заблуждение.
Дон Брэнсон,

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

@Justin - А, ладно. Я не связываю байты автоматически как символы. В дни сборки я увеличивал «a», чтобы получить «b», повторяя алфавит, поэтому иногда байты были одновременно и тем, и другим. Конечно, языки высокого уровня и UTF делают все это спорным.
Дон Брэнсон

0

Он использует метод по модулю 10, чтобы вычислить каждую цифру в числе больше 0, затем это изменит порядок массива. Предполагается, что вы не используете «0» в качестве начальной цифры.

Это изменено, чтобы принимать вводимые пользователем данные. Этот массив изначально вставлен в обратном направлении, поэтому мне пришлось использовать Collections.reverse()вызов, чтобы вернуть его в порядок пользователя.

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

0

Чтобы продолжить, вот как подтвердить, что число является палиндромным целым числом в 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;
}

Я уверен, что смогу еще больше упростить этот алгоритм. Тем не менее, я здесь. И это сработало во всех моих тестовых случаях.

Я надеюсь, что это помогает кому-то.


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

12344444 слишком велик, чтобы быть int.
Джузеппе Гарассино

@Beppe 12344444 не слишком большой, чтобы быть int. В документации Java утверждается следующее: Для int от -2147483648 до 2147483647 включительно. Хотя, чтобы точно знать, в вашей системе вы можете использовать System.out.println (Integer.MAX_VALUE); чтобы узнать max_value, который поддерживается в вашем пакете java.lang
OrwellHindenberg

0

Попробуй это:

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;

Вы получите первый = 1, второй = 2, третий = 3 и четвертый = 4 ....


Это менее утилитарно и элегантно, чем общие методы, перечисленные выше, и в принципе не отличается от других ответов %. Это не добавляет ценности.
Шон Механ

@ Шон Механ, я бы не согласился. Вышеупомянутые методы в основном касаются использования String или длинных многострочных решений, в то время как этот простой и простой.
парсер 04

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

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

1
Обновите свой ответ и объясните, как это решает проблему. Ответы, содержащие только код, обычно считаются ответами низкого качества.
devlin carnate

0

Что-то вроде этого вернет 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();
}

0

Как новичок, я бы ответил:

String number = String.valueOf(ScannerObjectName.nextInt()); 
int[] digits = new int[number.length()]; 
for (int i = 0 ; i < number.length() ; i++)
    int[i] = Integer.parseInt(digits.substring(i,i+1))

Теперь все цифры содержатся в массиве цифр.


0

Почему бы вам не сделать:

String number = String.valueOf(input);
char[] digits = number.toCharArray();

-1

Думаю, это будет самый полезный способ получить цифры:

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

Тогда вы можете получить цифры простым способом:

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

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

или проще:

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

Обратите внимание, что последний метод слишком долго вызывает метод getDigitsOf. Так будет медленнее. Вы должны создать массив int, а затем один раз вызвать метод getDigitsOf, как и во втором блоке кода.

В следующем коде вы можете отменить процесс. Этот код складывает все цифры вместе, чтобы получилось число:

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

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


-1

см. ниже мое предложение с комментариями

          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()+ " ");
                }

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


Ответ ЗА → [ссылка] stackoverflow.com/questions/47196499/…
always007 09

-1

в Java так можно отделить цифры от чисел и сохранить их в массиве.

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

Выход:

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

-1

если цифра должна быть Character

String numstr = Integer.toString( 123 );
Pattern.compile( "" ).splitAsStream( numstr ).map(
  s -> s.charAt( 0 ) ).toArray( Character[]::new );  // [1, 2, 3]

и следующие работы правильно
numstr = "000123" получает [0, 0, 0, 1, 2, 3]
numstr = "-123"    получает[-, 1, 2, 3]


Pattern.compile? Это большой перебор.
Саймон Форсберг

@ Simon-Forsberg На момент написания это было единственное решение, которое создавало Character -array. Я сомневаюсь, что один вызов Pattern.compileзанимает больше времени, чем многократный вызов оператора по модулю, %и он может обрабатывать все большие числа (без intограничений типа) одновременно.
Каплан

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

         }
     }
    }

Без использования массивов и строк. (цифры 1-99999)

выход :

Введите цифру для печати отдельно: - 12345

1 2 3 4 5


Должен быть способ более эффективно и динамично определять divider.
ZX9
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.