Hallo zusammen,

ich soll ein Programm schreiben, dass simple mathematische Funktionen berechnet und nur Grundrechenarten (+-/*).
Mein Problem ist, dass ich keine Idee habe wie das Programm mit Klammern umgehen soll.

Folgende Eingabe will ich tätigen:
nur als Beispiel
((1+5)+(1-2)*5)+1
Diese Eingabe wird in einen String gespeichert, der dann zerlegt wird.

Doch wie mache ich das, dass das (das das das,... :)) Programm die Klammern intelligent beachtet und damit auch korrekt rechnet kann.

Das ganze soll zwar in Pascal programmiert sein, doch ich brauche auch nur Eure Hilfe zum Ablauf.

Bitte helft mir

hm, ich weiss jetzt nicht, wie man das in pascal umsetzen könnte, aber ein ansatz währe, in mehreren schritten vorzugehen.
etwa so, dass man erst alle blöcke ausrechnet, die selbst keine weiteren klammern haben. ich bring mal nen beispiel

((1+5)+(1-2)*5)+1

also zuerst 1+5 = 6 und 1-2 = -1 berechnen

( 6 + -1 * 5 ) + 1

jetzt 6 + -1 * 5 = 1 (punkt vor strichrechung)

1 + 1 = 2

naja der klassiker zu dem thema ist ein baumstruktur
ok dir fehlt jetzt das praktische split von perl
aber ich denke schon das man mit einmal von links nach rechts parsen einen baum bekommt:

+
/ \
+ 1
/ \
+ *
/\ / \
1 5 - 5
/\
1 2

einfach ne pointerstruktur aufmachen
das geht ja in pascal
mit jeder klammer auf einen subnode
und mit einpaar hilfspointern bevor die struktur fertich verschweisst ist
und voilla dürfte nicht schwer werden\n\n

<!--EDIT|lichtkind|1083867562-->

Die Idee mit den Blöcken kam mir auch.

In jede Klammer zu gehn, die Rechenoperation ausführen, Ergebnis in Variable speichern und später alle variablen wieder zusammen setzen.

Das Programm müsste nach meinem Verständnis folgend vorgehen:

ich lasse ihn zunächst zählen wie viele Klammern geöffnet und dann wieder geschlossen werden.
Dann würde ich die Werte in den Klammern in Variablen packen.
in der ersten Variable $1 stünde dann: $1 = (1+5)+(1-2)*5
doch wie lasse ich ihn das am besten prüfen?

Woher soll das Programm wissen, dass die Schliessende Klammer ganz hinten steht und es nicht die nächste schliessende ist?
Das ist das Problem wozu ich keine Idee für ein Verfahren habe.

( (1+5) + (1-2) *5 ) +1 Funktion
1 2 2 3 3 1 Klammern

warning: code nicht getestet, sondern on-the-fly



so... du müsstest jetzt nur noch auf +-/* reagieren und immer result berechnen...

die calcstring ist quasi dein Bett, um jedes Klammerpäcken einzeln zu betrachten...

have fun!

PS: Wie gesagt; code ist nicht getestet und auch nicht compiliert

@ lichtkind

Dieser Ansatz ist für mich total neu, doch leider kann ich dir kaum folgen.

Das mit dem Baum ist echt toll. Guter Ansatz, doch was meinst Du mit Subnodes und Hilfspointern?

Ist die Baumstruktur zu betrachten wie ein Mehrdimmensionales Array? Oder liege ich mit dieser Idee völlig falsch?

@esskar

danke für deine code leistung.
Diese Syntax ist mir nicht geläufig, jedenfalls nicht unter pascal. Deshalb erzähl mir bitte etwas zu den Variablen und deren Bedeutung. Vielleicht erklärst du mir auch waas genau deine beiden funktionen machen.
mit INT gibt man ganze Zahlen aus. Meinst du das auch damit?

hab nicht gesehen, dass du pascal willst...
habe nur das forum gesehen...

aber licht kinds ansatz ist gut...
versuch ihn zu verstehen!

lol und ich habe mich an deinen code gesetzt und angefangen ich pascal mässig zu bereinigen.
Trotzdem danke.

Ich hoffe lichtkind kann mir etwas helfen, seine Baum idee scheint das richtige zu sein. Ich mach mich jetzt mal etwas schlau was es mit diesen Bäumen auf sich hat.

Viele Grüße

naja es ist das was sie mir an der uni einreden wollen es ist etwas theoretisch
aber was solls. mein pascal ist eigerostet deswegen erklär ichs mal rein logisch.
mit nodes meine ich einen knoten in dem baum. zuerst musst du dir einen datentyp basteln der so einen knoten representiert.
diese knoten bilden eine baumartig verkette liste.
wenn du solche sachen grad nicht kennst solltest du wenigsten mit zeigern
und datentypen sattelfest sein.
so ein knoten muss beinhalten:
-knoten typ ()
-inhalt (operator oder zahl)
-liste von kindern(erster unterknoten)
-geschwisterknoten (next oder prev und next)
-parent
den typ kann man sich sparen da nur operations knoten kinder haben(unterknoten)
es wirkt jetzt vielleicht kompliziert dafür geht das berechnen dann einfach.

wenn du es so machst brauchst du auch keine hilfszeigerw weil du von jedem punkt aus wieder zurück kannst. eine weitere variable die immer auf den rootnode(spitze des baums) zeigt ist aber besser.
das was jetzt das program machen muss bei : ((1+5)+(1-2)*5)+1
ist folgendes zuerst sag ich das zeichen dann was er macht:
0. zuerst machst du einen rootpointer und einen construction pointer wie weiter unten nochmal beschrieben beide zeigen am anfang auf den selben leeren node den du am anfang machst

1. "(" -> einen unter knoten erstellen so das du jetzt 2 hast die aufeinander zeigen
0
/
-> 0

2. "(" -> dito 0
/
0
/
-> 0
...\n\n

<!--EDIT|lichtkind|1083867768-->