J'essaie de trier les chiffres d'un entier de n'importe quelle longueur dans l'ordre croissant sans utiliser de chaînes, de tableaux ou de récursivité.
Exemple:
Input: 451467
Output: 144567
J'ai déjà compris comment obtenir chaque chiffre de l'entier avec division du module:
int number = 4214;
while (number > 0) {
IO.println(number % 10);
number = number / 10;
}
mais je ne sais pas comment commander les chiffres sans tableau.
Ne vous inquiétez pas pour la classe IO
; c'est un cours personnalisé que notre professeur nous a donné.
Il y a en fait un algorithme très simple, qui utilise seulement des entiers:
int number = 4214173;
int sorted = 0;
int digits = 10;
int sortedDigits = 1;
boolean first = true;
while (number > 0) {
int digit = number % 10;
if (!first) {
int tmp = sorted;
int toDivide = 1;
for (int i = 0; i < sortedDigits; i++) {
int tmpDigit = tmp % 10;
if (digit >= tmpDigit) {
sorted = sorted/toDivide*toDivide*10 + digit*toDivide + sorted % toDivide;
break;
} else if (i == sortedDigits-1) {
sorted = digit * digits + sorted;
}
tmp /= 10;
toDivide *= 10;
}
digits *= 10;
sortedDigits += 1;
} else {
sorted = digit;
}
first = false;
number = number / 10;
}
System.out.println(sorted);
il imprimera 1123447
. L'idée est simple:
Cette version de l'algorithme peut trier dans les deux ordres asc, il vous suffit de changer la condition.
Aussi, je vous suggère de jeter un coup d'oeil à ce qu'on appelle Radix Sort , la solution ici prend quelques idées de la sorte radix, et je pense que la sorte radix est le cas général pour cette solution.
C'est 4 lignes, basées sur une variante de la boucle for
de votre boucle while avec un peu d'épice Java 8:
int number = 4214;
List<Integer> numbers = new LinkedList<>(); // a LinkedList is not backed by an array
for (int i = number; i > 0; i /= 10)
numbers.add(i % 10);
numbers.stream().sorted().forEach(System.out::println); // or for you forEach(IO::println)
Comment trier un nombre sans utiliser de tableau, de chaîne ou de tri api? Eh bien, vous pouvez trier un nombre en procédant comme suit (si vous avez trop de choses à lire, reportez-vous au résultat de débogage ci-dessous pour avoir une idée de la méthode de tri):
J'ai fourni un code avec deux boucles while dans la méthode principale et une fonction. La fonction ne fait rien, mais construit un nouvel entier en excluant le chiffre transmis, par exemple, je passe les fonctions 451567 et 1 et la fonction me renvoie 45567 (dans n'importe quel ordre, peu importe). Si cette fonction est passée à 451567 et 5 alors, il trouve les deux chiffres en nombre et les ajoute à stocker et renvoie le numéro sans 5 chiffres (ceci évite un traitement supplémentaire).
Débogage, pour savoir comment il trie l'entier:
Le dernier chiffre est: 7 du numéro: 451567
Subchunk est 45156
Subchunk est 4515
Subchunk est 451
Subchunk est 45
Subchunk est 4
Le chiffre réduit en 451567 est 1
Le magasin est: 1
Supprimer 1 de 451567
Nombre réduit à: 76554
Le dernier chiffre est: 4 du numéro: 76554
Subchunk est 7655
Subchunk est 765
Subchunk est 76
Subchunk est 7
Le chiffre réduit en 76554 est 4
Le magasin est: 14
Supprimer 4 de 76554
Nombre réduit à: 5567
Le dernier chiffre est: 7 du numéro: 5567
Subchunk est 556
Subchunk est 55
Subchunk est 5
Le chiffre réduit en 5567 est 5
Le magasin est: 145
Supprimer 5 de 5567
Répétition du chiffre min. 5 trouvé. Le magasin est: 145
Nombre minimal répété 5 ajouté au magasin. Mise à jour du magasin: 1455
Nombre réduit à: 76
Le dernier chiffre est: 6 du nombre: 76
Subchunk est 7
Le chiffre réduit en 76 est 6
Store is: 14556
Retirer 6 de 76
Nombre réduit à: 7
Le dernier chiffre est: 7 du nombre: 7
Le chiffre réduit en 7 est 7
Store is: 145567
Retirer 7 de 7
Nombre réduit à: 0
L'ordre croissant de 451567 est 145567
L'exemple de code est le suivant:
//stores our sorted number
static int store = 0;
public static void main(String []args){
int number = 451567;
int original = number;
while (number > 0) {
//digit by digit - get last most digit
int digit = number % 10;
System.out.println("Last digit is : " + digit + " of number : " + number);
//get the whole number minus the last most digit
int temp = number / 10;
//loop through number minus the last digit to compare
while(temp > 0) {
System.out.println("Subchunk is " + temp);
//get the last digit of this sub-number
int t = temp % 10;
//compare and find the lowest
//for sorting descending change condition to t > digit
if(t < digit)
digit = t;
//divide the number and keep loop until the smallest is found
temp = temp / 10;
}
System.out.println("Smalled digit in " + number + " is " + digit);
//add the smallest digit to store
store = (store * 10) + digit;
System.out.println("Store is : " + store);
//we found the smallest digit, we will remove that from number and find the
//next smallest digit and keep doing this until we find all the smallest
//digit in sub chunks of number, and keep adding the smallest digits to
//store
number = getReducedNumber(number, digit);
}
System.out.println("Ascending order of " + original + " is " + store);
}
/*
* A simple method that constructs a new number, excluding the digit that was found
* to b e smallest and added to the store. The new number gets returned so that
* smallest digit in the returned new number be found.
*/
public static int getReducedNumber(int number, int digit) {
System.out.println("Remove " + digit + " from " + number);
int newNumber = 0;
//flag to make sure we do not exclude repeated digits, in case there is 44
boolean repeatFlag = false;
while(number > 0) {
int t = number % 10;
//assume in loop one we found 1 as smallest, then we will not add one to the new number at all
if(t != digit) {
newNumber = (newNumber * 10) + t;
} else if(t == digit) {
if(repeatFlag) {
System.out.println("Repeated min digit " + t + "found. Store is : " + store);
store = (store * 10) + t;
System.out.println("Repeated min digit " + t + "added to store. Updated store is : " + store);
//we found another value that is equal to digit, add it straight to store, it is
//guaranteed to be minimum
} else {
//skip the digit because its added to the store, in main method, set flag so
// if there is repeated digit then this method add them directly to store
repeatFlag = true;
}
}
number /= 10;
}
System.out.println("Reduced number is : " + newNumber);
return newNumber;
}
}
Je suppose que vous êtes autorisé à utiliser le hachage.
public static void sortDigits(int x) {
Map<Integer, Integer> digitCounts = new HashMap<>();
while (x > 0) {
int digit = x % 10;
Integer currentCount = digitCounts.get(digit);
if (currentCount == null) {
currentCount = 0;
}
digitCounts.put(x % 10, currentCount + 1);
x = x / 10;
}
for (int i = 0; i < 10; i++) {
Integer count = digitCounts.get(i);
if (count == null) {
continue;
}
for (int j = 0; j < digitCounts.get(i); j++) {
System.out.print(i);
}
}
}
Mon algorithme de le faire:
int ascending(int a)
{
int b = a;
int i = 1;
int length = (int)Math.log10(a) + 1; // getting the number of digits
for (int j = 0; j < length - 1; j++)
{
b = a;
i = 1;
while (b > 9)
{
int s = b % 10; // getting the last digit
int r = (b % 100) / 10; // getting the second last digit
if (s < r)
{
a = a + s * i * 10 - s * i - r * i * 10 + r * i; // switching the digits
}
b = a;
i = i * 10;
b = b / i; // removing the last digit from the number
}
}
return a;
}
Ajouter un algorithme très simple qui ne nécessite aucune infrastructure de données ni mathématique sophistiquée, contrairement aux autres.
int number = 65356;
for (int i = 0; i <= 9; i++) { // the possible elements are known, 0 to 9
int tempNumber = number;
while (tempNumber > 0) {
int digit = tempNumber % 10;
IO.print(digit);
tempNumber = number / 10;
}
}
Dans les mots:
1. Imprimez un 0 pour chaque 0 du nombre.
2. Imprimez un 1 pour chaque 1 du nombre.
...
class SortDigits {
public static void main(String[] args) {
int inp=57437821;
int len=Integer.toString(inp).length();
int[] arr=new int[len];
for(int i=0;i<len;i++)
{
arr[i]=inp%10;
inp=inp/10;
}
Arrays.sort(arr);
int num=0;
for(int i=0;i<len;i++)
{
num=(num*10)+arr[i];
}
System.out.println(num);
}
}
Voici la solution simple:
public class SortDigits
{
public static void main(String[] args)
{
sortDigits(3413657);
}
public static void sortDigits(int num)
{
System.out.println("Number : " + num);
String number = Integer.toString(num);
int len = number.length(); // get length of the number
int[] digits = new int[len];
int i = 0;
while (num != 0)
{
int digit = num % 10;
digits[i++] = digit; // get all the digits
num = num / 10;
}
System.out.println("Digit before sorting: ");
for (int j : digits)
{
System.out.print(j + ",");
}
sort(digits);
System.out.println("\nDigit After sorting: ");
for (int j : digits)
{
System.out.print(j + ",");
}
}
//simple bubble sort
public static void sort(int[] arr)
{
for (int i = 0; i < arr.length - 1; i++)
for (int j = i + 1; j < arr.length; j++)
{
if (arr[i] > arr[j])
{
int tmp = arr[j];
arr[j] = arr[i];
arr[i] = tmp;
}
}
}
}