# Ziffern einer Zahl in Reihenfolge sortieren



## moccajoghurt (1. Jul 2010)

Hi,

stehe ziemlich ratlos vor einer Aufgabe meines Java-Kurses. Sie lautet:

Aufgabe 5:
Schreiben Sie ein Programm, das die Ziffern einer eingegebenen positiven Zahl in aufsteigender Reihenfolge sortiert und diese ausgibt. 0en fallen weg. Sie dürfen dabei keine Arrays oder Rekursion benutzen!
Beispiel:
Eingabe: 1423 Ausgabe: 1234
Eingabe: 1442624 Ausgabe: 1224446
Eingabe: 100132 Ausgabe: 1123

Mein Lösungsansatz ist nicht sehr schön, weil ich für jede Ziffer eine Variable erstellen würde. Gibt es einfachere Varianten?

Wichtig dabei: Für die Aufgabe sind nur die Anweisungen do, for, while, if, break, continue, sowie Funktionen und Prozeduren vorgesehen.

Gruß


----------



## F.S.WhiTeY (1. Jul 2010)

hmmm, keine arrays is mies ^^ 

da will euch euer dozent echt mal foppen 

Ich würde das über einen String Lösen, du kannst in strings suchen und ersetzen bzw. anfügen. 

google mal nach Regular Expressions in java und schau dir String mal genauer an. 

du kannst dann nach den ziffern suchen und wenn sie gefunden wurden die jehweilige anzahl an einen anderen String anhängen und diesen dann ausgeben oder als integer parsen.


----------



## moccajoghurt (1. Jul 2010)

Die Methode habe ich noch nicht gelernt, daher möchte ich es so lieber nicht machen... die Aufgabe ist ja dazu da das Erlente zu festigen und nicht neue Sachen zu erlernen 
Aber trotzdem danke für den Tipp und werde mir diese Methode trotzdem anschauen, auch wenn ich sie für die Aufgabe nicht benutzen möchte.

...wobei ich so langsam immer ansatzloser werde. Brauche Hilfe


----------



## Landei (1. Jul 2010)

```
public static long numSort(long l) {
        long result = 0;
        while(l > 0) {
            long n = l;
            int pos = 0;
            int smallestDigit = 10;
            int smallestPos = 0;
            while(n > 0) {
                int digit = (int) (n % 10);
                if (digit != 0 && digit < smallestDigit) {
                    smallestDigit = digit;
                    smallestPos = pos;
                }
                n = n / 10;
                pos ++;
            }
            result = 10 * result + smallestDigit;
            l = l - smallestDigit * (long) Math.pow(10, smallestPos);
        }
        return result;
    }
```

In jedem "äußeren" Schleifendurchlauf wird die kleinste Ziffer der Zahl gesucht, der Lösung hinzugefügt und aus der Ausgangszahl herausgerechnet, und zwar bis nichts mehr übrigbleibt. Nullen werden einfach übersprungen. Das Potenzieren von 10 kannst du auch leicht selbst programmieren, falls java.lang.Math auch nicht "erlaubt" ist.


----------



## Marco13 (1. Jul 2010)

Nett.

```
class SortDigits
{

    public static void main(String args[])
    {
        System.out.println(sortDigits(1432));
        System.out.println(sortDigits(1442624));
        System.out.println(sortDigits(100132));
    }


    private static long sortDigits(long value)
    {
        long result = 0;
        int length = length(value);
        for (int i=1; i<=9; i++)
        {
            for (int j=0; j<length; j++)
            {
                int digit = getDigit(value, j);
                if (digit == i)
                {
                    result = result * 10 + digit;
                }
            }
        }
        return result;
    }

    private static int length(long value)
    {
        int length = 0;
        while (value > 0)
        {
            length++;
            value /= 10;
        }
        return length;
    }

    private static int getDigit(long value, int index)
    {
        while (index > 0)
        {
            value /= 10;
            index--;
        }
        return (int)(value % 10);
    }
}
```


EDIT: Hmpf. 2 Minuten  
Aber wenigstens ohne die (vermutlich nicht erlaubte) Math... :bae:


----------



## F.S.WhiTeY (1. Jul 2010)

dann bleibt dir, meiner meinung nach, dennoch nur das zerlegen in einen String. 

du musst dir die einzelnen ziffern ja irgendwie zugänglich machen. 

das geht bei einem reinen Integer nicht, also musst du ihn in einen string parsen und zerlegen. 

um nicht jedesmal eine variable nutzen zu müssen, würde ich mit einer for-schleife durch den string durchgehen und an einen anderen anfügen. 

das ganze noch verschachtelt und du bist der held ^^

hier mal nen beispiel: 


```
String zahl = deinInteger.toString();
String neueZahl=null;
//Ziffern von 1-9
for(int i = 1; i<=9; i++){
//deinen string durchsuchen

for(int j =0; j< zahl.size();j++){

//Wir müssen vom hexcode ausgehen um mit chars zu vergleichen
//der hexcode für zahlen geht von 48 bis 57, 48 fällt raus das ist die 0... also +48
if(zahl.charAt(j) == (i+48) ){
neueZahl += (char) (i+48);
}
}
}
```


büdde ^^


----------



## Landei (1. Jul 2010)

@Marco: Na dann halt ohne Math


```
public static long numSort(long l) {
        long result = 0;
        while(l > 0) {
            long n = l;
            int pos = 1;
            int smallestDigit = 10;
            int smallestPos = 0;
            while(n > 0) {
                int digit = (int) (n % 10);
                if (digit != 0 && digit < smallestDigit) {
                    smallestDigit = digit;
                    smallestPos = pos;
                }
                n /= 10;
                pos *=  10;
            }
            result = 10 * result + smallestDigit;
            l = l - smallestDigit * smallestPos;
        }
        return result;
    }
```

@F.S.... Das finde ich häßlich. Wozu Strings vergewaltigen?


----------



## F.S.WhiTeY (1. Jul 2010)

> @F.S.... Das finde ich häßlich. Wozu Strings vergewaltigen?



ca die selbe laufzeit von n*9 also O(n), weniger hast du auch nicht und sehr viel weniger zeilen code ^^ 
und für den Herren einfacher zu verstehen... denke ich.


----------



## Marco13 (1. Jul 2010)

Strings enthalten Arrays. Aber unabhängig davon: Es war mit Sicherheit nicht gedacht, das mit Strings zu machen.


----------



## F.S.WhiTeY (1. Jul 2010)

Mag sein, aber es funktioniert... wenn der Prof Strings als Datentyp nicht ausschließt, wäre es halt einfach es so umzusetzen. 

Eure ansätze sind ja nicht verkehrt, aber für meinen geschmack zu umständlich. Wenn strings allerdings verboten sind, wird euer weg der einzig wahre sein. 

das könnte die aufgabenstellung allerdings auch hergeben.


----------



## moccajoghurt (3. Jul 2010)

Marco13 hat gesagt.:


> Nett.
> 
> ```
> class SortDigits
> ...


deins habe ich verstanden, das von landei (wenn keine weitere erklärung in form von kommentaren kommt) leider nicht.


----------



## Landei (3. Jul 2010)

Ist doch ganz einfach:
l ist die zu untersuchende Zahl. Die Variable n wird verwendet, um davon nacheinander die letzte Ziffer digit "abschneiden" zu können. Mit smallestDigit merken wir uns, welches die kleinste Ziffer war, die wir in diesem Durchlauf gefunden haben, und mit smallestPos, auf welcher "Zehnerposition" sie sich befunden hat. Nach einem Durchlauf schieben wir diese kleinste Ziffer in unser Resultat und ziehen von unserer Ausgangszahl die Ziffer an der richtigen Stelle ab, so dass dann dort eine 0 steht. Das machen wir solange, bis l gleich 0 ist, denn dann wurden alle Ziffern berücksichtigt und wir sind fertig.


----------

