3. alle Arten der Klammersetzung durchprobieren

alle Arten der Klammersetzung durchprobieren

  • B

    Mein Ziel ist es ein Programm in c++ zu schreiben das 8 Variablen in alle möglichen Konstallationen zu einander setzt. Ich habe es bereits geschafft, dass alle Möglichkeiten, die die 4 Grundrechnungsarten bieten, ausgegeben werden. Ich scheitere jetzt aber daran, dass ich keine Ahnung habe wie ich es schaffen kann dass er alle möglichen Arten der Klammersetzung durchprobiert.
    Google gibt nicht viel her bei den Begriffen Klammersetzung, Algorithmus, c++ oder ähnlichem, es wäre nett wenn mir jemand einen Hinweis geben könnte, wo ich suchen kann damit ich selbst das Problem lösen kann.

    0
  • M

    vielleicht so:

    siehb die Klammern ebenfalls als operatoren wie +,-,*,/ an, musst aber zusätzlich drauf achten, dass die aufgehenden und zugehenenden gleich sind.

    0
  • B

    Ich hab die 4 Grundrechnungsarten in ein Array gepackt und als string elemente dem Formel String hinzugefügt, so hätte ich es auch bei den Klammern geplant gehabt, nur und an dem Ansatz hänge ich jetzt, ich habe keine Ahnung wie man es schafft dass alle Möglichkeiten durchprobiert werden, weil um wirklich alle Möglichkeiten der Klammersetzung durchzuspielen, müsste man die Variablen untereinander auch verschieben können, weil a/(b+c) ist ja nicht das selbe wie (b+c)/a.

    0
  • A

    Ganz verstehe ich Deine Aufgabenstellung noch nicht. D.h. Du willst sowas herausbekommen, wenn es nur 2 Variablen wären?

    A+B   A-B
 A*B   A/B
(A+B) (A)+(B) ((A)+(B))
(A-B) (A)-(B) ((A)-(B))
(A*B) (A)*(B) ((A)*(B))
(A/B) (A)/(B) ((A)/(B))

    Die Tabelle mit dem Array für die gewünschten Rechenarten finde ich gut. Die gibt die grobe Blockbildung für die Rechenarten vor. Wenn Du auch noch die Variablen mit ihren Positionen durchrotieren mußt, dann würde ich eine zweidimensionale Tabelle mit den Indizes x,y machen: x=8 Einträge (x=Spalte) und y=4 Einträge (y=0: welche Variable steht an Position x? y=1: wieviel öffnende Klammern hat die Variable? y=2: wieviel schließende Klammern hat die Variable? y=3: welche Rechenart liegt vor?). Mit dieser Tabelle kannst Du dann ganz einfach die jeweils gewünschte Ausgabe vornehmen, weil Du das Ergebnis statisch aus der Tabelle aufbauen kannst.

    Nun brauchst Du entsprechend viele Schleifen, die alle Kombinationen durchziehen und die Tabelle verändert... Das Ergebnis dürfte bei der Aufgabenstellung aber eine hübsch große Ausgabedatei ausgeben...

    0
  • B

    ja prinzipiell will ich sowas haben, nur eben mit 8 Variablen, nur und das ist ja das Problem, mit 2 versteh ichs noch mit 8 versteh ichs nicht mehr. weil wenn man es insofern durchprobiert dass sowas steht:

    a+b+c+d+e+f+g+h
(a+b)+c+d+e+f+g+h
(a+b+c)+d+e+f+g+h
(a+b+c+d)+e+f+g+h

    etc, dann versteh ichs ja auch noch, eine funktion schreiben die immer eine Variable mehr innerhalb der Klammer hinzufügt, nur wie lasse ich die Variablen rotieren oder wie schaffe ich es dann dass in der Klammer noch Klammern gesetzt werden und dabei alle Möglichkeiten durchprobiert werden. Im Sinne von:

    (a+b+c+d)+e+f+g+h
((a+b)+(c+d))+e+f+g+h
((a+b+c)+d))+e+f+g+h
(a+(b+c)+d)+e+f+g+h
(a+b+(c+d))+e+f+g+h
(a+(b+c+d))+e+f+g+h

    und so weiter und so fort und dabei noch die variablen rotieren lässt

    und ja das ergebnis ist eine sicher sehr große Ausgabedatei, aber das stört ja nicht

    0
  • A

    Na hab ich doch geschrieben: Du brauchst ne Tabelle, die Dein aktuelles Ergebnis speichert, das von einer Funktion statisch ausgegeben werden kann.

    Dann brauchst Du für Deine Lösung eine Vielzahl von ineinander verschachtelten Schleifen. Die äußere legt die Positionen der Variablen fest, so daß Du alle Rotationen durchbekommst. Die nächsttiefere ist für die Grundrechenartenvariationen zuständig. Die nächsten Schleifenebenen kümmern sich um die Klammernsetzung.
    Du fängst bei

    a+b+c+d+e+f+g+h

    an und weiter gehts mit

    (a)+b+c+d+e+f+g+h
(a)+(b)+c+d+e+f+g+h
(a)+b+(c)+d+e+f+g+h
(a)+b+c+(d)+e+f+g+h
...
(a)+b+(c)+d+(e)+f+(g)+h
...
(a)+b+c+(d)+e+f+(g)+h
...
(a)+(b)+(c)+(d)+e+(f)+g+h
...
((a)+(b))+c+d+e+f+g+h

    Für den Algorithmus hab ich jetzt keinen Bock. Schließlich ist das nicht meine Hausaufgabe, sondern Deine und ich wüßte nicht, wozu ich persönlich sowas brauchen könnte... 😉

    0
  • P

    klammern klingen immer nach rekursion.

    0
  • B

    @andreasD du glaubst echt das ist ne Hausaufgabe? nein, ist es und war es nie. 😉

    Ich bin jetzt selbst auf die selbe Idee gekommen, höchst wahrscheinlich durch dem was du geschrieben hast, hat nur länger gedauert bis ichs verstanden hab 😉 nur 28 ineinander verschachtelte Schleifen sind auch nicht umbedingt das wahre. Zudem ist die Sache jetzt die, wenn ich das alles ausgebe wird die Datei viel zu groß, was insofern bedeutet ich muss das doch wieder anders lösen.

    Und wenn du das so wie du schreibst machst, also die Formel mit den Schleifen zusammen zusetzen, warum brauchst du dann noch eine Tabelle, weil dann kann man nur in einnander verschachtelte Schleifen hernehmen in der letzten schreibt man die erwünschte Formel rein, die einzelnen operatoren und Variablen und möglichen Klammern werden in ein jeweiliges Array gepackt und dann wird nach den schönen "Matrizenverfahren" alles durchgespielt. Nur wie gesagt, die eleganteste Lösung ist es meiner Meinung nach nicht.

    0
  • B

    so, jetzt hab ich das Problem gelöst. Hm, naja einfach umgangen würd eher passen, aber gelöst ist gelöst. Ich bin einfach auf eine andere Art der Schreibweise umgestiegen und schreibe die Formel nicht mittels der Infix Notation sondern mit der Umgekehrten Polnischen Notation, was die Sache um einges einfacher macht. So kann man es in einer Rekursiven Funktion leicht abhandeln.
    hoffe nur noch dass ich nichts vergessen hab 🙂

    0
Anmelden zum Antworten