Beiträge von Ycul

Die Probleme haben sich weitgehend gelöst, hab im Chat Hilfe bekommen.

Hallo,
Ich hoffe ihr könnt mir helfen.
Wir mussten als Aufgabe eine Klasse erstellen, in der ein Array Counter erstellt wird und das je nach Konstruktor entweder mit 0en oder mit zufälligen Integer Werten gefüllt wird. Dazu zum einen eine Methode, in der eine angegebene Position um 1 erhöht wird und alle minderwertigeren Stellen auf 0 gesetzt werden (genaueres steht im Quellcode). Zum anderen eine Methode, die einfach alle Stellen um 1 erhöht.
Jetzt habe ich das Problem, dass das Programm beim Ausführen der ersten Methode offenbar in einer Endlosschleife hängt und entsprechend gar nichts rauskommt, und die andere Methode erhöht zwar alle Stellen um 1 (wenn ich den "0er-Konstruktor" gewählt habe), gibt dann aber ArrayIndexOutOfBoundsException aus, und wenn ich den anderen Konstruktor nehme, gibt es mir irgendeine Stelle aus, erhöht die Werte jedoch nicht.

Hier mal der Code, ich konnte leider nichts kürzen, weil für die Methoden ja doch irgendwie alles relevant ist. Wobei die Konstruktoren eigentlich richtig sein müssten.

public class Counter{
    private int base;
    private int length;
    private final int[] counter;




    /**
     * Aufgabe 3 (a)
     */
    public Counter(int length, int base) {
        this.base = base;
        this.length = length;

        //Macht den Counter robust gegen ungültige Werte
        if(length<1 || base<2) {
            throw new IllegalArgumentException("Ungültige Länge oder Basis!");
        }

        //Initialisiert, falls length und base in Ordnung sind, einen Counter der Länge length und setzt alle Stellen auf 0.
        else { 
          counter = new int[length];

          for(int i = 0; i < length; i++) {
              counter[i] = 0;
          }
        }
    }

    /**
     * Aufgabe 3 (b)
     */
    public Counter(int length, int base, boolean random) {
        //Überprüft, ob die Werte für length und base gültig sind.
        if(length<1 || base<2) {
            throw new IllegalArgumentException("Ungültige Länge oder Basis!");
        }

        //Überprüft, ob random false oder true ist. Ist es false, funktioniert dieser Konstruktor wie der erste, ist es true, 
        //wird jeder Stelle des Counters ein zufälliger Wert zugeordnet.
        else {

            this.base = base;
            counter = new int[length];
            if(random == false) {
                for(int i = 0; i < length; i++) {
                    counter[i] = 0;
                }
            }

            else {

              for(int i = 0; i < length; i++) {
                   counter[i] = (int)(Math.random()*(base));
              }
            }
        }

    }




    /**
     * Aufgabe 3 (c)
     * Die Methode nimmt eine bestimmte Position entgegen, erhöht den Wert dieser und setzt alle minderwertigeren Stellen auf 0. Sollte dabei der Wertebereich überschritten
     * werden, wird die nächsthöhere Position um 1 erhöht. Passiert dies auf der letzten Stelle des Arrays, werden alle Stellen auf 0 gesetzt.
     */
    public int inc(int pos) {
        //Verhindert, dass pos kleiner als 0 oder grösser als die Counterlänge ist.
        if(pos<0 || pos>=counter.length) {
            throw new IllegalArgumentException("Ungültiger Wert für pos!");
        }
        int i = pos-1;

        //setzt alle Stellen. die minderwertiger sind als pos, auf 0.
        while(i >= 0) {
            counter[i] = 0;
            i = i--;
        }
        //erhöht den Wert von pos um 1.
        counter[pos]++;

        //Falls pos dabei den Wertebereich übertritt, wird die nächsthöhere eins höher gesetzt und pos auf 0.
        if(counter[pos] >= base) {
          counter[pos+1]++; 
          counter[pos] = 0;
        }

        //Passiert der Überlauf auf der letzten Stelle des Arrays, werden alle Stellen auf 0 gesetzt.
        if(pos == counter.length-1) {
            if(counter[pos] >= base) {
                counter[i] = 0;
            }
        }

        return counter[pos];
    }

    /**
     * (d)
     * Erhöht die Werte aller Stellen um 1, unter Beachtung der Base, wie bei int inc(int pos).
     */
    public int inc() {
        int i = 0;

        //Erhöht alle Stellen um 1
        for(i = 0; i < length; i++) {
            counter[i]++;
        }

        //Falls der Wertebereich überschritten wird, wird die nächsthöhere erneut um 1 erhöht.
        if(counter[i] == base) {
            counter[i+1]++;
        }

        //Setzt alle Stellen auf 0, falls der Überlauf an letzter Stelle eintritt.
        if(i == counter.length-1) {
            if(counter[i] >= base) {
                counter[i] = 0;
            }
        }

        return counter[i];
    }

    /**
     * (e)
     * gibt den aktuellen Stand des Zählers zurück und erstellt dazu ein Hilfsarray.
     */
    public int[] value() {
        int[] help = new int[counter.length];

        for(int i = 0; i < counter.length; i++) {
            help[i] = counter[i];
        }

        return help;
    }
}

Ich hoffe, mir kann da jemand helfen.

Edit:
Hier nochmal die komplette Aufgabenstellung dazu: (die ä,ö,ü sind jetzt nur a o u, weil das PDF so komisch ist, wollte jetzt nicht alles durchgehen und korrigieren, kann man ja trotzdem lesen)

Aufgabe 3: Codeknacker: Zahlensystem-Zahler 30 Punkte
In dieser Aufgabe geht es darum einen Zahlensystem-Zahler zu implementieren. Die Klasse
soll Counter heien. Ein Zahler hat eine Lange (Zahl der Stellen innerhalb des Zahlers) und
eine Basis. Jede Stelle im Zahler hat einen ganzzahligen Wert im Bereich [0,Basis).
z.B. ein Zahler mit Lange 4 und Basis 2 zahlt die 4-stelligen Binarzahlen ab und ein Zahler
mit Lange 2 und Basis 10 zahlt die 2-stelligen Dezimalzahlen ab.
(a) Konstruktor: 6 Punkte
Der Konstruktor soll zwei Integer-Parameter besitzen. Zum Einen die Zahlerlange, zum
Anderen die Basis Counter(int length, int base). Gultige Werte fur die Zahlerlange
sind 1 und fur die Basis 2. Der Konstruktor soll robust gegen ungultige Werte sein.
Alle Stellen des Counters werden mit 0 initialisiert.
(b) Konstruktor: 6 Punkte
Der zweite Konstruktor hat drei Parameter Counter(int length, int base, boolean
random). Wenn random nicht wahr ist, funktioniert er wie der Konstruktor mit nur zwei
Parametern. Wenn random wahr ist, wird der Counter initialisiert mit einem random Wert.
Der Konstruktor soll robust gegen ungultige Werte sein.
(c) int inc(int pos): 6 Punkte
Diese Methode erhoht die angegebene Position im Zahler um 1 und setzt die minderwertigeren
Stellen auf 0. Wird bei diesem Schritt der Wertebereich uberschritten, so wird die
nachsthoherwertigeren Position um 1 erhoht, usw. Sollte der Uberlauf auf die hochstwertigen
Position eintreten, werden alle Stellen auf 0 gesetzt.
Der Ruckgabewert dieser Methode ist der Index der hochstwertigen Position die verandert
wurde.
Es ist ein Fehler, wenn pos < 0 oder pos length ist.
(d) int inc(): 6 Punkte
Erhoht den Zahler als Ganzen um 1, unter Beachtung der Basis, wie unter inc(pos) beschrieben.

(e) value(): 6 Punkte
Die Methode int[] value() soll den aktuellen Stand des Zahlers zuruck geben. Achte
darauf, dass es nicht moglich sein soll, den Zahler von auen zu manipulieren indem
man das zuruckgegebene Array andert. Damit das Resultat der Methode fur Menschen
leicht lesbar ist, enthalt es die meist-signikante Zier auf Position 0 (big-endian). z.B. new
Counter(4,2).inc().inc() ergibt f0,0,1,0g.
Beispiel
int x;
Counter c = new Counter(3,4);
// c.value() = {0,0,0}
x = c.inc();
// c.value() = {0,0,1}, x = 0;
x = c.inc();
// c.value() = {0,0,2}, x = 0;
x = c.inc();
x = c.inc();
// c.value() = {0,1,0}, x = 1;
x = c.inc(2);
// c.value() = {1,0,0}, x = 2;
x = c.inc();
// c.value() = {1,0,1}, x = 0;
x = c.inc(1);
// c.value() = {1,1,0}, x = 1;
...
// Assume c.value = {3,3,3} here
c.inc();
// c.value() = {0,0,0}, x = 2;
3

Zitat von Bradon

Richtig, ein Array mit 7 Elementen hat die Indices 0-6, der Zugriff auf array[7] fuehrt zu einer ArrayIndexOutOfBoundsException. Daher muss der ende-Parameter 6 sein.

In der Aufgabenstellung steht eben [start;ende), demnach müsste ende ja eigentlich eins höher als der letzte Index sein.

Zitat von Bradon

@IndexOutOfBounds: Ich meinte den Aufruf in der main-Methode, der die Rekursion beginnt

Äh... Das ist die einzige Methode dazu.

Zitat

stackoverflow: Das Array-Objekt ist in jedem rekursiven Aufruf das gleiche, das heisst seine Laenge veraendert sich nie. Es kann daher auch nie die Laenge 1 erreichen.

Ja, dass das nicht stimmt wurde mir auch schon gesagt, deswegen hab ich das geändert.

Edit: Ich hab das darüber getestet, dass ich ein neues Objekt erzeuge und da die Methode ausführ. Hab da 7 Elemente eingegeben für das array, start = 0 und ende = 7, weil in der Aufgabe steht, das Intervall soll [start;ende) sein, also exklusive ende. Hab jetzt mal statt 7 6 eingegeben für ende und es ging.

Also zum IndexOutOfBounds sieht der Code bei mir so aus:

public int getSmallestElement(int[] array, int start, int ende) {


       if (start == ende) {
            return array[start];
       }

       else { 
       int mid = (start+ende)/2;
       return Math.min(getSmallestElement(array, start, mid), getSmallestElement(array, mid+1, ende)); 
       }
    }

Also im Vergleich zu Roflkopf hab ich nur mittel zu mid geändert.
Und beim StackOverflow hatte ich

public int getSmallestElement(int[] array, int start, int ende) {


       if (array.length == 1) {
            return array[0];
       }

       else { 
       int mid = (start+ende)/2;
       return Math.min(getSmallestElement(array, start, mid), getSmallestElement(array, mid+1, ende)); 
       }
    }

bzw. zuerst array.length<=1, aber da kam das gleiche.

Wir scheinen wohl an der gleichen Uni zu sein

Ich hatte den Code auch erst wie am Anfang, hatte es dann mit dem letzten Code von Roflkopf etwas anders versucht, aber da bekam ich StackOverflow. Und wenn ich das gleiche if verwende kommt bei mir ArrayIndexOutOfBoundsException. Bist du sicher, dass der Code richtig ist?