Rekursion, String

[O2016]

Hallo,

ich hänge an einer Aufgabe es geht um die Türme von Hanoi:
Ich habe eine Funktion die Anzahl,start,mitte,ende an eine Funktion übergibt.

Diese soll rekursiv aufgerufen werden,
nun möchte ich die Werte in einem String speichern und dann zurückgeben.
A verschoben auf C
B verschoben auf C
C, Verschoben auf A...
( ihr wisst was ich meine)
Er gibt es soweit auch zurück, aber nicht alles in einer Zeile. Wie kann ich es nun in einem String speichern.
also:

A verschoben auf C; B verschoben auf C; C, Verschoben auf A...
und dann zurückgeben?
Wenn ich einen String initialisiere also auf "" setze, dann wird er ja bei jedem erneuten Aufruf wieder initialisiert und ist am Ende leer.
Gibt es eine Möglichkeit, diesen nur einmal zu initialisieren?

Bsp Funktionen:

Hanoi(a, c, b, n-1);
Hanoi(a, b, c, 1);
Hanoi(b, a, c, n-1);

hoffentlich wisst ihr was ich meine.
Vielen Dank im Voraus

 

[Xyz1]

Musses denn unbedingt rekursiv sein???? Mit iterativ hättest du "mehr" Möglichkeiten bei der Ausgabe....
Leider weiß ich gerade nich mehr iterativ wie das ging im Koppp. 🙁

hoffentlich wisst ihr was ich meine

zu ca 47,5% verstehe ich was Du meinst. 😉

 

[mihe7]

Beispiel:

import java.util.StringJoiner;

public class Hanoi {
    public StringJoiner move(int i, String aName, String bName, String cName) {
        StringJoiner sj = new StringJoiner(", ");
        if (i > 0) {
            sj.merge(move(i-1, aName, cName, bName));
            sj.add("verschiebe von " + aName + " nach " + cName);
            sj.merge(move(i-1, bName, aName, cName));
        }
        return sj;
    }

    public static void main(String[] args) {
        System.out.println(new Hanoi().move(3, "A", "B", "C").toString());
    }
}

 

[Xyz1]

Wem noch nich schwindelig ist: 😕

public class TuermeHanoi {
    public static void main(String[] args) {
        System.out.println(h(Stream.of(5, 4, 3, 2, 1).collect(Collectors.toCollection(Stack::new))).toString());
    }
    static StringJoiner h(Stack<Integer> a) {
        return g(Stream.of(a, new Stack<Integer>(), new Stack<Integer>()).collect(Collectors.toList()));
    }
    static StringJoiner g(List<Stack<Integer>> list) {
        return f(list.stream().collect(Collectors.toList()), list, list.get(0).size());
    }
    static StringJoiner f(List<Stack<Integer>> swapped, List<Stack<Integer>> unswapped, int deep) {
        StringJoiner g = new StringJoiner("; ");
        if (deep > 0) {
            Collections.swap(swapped, 1, 2);
            g.merge(f(swapped, unswapped, deep - 1));
            Collections.swap(swapped, 1, 2);
            g.add(unswapped.toString());
            swapped.get(2).push(swapped.get(0).pop());
            Collections.swap(swapped, 0, 1);
            g.merge(f(swapped, unswapped, deep - 1));
            Collections.swap(swapped, 0, 1);
        }
        return g;
    }
}

Ich selber würde das selber aber nich so schreiben......

@mihe7 Gibt es ieeine Möglichkeit auf den deep-Parameter zu verzichten???? 🙂

schönen Tag noch

BEARBEITUNG, ach ja, hier noch:
[[5, 4, 3, 2, 1], [], []]; [[5, 4, 3, 2], [], [1]]; [[5, 4, 3], [2], [1]]; [[5, 4, 3], [2, 1], []]; [[5, 4], [2, 1], [3]]; [[5, 4, 1], [2], [3]]; [[5, 4, 1], [], [3, 2]]; [[5, 4], [], [3, 2, 1]]; [[5], [4], [3, 2, 1]]; [[5], [4, 1], [3, 2]]; [[5, 2], [4, 1], [3]]; [[5, 2, 1], [4], [3]]; [[5, 2, 1], [4, 3], []]; [[5, 2], [4, 3], [1]]; [[5], [4, 3, 2], [1]]; [[5], [4, 3, 2, 1], []]; [[], [4, 3, 2, 1], [5]]; [[1], [4, 3, 2], [5]]; [[1], [4, 3], [5, 2]]; [[], [4, 3], [5, 2, 1]]; [[3], [4], [5, 2, 1]]; [[3], [4, 1], [5, 2]]; [[3, 2], [4, 1], [5]]; [[3, 2, 1], [4], [5]]; [[3, 2, 1], [], [5, 4]]; [[3, 2], [], [5, 4, 1]]; [[3], [2], [5, 4, 1]]; [[3], [2, 1], [5, 4]]; [[], [2, 1], [5, 4, 3]]; [[1], [2], [5, 4, 3]]; [[1], [], [5, 4, 3, 2]]

 

[mihe7]

Gibt es ieeine Möglichkeit auf den deep-Parameter zu verzichten???? 🙂

Mal von einer Classvariablen abgesehen, wüsste ich nicht, wie man darauf verzichten könnte, ohne dafür einen anderen Parameter einzuführen.

 

[Xyz1]

wüsste ich nicht, wie man darauf verzichten könnte

Zu dem Schluss kam ich auch schon 😳

 

[O2016]

@mihe7 vielen Dank. Ich teste es noch.

 

[O2016]

@mihe7 Danke aber hab gerade gesehen importieren dürfen Wir nichts. Alles sehr streng, genauso wenig eine weitere Methode

 

[mihe7]

Der StringJoiner macht einem (und dem Garbage Collector) das Leben nur leichter. Es geht auch ohne:

    public String move(int i, String aName, String bName, String cName) {
        String sj = "";
        if (i > 0) {
            String step = move(i-1, aName, cName, bName);
            if (!step.isEmpty()) {
                sj = step + ", ";
            }
            sj += "verschiebe von " + aName + " nach " + cName;
            step = move(i-1, bName, aName, cName);
            if (!step.isEmpty()) {
                sj += ", " + step;
            }
        }
        return sj;
    }

genauso wenig eine weitere Methode

Welche weitere Methode?