wer hat 4110?

[glubschi]

hallöle,

hab grad runde 4 abgeholt und möchte davon das mittlere bsp machen (das schwere probier ich erst gar nicht), welches nr 4110 ist (boolpars).
allerdings hab ich noch etwas schwierigkeiten mit oop und so stecke ich jetzt schon bei der überlegung, welche klassen ich am besten für das programm erstellen soll. bzw wie ich die aufteilung machen soll usw...

wär nett, wenn sich gleichgesinnet oder wissende melden würden... *g*

[glubschi]

ist bei 4110 eigentlich eine eingabe der form
LoLoL oder HaHaH oder LoHxL erlaubt oder dürfen immer nur jeweils zwei zustände miteinander verknüpft werden und hier zb eine neue ebene begonnen werden mit Lo(LoL) oder Ha(HaH) usw.????

[supersonnig]

hab ich mich auch gefragt?

...

[glubschi]

LoLoL oder HaHaH ist gluab ich nicht erlaubt.
Da müsste dann stehen Lo(LoL) oder Ha(HaH). aber ich bin mir selbst auch nicht zu 100% siher.

[Vench]

Ich hab auch dieses Beispiel und genauso wenig Ahnung davon, wie von dem leichten und schweren. - Aber da sich zu boolpars jetzt einige (naja 2 halt) gefunden haben, werd ich es wohl auch versuchen. :shinner:


Ich hätt da allerdings schon ein paar ganz prinzipielle Fragen:

1) Bitte nicht gleich sauer sein wegen der Frage, aber: Was genau bedeutet eigentlich objektorientiert? Heißt das einfach, dass wir verschiedene Klassen verwenden müssen?
- Ich hab versucht aus alten Threads eine Antwort herauszulesen, aber da hab ich nur gefunden, dass Runde 4 objektorientiert sein muss und alles Mögliche was man programmieren könnte, was dann aber trotzdem nicht unbedingt objektorientiert ist.
Natürlich hab ich auch in mein javabuch geschaut, aber da steht halt nicht neben den Erklärungen :"... und wenn Sie das so programmieren, ist es objektorientiert."

2) Was ist darunter zu verstehen?:Geben Sie den endgültigen logischen Zustand der boolschen Verknüpfungen mit Hilfe einer rekursiven Prozedur an. Was ist eine rekursive Prozedur?


Ach ja, ich denke auch, dass Eingaben der Art HxLoH nicht zulaessig sind.
Daher kommt doch auch die Fehlermeldung bei der Eingabe : (Ha(Hx(LoH)))xn(n(HaL)o(Lan(LoL)) aus der Spezifikation - oder was wäre da sonst dran falsch?

[Paulchen]

Was genau bedeutet eigentlich objektorientiert?objektorientiert heißt, dass du neben Main mindestens eine klasse hast, die ein objekt darstellt, und in deinem programm von diesem objekt instanzen erstellst.
Was ist eine rekursive Prozedur?
eine rekursive prozedur ist jene prozedur, welche sich selbst aufruft, um einem ergebnis einen schritt näher zu kommen (wenn du z. B. die fakultät durch festlegung von 0!=1 und n!=n*(n-1)! berechnest)
(Ha(Hx(LoH)))xn(n(HaL)o(Lan(LoL)) aus der Spezifikation - oder was wäre da sonst dran falsch?die klammern

[martmike]

Sers

Also ich habe nur die Notwendigkeit gesehen für die Überprüfung, ob der String mehr als 16 logische Zustände enthält, und für die Auswertung einer logischen Verknüpfung, also 2 Klassen zu schreiben. Gibt es von euch Vorschläge was man noch aus der static main Methode objektorientiert loswerden kann?

[Vench]

Danke Paulchen!
Ich verstehs jetzt! :)

thx Vench

[Darkshadow_0]

Ich hab auch das beispiel und habe ein großes problem:

gefordert ist ja das die geschichte von inner heraus also ich mein wenn zb Lo(HaL) soll die klammer zuerst is klar oder?

ich positionier mit for schleife 2 vars für anfang und ende also den klammer bereich

und mit substring hohl ich mirs und überarbeite es, auch das estellen des neuen strings indem ich alles vor dem anfang marker und alles dahinter nehme und dazwischen mien teilergebnis reinhau klappt,
nur wie schick ich den neuen string, der optimalerweise den selben namen hat wie der alte (damit das prog immer wieder, bis entgültig vereinfacht läuft)
wieder in meine alte methode, und zwear so, dass sie von dem zeitpunkt an nur noch diesen benutzt??

oder wie habt ihr das gelöst?

[Paulchen]

das einfachste, nachdem hier ohnehin objektorientiert vorzugehen ist, ist, eine klasse zu schreiben, die einen boole'schen ausdruck verarbeitet; und zwar so, dass sie diesen an einem nicht in einer klammer stehenden rechenzeichen zertrennt, den linken und den rechten teil rekursiv (durch verwendung einer neuen instanz des selben objektes) berechnet und das ergebnis schließlich durch den operanden, an welchem unterteilt wurde, zu verknüpfen; abbruchbedingung für diesen rekursiven vorgang ist das vorliegen von "H" bzw. "L"
ich habe just-for-fun dieses beispiel programmiert, habe rund 30 min dafür gebraucht, also sollte es keine schwierigkeit sein, mit diesem wissen das beispiel bis übermorgen zu schaffen

[Darkshadow_0]

ok langsam und für dumme, ich habe erst einmal zuvor ein rekursiev programmiertes programm gesehn und das war ien einfach mal ein bäumchen ding (unwichtig)


du willst alo, dass ein rek programm rechenzeichen(also o a xor n ..) sucht und dann mit zeichen davor und danach verarbeitet bis eindeutiges ergebnis oder?

nur was wird mit klammern?

zb.:
(HaL)o(HoLa(LnoL)) ?? da geht das ja nicht oder??

und könntest du den code für rekusionen in java zeigen? ich finds nicht, meine mir zu Verfügung stehende literatur istn icht gerade top.

und selbst bei rekusrion läuft das alles in einer methode?? wenn ja wie? und wenn nein leibti mmer noch die frage wie das ergebnis in die rechnung wieder einbezogen wird(ich weiß das sich das durch rekursion löst nur eine etwas detailiertere erklärung wär echt toll)


PS.: meine vorgeschlagene methode kann die funktionieren? oder gibt es keinen weg mit der neuen var eingabe die alte dauerhaft zu ersetzen?

[Paulchen]

(HaL)o(HoLa(LnoL))
diese eingabe sollte meiner meinung nach zu "FALSCHE EINGABE" führen, und zwar aus zwei gründen:

es dürfen nur klammerstrukturen negiert werden, nicht die operationen selbst (keine NOR-verknüpfung gefordert)
es sollen in einer klammerebene immer nur zwei operanden durch einen operator verknüpft werden, nicht jedoch drei operanden durch zwei operatoren (so hab ich zumindest diese spezifikation verstanden)

betrachten wir als beispiel folgende eingabe:

(HaL)o(Ho(Lan(LoL)))

du schreibst eine klasse, nennen wir sie Term, erstellst eine instanz von dieser, fütterst sie mit dieser eingabe; diese klasse stellt weiters eine methode zur verfügung, welche den gegebenen ausdruck auswerten soll.
diese methode macht nichts anderes, als dass sie die vorliegende zeichenkette in zwei teilausdrücke zerlegt und jeden davon getrennt auswertet, und das soll im rahmen zweier neuer instanzen der klasse Term geschehen. die klammern stellen hier kein problem dar; ganz im gegenteil, sie erleichtern die angelegenheit sogar, da du nur einen operator suchen musst, der nicht innerhalb einer klammer steht.
das programm soll also wie folgt mit der eingabe umgehen:

(HaL)o(Ho(Lan(LoL)))

in einer schleife wird der erste operator gesucht, der nicht in einer klammer steht (du verwendest dazu eine variable, welche die aktuelle klammerebene angibt; diese hat anfangs den wert 0, findest du eine (, wird diese variable um 1 erhöht, bei ) um 1 vermindert; findest du einen operator und diese variable ist 0, so hast du das gewünschte zeichen, an dem zertrennt werden soll, gefunden). nun wird die eingabe in zwei teilausdrücke zerlegt, und zwar in (HaL) und (Ho(Lan(LoL))). nun werden zwei neue instanzen des objektes Term erstellt, die eine verarbeitet den einen teilausdruck, die andere eben den anderen.

die instanz, welche (HaL) verarbeitet, merkt, dass die gesamte eingabe in einer klammer steht => weg damit; also haben wir HaL; wieder wird ein operator gesucht, der nicht in der klammer steht, dann wird zertrennt; wir erhalten H und L. diese teilausdrücke werden wieder rekursiv (wiederum durch erstellen neuer instanzen von Term) verarbeitet; diese beiden instanzen bemerken jetzt, dass nur H und L vorliegt und die auswertungsmethode gibt entsprechend true bzw. false zurück.
jene instanz, welche HaL auswertet, weiß nun, dass ein wert true und ein wert false ist; diese beiden sind durch den operator "a" verknüpft, also wird true && false berechnet, false wird zurückgegeben. damit ist der erste teil der auswertubng abgeschlossen.

folgt der rechte teilausdruck (Ho(Lan(LoL))); dieser ist komplett von klammern umschlossen => entfernen => Ho(Lan(LoL))). suche nach operator, zerlegung in teilausdrücke: H und (Lan(LoL)).
die rekursiv auswertung von H liefert true, die auswertung von (Lan(LoL)) erfordert erneute entfernung von klammern und zerlegung in teilausdrücke, und zwar in L und n(LoL)
L liefert false; der zweite teilausdruck beginnt mit n, das streichen wir (merken uns das aber!) und werten LoL aus; zerlegung in zwei teilausdrücke (L und L), beide liefern false, verknüpfung durch oder => false. dieser ausdruck wird negiert (n vor der klammer) => true
false && true ergibt false, also ist (Lan(LoL)) false; dies war ein rechter teilausdruck, H der linke, o der operator => ergibt true
nun sind wir wieder zurück in der ersten instanz von Term; hier wird false durch oder mit true verknüpft, ergibt true; das wird auch zurückgegeben

in jener methode, welche die erste instanz von Term erstellt hat, betrachtet nun das endergebnis (true) und entscheidet, dass in diesem fall H ausgegeben werden muss; ansonsten würde L ausgegeben.

abschließed noch ein paar worte zur fehlerbehandlung: sollte irgendwo eine konstruktion auftreten, welche nicht zulässig ist (zum beispiel zu viele ) oder ( ), dann ist es wohl das einfachste, in diesem fall eine exception zu werfen, welche von der methode main aufgefangen wird; in diesem fall wird dann "FALSCHE EINGABE" ausgegeben.

jetzt sollte 4110 halbwegs verständlich sein, wenn du das immer noch nicht schaffst, kann und will ich dir nicht weiter helfen; in zwei wochen ist eprog-übungstest, und da wirst du unter enormem zeitdruck (was ich von leuten höherer semester gehört habe) problemstellungen analysieren und lösungen angeben müssen. wenn du 4110 nicht schaffst, sehe ich für dich schwarz beim übungstest (das soll dich jetzt nicht fertigmachen, das ist meine persönliche einschätzung der lage)

[Darkshadow_0]

ok danke für die info

die funktion anhand der operatoren zu zerlegen ist sicher ein guter (wahrscheinlich auch ein besserer) Weg als meiner, doch mir kommt das grauen, so knapp vorm abgabetermien nochmal von vorn anzufangen.

fals du nochmal lust hast mir nen denkanstoss zu geben hier ist das problem:

um den string richtig zu zerlegen setze ich 2 int variablen, anfang und ende
in der ersten for schleife wird im string ')' gesucht und wenn gefunden (if anweisung) die position in ende gespeichert und eine 2 te for schleife in der ersten aufgemacht, welche von ende an mit j-- sucht bis '(' und dann den wert von j in anfang speichert.
Ansich funkt das toll (ok einen ausnahmefehler mit index out of bounds habe ich) nur wenn mehrere oder gar keiner () gefunden werden gibts echte probleme
bei keiner klappt das zerlegen nicht, und fehler kommt und in else anweisung anfang=0 und ende = eingabe.length klappt beim ersten teilsegment nicht (also jened das von 0 bis anfang alles schneidet)
wenn mehrere dann überschreibt er praktisch die alten ergebnisse mit den neuen

ich post mal meinen code, vielleicht findest einen banalen fehler oder fals meine art zu denken falsch ist bitte gleich sagn

hier habe ich das problem in einer neuen datei geschrieben um die fehler zu
finden leider ohne viel erfolg:



import eprog.*;

public class test
{
public static void main(String[] args)
{
int counter = 0;
int anfang = 0;
int ende = 0;
String eingabe = EprogIO.readWord();
markierung(eingabe, counter, anfang, ende);
}





private static void markierung(String eingabe,int counter, int anfang, int ende)
{
if (counter != 1){
for (int i = 0; i < eingabe.length(); i++)
{
char c = eingabe.charAt(i);
if (c == ')'){
ende = i;
for (int j = ende+1; j > -1 ; j--)
{
char d = eingabe.charAt(j);
if ( d == '(')
{
anfang = j;



String anfangende = eingabe.substring(anfang,ende+1);
String nullanfang = eingabe.substring(0, anfang);
String endeEnde = eingabe.substring(ende+1, eingabe.length());
veraendern(eingabe,counter,anfangende,nullanfang,e ndeEnde,anfang,ende);
break;
}
else{
//dann fehlt eine klammer, also fehler beim substring
EprogIO.println("ok falsch");
}
}
}
else{
anfang = 0;
ende = eingabe.length();
if(i == eingabe.length()){
String anfangende = eingabe.substring(anfang,ende+1);
String nullanfang = eingabe.substring(0, anfang);
String endeEnde = eingabe.substring(ende+1, eingabe.length());
veraendern(eingabe,counter,anfangende,nullanfang,e ndeEnde,anfang,ende);
break;
}
}



leider funktioniert der code nur wenn der term diese struktur hat:
blabla(inhalt)blabla
bei mehreren keiner oder einem term der völlig von einer klammer umschlossen ist gehts nicht

ich versuchs zu ändern, wenn ichs schaff psot ich oder löss meinen thread aber tipps und ratshcläge warum es nicht geht oder wie ich es hinbekommen würde wären toll




Ps.: ups das edit hats nicht genommen is eh kein fehler ich hab nur zeile verlesen

und das ist nun der code ohne fehler, außer, dass ich die for shcleifen nciht zum stoppen bring, wenn mehrere () () sind dann versucht er alle auf einmal zu machn, und benutzt dabei aber noch die alten anfang ende vars

[Paulchen]

ähm wenn ich mich nicht irre hast du da einen fehler denn zb bei (HoL)
und einer var die be 0 statet und bei ( ++ hat und bei ) -- ist die var 1 und nicht 0 wenn die schleife beim operator ankommt oder??in dem fall sollte dein programm feststellen, dass der ausdruck von klammern umschlossen ist, und diese eliminieren

[Darkshadow_0]

ok danke ich habs ich bin fertig ^^^oder zuminstest fast zusammensetzen mus ichs noch.

vielen dank an alle vor allem an Paulchen der mit viel Geduld zu all meinen posts geantwortet hat.

-> und könntest du mir, nach dem 17ten also nach entgültigem ende der eprog übungen die rekursieve lösung und deine Bruchzahlversion schicken?

ich würde mir genr die codes anschaun und vielleicht lern ich dabei auch was :)


ALSO NOCHMAL EIN GROßES DANKE AN ALLE, IHR SEID TOLL