Comment obtenir les chiffres séparés d'un nombre entier?


144

J'ai des nombres comme 1100, 1002, 1022 etc. Je voudrais avoir les chiffres individuels, par exemple pour le premier numéro 1100 je veux avoir 1, 1, 0, 0.

Comment puis-je l'obtenir en Java?

Réponses:


205

Pour ce faire, vous utiliserez l' %opérateur (mod).

int number; // = some int

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

L'opérateur de mod vous donnera le reste de la division int sur un nombre.

Alors,

10012 % 10 = 2

Car:

10012 / 10 = 1001, remainder 2

Remarque: comme Paul l'a noté, cela vous donnera les nombres dans l'ordre inverse. Vous devrez les pousser sur une pile et les faire sortir dans l'ordre inverse.

Code pour imprimer les nombres dans le bon ordre:

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
Cela vous donnera les nombres dans le mauvais ordre, cependant, vous devrez donc être sûr de les pousser sur une pile ou simplement les mettre dans un tableau dans l'ordre inverse.
Paul Tomblin

4
Notez que cela leur donne de droite à gauche. (L'exemple de l'OP les montre de gauche à droite). Assez simple à manipuler, mais il faut le noter.
James Curran

1
@Don, en pratique, non. Je ne serais pas favorable à cela. C'est bien plus rapide que la version basée sur des chaînes. Je regarderais la réponse de Marimuthu pour un code rapide et court.
jjnguy

2
Excellente solution mais il semble qu'elle ne gère pas le scénario lorsque le nombre commence par des zéros non significatifs. par exemple - 001122. Si j'utilise la logique ci-dessus - je n'aurai que 1,1,2,2. Les 0 en tête sont supprimés de% et / operations. S'il vous plait corrigez moi si je me trompe.
goyalshub1509

2
qu'en est-il des entiers négatifs ici? si je passe -3432, la sortie sera -2-3-4-3, ce qui est incorrect.
Nodir Nasirov

76

Convertissez-le en Stringet utilisez String#toCharArray()ou String#split().

String number = String.valueOf(someInt);

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

Si vous êtes déjà sur Java 8 et que vous souhaitez effectuer des opérations d'agrégation sur celui-ci par la suite, envisagez d'utiliser String#chars()pour en extraire un IntStream.

IntStream chars = number.chars();

7
C'est la manière rapide et sale.
jjnguy

8
Avec split(""), le premier élément du tableau est "". Utilisez une autre expression régulière, comme split("(?<=.)").
True Soft

3
toCharArray est BEAUCOUP plus rapide que split. Je viens de mettre les deux en boucle 1000 fois et toCharArray a pris 20 ms et le split a pris 1021 ms. Je l'ai également fait mathématiquement en utilisant diviser par dix avec mod (%) et cela a pris 50 ms pour le faire de cette façon, donc toCharArray semble être plus rapide que les deux autres.
Jerry Destremps

2
Edit: Je viens de le refaire, cette fois avec des boucles plus longues pour être sûr (10 000 itérations). toCharArray est environ 100 fois plus rapide que split, et toCharArray est environ 5 fois plus rapide que la méthode mathématique du module.
Jerry Destremps

9
@BalusC number.chars()renverra le résultat dans une valeur Ascii et non numérique. De sorte que le nombre "1234" sera divisé en "49", "50", "51", "52" au lieu de "1", "2", "3", "4". Pour faire les choses correctement, cela devrait ressembler à:IntStream chars = number.chars().map(Character::getNumericValue);
Koin Arab

29

Que dis-tu de ça?

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

ou au lieu d'imprimer sur la console, nous pouvons le collecter dans un tableau d'entiers puis imprimer le tableau:

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

Si vous souhaitez conserver l'ordre des chiffres du moins significatif (index [0]) au plus significatif (index [n]), vous avez besoin de getDigits () mis à jour:

/**
 * 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
C'est un bon moyen d'imprimer les choses dans le bon ordre en utilisant mod. +1
jjnguy

1
C'est beau. Je pensais: "Il doit y avoir un moyen d'inverser l'ordre sans utiliser de collection ...." +1
bobndrew

Impeccable. Pourrait vouloir ajouter le code suivant à getDigits (int num) pour le rendre immunisé contre les mauvaises entrées: if (number < 0) { return new Integer[0]; } Testé avec les entrées suivantes:Integer[] samples = {11111, 123457, 0, -13334, 93846, 87892, 9876543, -1234, 012455};
realPK

24

Je n'ai vu personne utiliser cette méthode, mais cela a fonctionné pour moi et est court et doux:

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

Cela produira:

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

C'est étonnant. Merci
Marwa Eltayeb

Pour une raison quelconque, cette logique donne une mauvaise sortie pour des nombres différents de 5542. Essayez par exemple: 0142323
tavalendo

@tavalendo 0142323est une constante octale égale à 50387, en raison du zéro de début , tout comme 0x100une constante hexadécimale égale à 256, en raison du début 0x, et 0b1011est une constante binaire égale à 11due au début 0b. Méfiez-vous des 0 en tête sur les constantes entières!
AJNeufeld

12

J'ai remarqué qu'il existe peu d'exemples d'utilisation du flux Java 8 pour résoudre votre problème, mais je pense que c'est le plus simple:

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

Pour être clair: vous utilisez String.valueOf(number)pour convertir un int en chaîne, puis une chars()méthode pour obtenir un IntStream (chaque caractère de votre chaîne est maintenant un nombre Ascii), puis vous devez exécuter une map()méthode pour obtenir une valeur numérique du nombre Ascii. À la fin, vous utilisez la toArray()méthode pour changer votre flux en un tableau int [].


11

Je vois que toutes les réponses sont laides et pas très propres.

Je vous suggère d'utiliser un peu de récursivité pour résoudre votre problème. Cet article est très ancien, mais il pourrait être utile aux futurs codeurs.

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

Production:

Input: 12345

Output: 1   2   3   4   5 

Vous avez raison, les réponses sont laides. Merci.
parsecer

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

Le type Java int a une valeur minimale de -2 ^ 31 et une valeur maximale de 2 ^ 31-1. Comment la solution ci-dessus peut-elle fonctionner pour toutes les valeurs + ve qui correspondent à un type int?
realPK

3

Un moyen plus simple, je pense, est de convertir le nombre en chaîne et de l'utiliser substringpour extraire puis convertir en entier.

Quelque chose comme ça:

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

la sortie est 2014


la conversion de type ici coûtera-t-elle plus cher ou les opérations de division?
Rahul

3

solution simple

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

2

J'ai écrit un programme qui montre comment séparer les chiffres d'un entier en utilisant une approche plus simple et compréhensible qui n'implique pas de tableaux, de récursions, et tout ce schmancy sophistiqué. Voici mon code:

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

Supposons que votre entrée soit l'entier 123, la sortie résultante sera la suivante:

1
2
3

2

Voici ma réponse, je l'ai fait pour moi-même et j'espère que c'est assez simple pour ceux qui ne veulent pas utiliser l'approche String ou qui ont besoin d'une solution plus mathématique:

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

Donc, je viens de récupérer les unités, de les imprimer, de les soustraire du nombre, puis de diviser ce nombre par 10 - ce qui est toujours sans aucun élément flottant, puisque les unités ont disparu, répétez.


1

Essaye ça:

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;

Vous obtiendrez premier = 1, deuxième = 2, troisième = 3 et quatrième = 4 ....


Ceci est moins utilitaire et élégant que les méthodes générales énumérées ci-dessus, ni différent en principe des autres réponses utilisant %. Cela ajoute peu de valeur.
Shawn Mehan

@Shawn Mehan, je ne suis pas d'accord. Les méthodes ci-dessus concernent principalement l'utilisation de String ou de longues solutions multi-lignes, alors que celle-ci est claire et simple.
parsecer

1

Solution Java 8 pour obtenir des chiffres comme int [] à partir d'un entier que vous avez comme chaîne:

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

J'ai essayé et ça ne marche pas. Vous pouvez simplement essayer "12" .chars (). ToArray () et vous découvrirez qu'au lieu de renvoyer [1,2], il renvoie [49,50] qui, je suppose, sont en fait les codes ASCII pour "1" et «2», et ce n'est certainement pas ce que voulait l'OP.
Fran Marzoa

@Fran vous avez raison. J'ai mis à jour ma réponse pour inclure une i -> i - '0'cartographie afin que le résultat soit exactement ce que le PO a demandé.
qben

Au lieu d'utiliser, i - '0'il est également Character.toDigitpréférable d'utiliser des méthodes comme celle de l'OMI.
Simon Forsberg

@SimonForsberg pouvez-vous référencer la méthode dans la documentation et donner un extrait de code comment cela fonctionnerait? Je suis heureux de mettre à jour ma réponse s'il existe une manière plus élégante.
qben

@qben "0123456789".chars().map(i -> Character.digit(i, 10)).toArray() Character # digit (il y en a un pour char et un pour int codePoints)
Simon Forsberg

1

ni chars() ni codePoints() - l'autre lambda

String number = Integer.toString( 1100 );

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

1

Java 9 a introduit une nouvelle Stream.iterateméthode qui peut être utilisée pour générer un flux et s'arrêter à une certaine condition. Cela peut être utilisé pour obtenir tous les chiffres du nombre, en utilisant l'approche modulo.

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

Notez que cela obtiendra les chiffres dans l'ordre inverse, mais cela peut être résolu soit en bouclant le tableau à l'envers (malheureusement, inverser un tableau n'est pas si simple ), soit en créant un autre flux:

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

ou

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

A titre d'exemple, ce code:

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

Imprime:

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

0

Integer.toString (1100) vous donne l'entier sous forme de chaîne. Integer.toString (1100) .getBytes () pour obtenir un tableau d'octets des chiffres individuels.

Éditer:

Vous pouvez convertir les chiffres des caractères en chiffres numériques, ainsi:

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

Ceci est légèrement trompeur. Cela vous donnera un tableau d'octets représentant le char '1'ou '0'. Les valeurs d'octet ne seront pas 1, ou 0.
jjnguy

Trompeur? C'est un peu dur. La question était ambiguë. Cela dépend vraiment de ce qu'il veut faire avec les chiffres. Vous supposez qu'il veut effectuer des calculs. Ma réponse suppose un traitement de texte. L'une ou l'autre hypothèse est partiellement correcte, mais ce n'était pas mon intention de tromper.
Don Branson

Je suppose que je pense que c'est trompeur parce que vous obtenez un tableau d'octets, ce que je pense à des nombres et non à des caractères.
jjnguy

@Justin - Ah, d'accord. Je n'associe pas automatiquement les octets comme pas des caractères. Dans mes jours d'assemblage, j'incrémentais «a» pour obtenir «b», en parcourant l'alphabet - donc parfois, les octets étaient simultanément les deux. Bien sûr, les langages de haut niveau et UTF rendent tout cela sans objet.
Don Branson

0

Cela utilise la méthode modulo 10 pour comprendre chaque chiffre dans un nombre supérieur à 0, cela inversera l'ordre du tableau. Cela suppose que vous n'utilisez pas "0" comme chiffre de départ.

Ceci est modifié pour prendre en compte l'entrée utilisateur. Ce tableau est à l'origine inséré à l'envers, j'ai donc dû utiliser l' Collections.reverse()appel pour le remettre dans l'ordre de l'utilisateur.

    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

Juste pour construire sur le sujet, voici comment confirmer que le nombre est un entier palindromique 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;
}

Je suis sûr que je peux simplifier davantage cet algo. Pourtant, c'est là que je suis. Et cela a fonctionné dans tous mes cas de test.

J'espère que ça aidera quelqu'un.


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 est trop gros pour être un int.
Giuseppe Garassino

@Beppe 12344444 n'est pas trop gros pour être un int. La documentation Java revendique ce qui suit Pour int, de -2147483648 à 2147483647, inclus. Bien que pour être sûr de votre système, vous pouvez utiliser System.out.println (Integer.MAX_VALUE); pour connaître la valeur maximale prise en charge dans votre package java.lang
OrwellHindenberg

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
Veuillez mettre à jour votre réponse et expliquer comment elle résout le problème. Les réponses au code uniquement sont généralement considérées comme des réponses de mauvaise qualité.
devlin carnate

0

voir ci-dessous ma proposition avec des commentaires

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

0

Quelque chose comme ceci renverra le 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

En tant que noob, ma réponse serait:

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

Maintenant, tous les chiffres sont contenus dans le tableau "digits".


0

Pourquoi tu ne fais pas:

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

0

Comme je ne vois pas de méthode sur cette question qui utilise Java 8, je vais la jeter. En supposant que vous commencez par a Stringet que vous voulez obtenir a List<Integer>, alors vous pouvez diffuser les éléments comme ça.

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

Cela obtient les caractères dans le Stringsous forme de IntStream, mappe ces représentations entières de caractères à une valeur numérique, les encadre, puis les rassemble dans une liste.


Il est intéressant de noter que chars () renvoie un IntStream, donc si vous appelez boxed () et collect (), vous pouvez renvoyer la liste des entiers immédiatement.
Jason

1
Vous récupérez les valeurs ASCII. Donc 1 correspond à 49.
ifly6

Intéressant! Je ne savais pas ça, ty.
Jason

Ne compile pas: Collectors.toList()→ " Incompatibilité de type: impossible de convertir de Collector <Object, capture # 3-of?, List <Object>> to Supplier <R> ", collect→ " La méthode collect (Supplier <R>, ObjIntConsumer <R >, BiConsumer <R, R>) dans le type IntStream n'est pas applicable pour les arguments (Collector <Object,?, List <Object>>) "
Gerold Broser

Édité. Ils doivent être emballés avant d'être collectés. Voir par exemple repl.it/@ifly6/HeftyAffectionateHertz#Main.java
ifly6

-1

Je pense que ce sera le moyen le plus utile d'obtenir des chiffres:

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

Ensuite, vous pouvez obtenir des chiffres de manière simple:

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

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

ou plus simplement:

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

Notez que la dernière méthode appelle la méthode getDigitsOf trop longtemps. Ce sera donc plus lent. Vous devez créer un tableau int, puis appeler la méthode getDigitsOf une fois, comme dans le deuxième bloc de code.

Dans le code suivant, vous pouvez inverser le processus. Ce code rassemble tous les chiffres pour former le numéro:

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

Les deux méthodes que j'ai fournies fonctionnent également pour les nombres négatifs.


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


La réponse est POUR → [lien] stackoverflow.com/questions/47196499/…
007

-1

en Java, voici comment séparer les chiffres des nombres et les stocker dans un tableau.

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

Production:

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

-1

si le chiffre est censé être un Character

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

Pattern.compile? C'est beaucoup exagéré.
Simon Forsberg

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

         }
     }
    }

Sans utiliser de tableaux et de chaînes. (chiffres 1-99999)

production :

Entrez le chiffre à imprimer séparément: - 12345

1 2 3 4 5


Il doit y avoir un moyen de déterminer plus efficacement et dynamiquement divider.
ZX9
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.