Ziffern einer Zahl in Reihenfolge sortieren

M

moccajoghurt

Bekanntes Mitglied
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

F.S.WhiTeY

Bekanntes Mitglied
hmmm, keine arrays is mies ^^

da will euch euer dozent echt mal foppen :D

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.
 
M

moccajoghurt

Bekanntes Mitglied
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 :D
 
Zuletzt bearbeitet:
Landei

Landei

Top Contributor
Java: 
    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.
 
Zuletzt bearbeitet:
M

Marco13

Top Contributor
Nett.
Java: 
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

F.S.WhiTeY

Bekanntes Mitglied
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:

Java: 
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 ^^
 
Zuletzt bearbeitet:
Landei

Landei

Top Contributor
@Marco: Na dann halt ohne Math

Java: 
    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

F.S.WhiTeY

Bekanntes Mitglied
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.
 
M

moccajoghurt

Bekanntes Mitglied
Marco13 hat gesagt.:
Nett.
Java: 
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:
Zum Vergrößern anklicken....
deins habe ich verstanden, das von landei (wenn keine weitere erklärung in form von kommentaren kommt) leider nicht.
 
Landei

Landei

Top Contributor
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.
 

Aktuelle Jobs

Neue Themen


Oben