Programmierprobleme

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen zum Einsatz von Cookies
    Beachten Sie zudem unsere Datenschutzerklärung: Pirateboard.net - Datenschutzerklärung

    • Wow, so viel hatte ich nicht erwartet!!
      Vielen, vielen Dank!!!

      Ein paar Sätz dazz:

      1. Was hast du denn abgeändert damit das erste Problem behoben wurde?
      2. Das oder musste ein und sein richtig? Das habe ich nämlich auch gestern noch gesehen anders hätte es garkeinen Sinn gemacht.

      3. Das mit den Namen war so vorgegeben das habe ich nicht bestimmt :s

      4. Der Ansatz von ihm war auch super, aber könnte ich nicht jetzt mit dem was ich habe weitermachen? So würde es also nicht klappen ja?

      Ich versuche es dann mal auf die andere Weise und benutze deine Main Methode um es immer wieder zu testen.

      PS: Hast du vielleicht zufällig auch das duplicate angeguckt? Das lief?
      If I can't even protect my captain's dream, then whatever ambition I have is nothing but just talk.
    • 1) Es gibt mehrere Wege das Problem zu beheben. Ob du nun den vorhandenen Code leicht abänderst, eine neue Zeile einfügst oder was ganz anderes machst ist egal. Wichtig ist nur, dass du im nächsten Schritt nicht das nächste - da gerade eingefügte - sondern übernächste Element nimmst.

      2) ja

      3) Wie aus meinem dritten Punkt hervorgeht, hatte ich dies schon vermutet. Aber schön, dass du es noch einmal bestätigt hast.

      4) Natürlich kannst du deine Variante auch weiter verfolgen. Du musst nur alle Referenzen/Zeiger umändern, um die Elemente auch wirklich auszutauschen. Und du musst sicherstellen, dass alle drei existieren, bevor du die Vertauschung vornimmst.

      An dieser Stelle fällt mir noch ein Tipp ein, den ich vorhin bei dem Haufen an Text vergessen hatte:
      Bei Listen bietet es sich an immer ein leeres dummy-Element mitzuschleppen. Der Speicheraufwand ist minimal und in fast allen Fällen vernachlässigbar. Auf der anderen Seite ersparrt man sich die ständigen Überprüfungen und Sonderbehandlungen von first==null.

      PS) Die Duplikat-Erzeugung wird in der main mit getestet und auch ausgegeben. Mit mehr als dem einen dort angegebenen Beispiel habe ich es nicht getestet. Bei Tests sollte man auch immer die Randfälle mit beachten - z.B. leere Listen. Dies habe ich an dieser Stelle folglich nicht gemacht.
    • Hey Leute!

      Hab ne aufgabe bekommen und bin überfordert da ich wirklich über keine programmierkenntnisse verfüge... o:
      Nun zu der aufgabe: Ich soll mit Visual Studio 2013 Express ein WPF Projekt erstellen, sprich den windows taschenrechner nach bauen. Bin über jede hilfe und jeden tipp dankbar.
    • Da es mit Code sehr viel wird, will ich nur eine allgemeine Idee.

      Wenn ich viele aneinandergeordnete Dreiecke habe (Triangles), bei denen immer zwei durch eine Kante verbunden sind und ich einen Punkt rauslöschen will, der auf einer Kante liegt, können davon mehrere Dreiecke betroffen sein. Nun lösche ich also die Kante. Die betroffenen Dreiecke brauchen jetzt neue Verweise bzw. werden neu untereinander verbunden, dazu werden neue Kanten erstellt.

      Ich gehe wie folgt vor: Ich suche nach allen Dreiecken die mit dem Punkt in Verbindung stehen. Dann nehme ich davon die Kanten. Wenn z.b. ein Punkt am Ende von Kante a und b liegt, dann speichere ich mir c separat ab. Später werden die Kanten a und b gelöscht und c wird mit einem anderen Dreieck, dessen kanten auch gelöscht wurden, verknüpft.

      Nun habe ich folgendes Problem:

      Ich bekomme keine Liste von Dreiecken o.Ä., sondern nur den Anfang, also root. Das ist das erste Dreieck.
      Ich gehe in einer Hilfsmethode alles durch und gebe alle Dreiecke als liste wieder.
      Diese benutze ich auch in dieser Aufgabe. Nun steht beim Test "expected 3 Edges, but was 17".

      Ich nehme an, dass dies daraus folgt dass ich auf meiner erstellten liste arbeite und die ursprünglichen Dreiecke nicht verändere. Und das ist mein Problem. Wie kann ich die eigentlichen Dreiecke bearbeiten?

      Ich hoffe ich war so verständlich wie möglich. Danke schonmal!

      PS: Ich darf nicht die alte Liste löschen und eine neue erstellen, Dreiecke die nicht betroffen sind dürfen nicht verändert werden.
      If I can't even protect my captain's dream, then whatever ambition I have is nothing but just talk.

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von Lorenor D. Zorro ()

    • Ich weiß nicht, ob es nur mir so geht, aber ich verstehe leider die Aufgabenstellung schon nicht. Hast du eine Punkt-Wolke, die du trianguliert hast, nun einen Knoten löschen willst und deshalb an der Stelle neu triangulieren musst? Oder hast du eine "Kette an Dreiecken" und beim Löschen eines Punktes werden die zwei Dreiecke zu einem? Oder ist das Richtige noch nicht dabei?

      Was die große Menge an Quellcode angeht, früher konnte man Dateien an einem Beitrag anhängen - dazu gibt es auch einen Hilfeeintrag. Aber da ich die Funktion aktuell nicht finden kann, wurde dies vllt. mittlerweile abgeschafft. Deshalb habe ich zu den Dreieck-Netzen jetzt auch keine Bilder angehangen.
      Wie umfangreich der Code-Tag ist, weiß ich auch nicht, bei einigen gibt es die Möglichkeit Scrollleisten zu haben, so dass der Beitrag nicht endlos wird. Aber ob es das auch hier gibt... k.A..
    • img5.fotos-hochladen.net/uploa…eenshot2015eb9ioykm3d.png
      Das Bild dürfte es verdeutlichen.

      Ein Punkt kann von mehreren Kanten erreicht werden. Wird dieser gelöscht müssen die Triangles angepasst werden.

      Beim Test steht, dass am Ende 3 Kanten weniger da sein müssen. Sind es am Anfang 20, müssen es also 17 sein.

      Nun erstelle ich in einer Hilfsmethode ausgehend von root eine LinkedList, indem ich alle Triangles in die Liste speichere und rekursiv die Nachbarn aufrufe. Die Liste ist richtig und vollständig, ich erfasse alle vorhandenen Dreiecke und Edges. Dies waren zwei vorherige Aufgaben.

      Nun muss ich die Aufgabe deletePoint lösen, in der mir ein Punkt übergeben wird. Ich muss die betroffenen Triangles suchen, davon die Edges die betroffen sind und diese Triangles dann löschen ( also Referenz darauf löschen ). Dies zeigt das mittlere Bild.Danach muss ich die neuen Triangles erstellen wie rechts im Bild zu sehen ist.

      Ich rufe die Hilfsmethode auf und speichere die Liste in einer tenporären Liste. Also z.b.

      list = getAllTriangles();

      Jedoch verändere ich bei den Operationen auf dieser Liste dann nur meine temporären Dreiecke, oder?
      Wenn ich einen Punkt in list lösche, ändert das nichts am eigentlichen Triangle, oder? Doch wie schaffe ich eben genau das?

      Bin Java-Anfänger also nicht wundern wenn dumme Fehler drin sind. Danke schonmal!
      If I can't even protect my captain's dream, then whatever ambition I have is nothing but just talk.
    • Ohne konkreten (kompletten) Code etwas zu sagen, ist schwer, vor allem auf Fragen wie:

      Jedoch verändere ich bei den Operationen auf dieser Liste dann nur meine temporären Dreiecke, oder?
      Wenn ich einen Punkt in list lösche, ändert das nichts am eigentlichen Triangle, oder? Doch wie schaffe ich eben genau das?

      oder

      Ich nehme an, dass dies daraus folgt dass ich auf meiner erstellten liste arbeite und die ursprünglichen Dreiecke nicht verändere. Und das ist mein Problem. Wie kann ich die eigentlichen Dreiecke bearbeiten?

      da dies sehr von den verwendeten Datenstrukturen und deren Umgang abhängt. Wenn Beispielsweise die Funktion eine Kopie der Liste erstellt, kann alles was mit dessen Rückgabewert gemacht wird nur auf dieser Kopie und nicht dem Original geändert. Wird später wieder das Original verwendet liegt das natürlich unverändert vor. Wenn diese Informationen gar nicht in der Form vorliegen, sondern von der Funktion extra generiert wird helfen Änderungen da auch nicht. Das gleiche gilt auch für die Punkte und Kanten. Es ist nicht klar, welche Daten direkt vorliegen und verändert werden müssen und welche "On-the-fly" generiert werden und bei denen eine Änderung irrelevant ist. Welche Informationen liegen redundant vor, müssen also an mehreren Stellen verändert werden? Welche Daten sind "immutable" und müssen deshalb im besonderen Beachtet werden? Und so weiter.
      Natürlich sind nicht immer alle Informationen notwendig. Aber aus eigener Erfahrung weiß ich, dass es als "Eingeweihte" teils schwer ist festzustellen, welche Informationen für "Außenstehende" notwendig sind und auf welche verzichtet werden kann. Das soll keine Anklage oder etwas sein, ich hoffe nur dir damit klar zu machen, warum es für uns "Außenstehende" teils sehr scher ist, dir zu helfen, wenn du nicht den kompletten Code angibst.
      Leute die (sehr) viel mit Java arbeiten kennen Standardfehler der Menschen und können vllt. auch so helfen, indem sie raten, dass du solche Fehler gemacht hast. Auf mich trifft das leider nicht zu, ich nutze Java nur, wenn es notwendig ist, also quasi nie. :P

      Nun zu dem Quellcode, den ich gesehen habe. Ich gebe einfach mal wieder, wie ich den Quellcode lese.
      Du holst dir eine Liste aller Dreiecke. Diese Liste gehst du durch und merkst die alle Kanten der Dreiecke, die den zu löschenden Punkt enthalten. Die Liste aller dieser Kanten gehst du durch und löschst alle Kanten, die den Punkt enthalten. Danach hast du alle Kanten, die das Loch umschließen, wenn der Punkt gelöscht wird.
      In dem zweiten großen Bereich gehst du danach jede Zweiter-Kombination dieser Kanten durch und schaust nach, ob die einen gemeinsamen Punkt haben. Dabei überprüfst du evtl. (kann ja nicht in die Funktion haveMatchingPoints sehen), ob die Kanten die selben sind. Wenn die Kanten min. einen gemeinsamen Punkt haben ermittelst du diesen und verbindest die jeweils anderen Punkte mit einer virtuellen Kante. Mit diesen drei Kanten erstellst du ein neues Dreieck, dass du der (lokalen) Liste der Dreiecke hinzufügst.
      Die Funktion endet dann, nachdem du für jede Kombination der Kanten mit (min.) einem gemeinsamen Punkt ein neues Dreieck angelegt und der (lokalen) Liste hinzugefügt hast.

      Ich habe dein Bild mal schnell, aber hässlich, nachgebildet und am Ende die Dreiecke farbig hinzugefügt, wie sie meinem aktuellen Verständnis nach dein Quellcode erstellt. Ja, es ist ein wenig unübersichtlich, das muss aber so sein, da die Dreiecke teilweise übereinander. Ein Loch bleibt aber trotzdem noch über. Es sind übrigens 5 oder 10 neue Dreiecke, je nach dem, was deine haveMatchingPoints-Funktion macht.
      Bild(Edit:entfernt)

      Das grobe Vorgehen beim Löschen kann z.B. sein:
      • alle Dreiecke mit dem Knoten finden
      • die nach Löschen zurückbleibenden Kanten merken
      • alle Dreiecke mit dem Punkt löschen
      • alle Kanten mit dem Punkt löschen
      • entstandene Loch sukzessive neu triangulieren

      Und wenn ich das richtig verstanden habe, dann ist dies auch dein Vorgehen, wobei du bei einigen Punkten bei der Umsetzung noch Probleme hast. Z.B. steht bei dir ein Kommentar "// loeschen der referenzen auf die dreiecke (funktionirt nicht)". Da kann ich dir aber, wie am Anfang dieses Beitrages geschrieben, nicht helfen. Ich sehe nur, dass Funktionen aufgerufen werden.

      Dann noch eine Sache, die mich nur interessiert, völlig ohne Bewertung. Habt ihr gelernt den Kommentar nach dem Code zu schreiben? Ich habe bisher - zumindest aktiv - nur die Variante gesehen, dass der Kommentar den Code beschreibt, der danach kommt; also quasi einleitet, wie es sein soll (Kommentar) und dann kommt, wie es ist (echter Code). Das soll, wie gesagt, keine Bewertung sein, du kannst ja nichts dafür, dass ich seit Jahren etwas anderes gewöhnt bin. ;)

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Estocitus () aus folgendem Grund: Bild-Link entfernt

    • Erstmal: Danke!

      Zu den Kommentaren:

      In der Schule haben wir sie rechts neben den Code geschrieben, in der Uni eigentlich so wie du es sagst, ich hab das nur kurz für dich hinzugefügt und nicht darauf geachtet, allerdings habe ich auch verschoedene Versionen in der Uni gesehen. :s

      Und danke für deine Ideen! Das was du sagst stimmt ich habe vergessen abzufragen ob der Punkt der selbe ist bzw. muss mir MatchingPoints mal angucken.

      Wie du sagst eestelle ich die Triangel lokal und das ist ja mein Ursprungsproblem. Ich weiß nicht wie ich es dann in der Triangulation habe, oder ist es dann vorhanden?

      PS: Falls du magst kannst du mir eine Email o.Ä. geben, dann kann ich dir den Code mal zeigen.
      If I can't even protect my captain's dream, then whatever ambition I have is nothing but just talk.
    • Letztendlich kann ich dir nur sagen, dass du aufpassen musst, das Original zu verändern, wie das genau aussieht, hängt von deinem Code ab. Ich habe aktuell leider nicht mehr Zeit mir deinen Quellcode im Detail anzusehen und muss es deshalb bei diesen kleinen Hinweisen belassen.

      Bei dem Ausfüllen des Loches musst du bedenken, dass du einmal benutze Kanten nicht noch einmal verwenden solltest, stattdessen hast du die neue Kante vom neuen Dreieck, die du noch mit weiteren Dreiecken verbinden musst.

      Ich habe mal ein "kleines" Beispiel zwecks Referenz und Kopie erstellt. Diese Beachtung zwecks Änderung Original/Kopie musst du auch bei Bilbiotheks-Funktionen vornehmen. Ein weiteres Beispiel für die Beachtung von Variablen-Änderungen und Set-Funktionen gibt es z.B. bei Stack Overflow.

      Brainfuck-Quellcode

      1. [{[<2, 1>, <3, 2>], [<3, 2>, <1, 2>], [<1, 2>, <2, 1>]}, {[<2, 3>, <3, 2>], [<3, 2>, <1, 2>], [<1, 2>, <2, 3>]}]
      2. ----------------
      3. [{[<2, 1>, <3, 2>], [<3, 2>, <1, 2>], [<1, 2>, <2, 1>]}, {[<2, 3>, <3, 2>], [<3, 2>, <1, 2>], [<1, 2>, <2, 3>]}, {[<3, 3>, <2, 3>], [<2, 3>, <3, 2>], [<3, 2>, <3, 3>]}]
      4. ----------------
      5. [{[<2, 1>, <3, 2>], [<3, 2>, <1, 2>], [<1, 2>, <2, 1>]}, {[<2, 3>, <3, 2>], [<3, 2>, <1, 2>], [<1, 2>, <2, 3>]}, {[<1, 1>, <1, 2>], [<1, 2>, <2, 1>], [<2, 1>, <1, 1>]}]
      6. #########################################
      7. [{[<2, 1>, <3, 2>], [<3, 2>, <1, 2>], [<1, 2>, <2, 1>]}, {[<2, 3>, <3, 2>], [<3, 2>, <1, 2>], [<1, 2>, <2, 3>]}, {[<1, 1>, <1, 2>], [<1, 2>, <2, 1>], [<2, 1>, <1, 1>]}]
      8. ----------------
      9. [{[<2, 1>, <3, 2>], [<3, 2>, <1, 2>], [<1, 2>, <2, 1>]}, {[<2, 3>, <3, 2>], [<3, 2>, <1, 2>], [<1, 2>, <2, 3>]}, {[<3, 3>, <2, 3>], [<2, 3>, <3, 2>], [<3, 2>, <3, 3>]}]
      10. ----------------
      11. [{[<2, 1>, <3, 2>], [<3, 2>, <1, 2>], [<1, 2>, <2, 1>]}, {[<2, 3>, <3, 2>], [<3, 2>, <1, 2>], [<1, 2>, <2, 3>]}, {[<1, 1>, <1, 2>], [<1, 2>, <2, 1>], [<2, 1>, <1, 1>]}]
      Alles anzeigen



      Java-Quellcode

      1. import java.util.LinkedList;
      2. public class CEinfachEtwas {
      3. /** \brief Ein 2D-Punkt im Raum.
      4. *
      5. */
      6. class CPoint{
      7. public int x;
      8. public int y;
      9. public CPoint(int iX, int iY){
      10. x=iX;
      11. y=iY;
      12. }
      13. @Override
      14. public String toString(){
      15. return "<"+String.valueOf(x)+", "+y+">";
      16. }
      17. @Override
      18. public boolean equals(Object aObject){
      19. if((aObject == null) || !(aObject instanceof CPoint)){
      20. return false;
      21. }
      22. //ob es gleich this is, muss nicht extra getestet werden
      23. return ((CPoint)aObject).x==x && ((CPoint)aObject).y==y;
      24. }
      25. }
      26. /** \brief Eine Kante im 2D-Raum bestehend aus zwei Punkten.
      27. *
      28. */
      29. class CEdge{
      30. public CPoint p1;
      31. public CPoint p2;
      32. public CEdge(CPoint aPoint1, CPoint aPoint2){
      33. p1 = aPoint1;
      34. p2 = aPoint2;
      35. }
      36. @Override
      37. public String toString(){
      38. return "["+p1+", "+p2+"]";
      39. }
      40. @Override
      41. public boolean equals(Object aObject){
      42. if((aObject == null) || !(aObject instanceof CEdge)){
      43. return false;
      44. }
      45. //ob es gleich this is, muss nicht extra getestet werden
      46. return (((CEdge)aObject).p1==p2 && ((CEdge)aObject).p2==p1) ||
      47. (((CEdge)aObject).p1==p1 && ((CEdge)aObject).p2==p2);
      48. }
      49. }
      50. /** \brief Ein Dreieck im 2D-Raum bestehend aus drei Kanten.
      51. *
      52. */
      53. class CTriangle{
      54. public CEdge e1;
      55. public CEdge e2;
      56. public CEdge e3;
      57. public CTriangle(CPoint aPoint1, CPoint aPoint2, CPoint aPoint3){
      58. e1 = new CEdge(aPoint1, aPoint2);
      59. e2 = new CEdge(aPoint2, aPoint3);
      60. e3 = new CEdge(aPoint3, aPoint1);
      61. }
      62. public CEdge getEdge(int iNumber){
      63. if(iNumber==0){
      64. return e1;
      65. }else if(iNumber==1){
      66. return e2;
      67. }else if(iNumber==2){
      68. return e3;
      69. }else{
      70. return null;
      71. }
      72. }
      73. @Override
      74. public String toString(){
      75. return "{"+e1+", "+e2+", "+e3+"}";
      76. }
      77. }
      78. /** kleine Hilfsfunktion für kompakteren Code */
      79. public CPoint p(int x, int y){
      80. return new CPoint(x,y);
      81. }
      82. /** \brief Diese Klasse erstellt eine Liste von Dreiecken.
      83. *
      84. */
      85. class CTriangleList{
      86. LinkedList<CTriangle> mList;
      87. public CTriangleList(){
      88. mList = new LinkedList<CTriangle>();
      89. mList.add(new CTriangle(p(2,1), p(3,2), p(1,2)));
      90. mList.add(new CTriangle(p(2,3), p(3,2), p(1,2)));
      91. }
      92. public LinkedList<CTriangle> getList(){
      93. return new LinkedList<CEinfachEtwas.CTriangle>(mList);
      94. }
      95. public LinkedList<CTriangle> getListV2(){
      96. return mList;
      97. }
      98. public boolean addTriangle(CPoint newPoint, int iNumberTriangle, int iNumberEdge){
      99. //Var init
      100. CEdge tmpEdge;
      101. //Prüfung der Validität der Nummer-Angaben
      102. if(iNumberEdge<3 && iNumberEdge>=0 && iNumberTriangle>=0 && iNumberTriangle<mList.size()){
      103. tmpEdge = mList.get(iNumberTriangle).getEdge(iNumberEdge);
      104. if(tmpEdge!=null){
      105. mList.add(new CTriangle(newPoint, tmpEdge.p1, tmpEdge.p2));
      106. return true;
      107. }
      108. }
      109. return false;
      110. }
      111. @Override
      112. public String toString(){
      113. StringBuilder aBuilder = new StringBuilder();
      114. aBuilder.append("List["+mList.size()+"]: \n");
      115. for(CTriangle tmpTriangle: mList){
      116. aBuilder.append(" " + tmpTriangle + "\n");
      117. }
      118. return aBuilder.toString();
      119. }
      120. }
      121. /** \brief Dies ist die Hauptfunktion für dieses Beispiel.
      122. *
      123. */
      124. public void doAll(){
      125. //Var init
      126. CTriangleList aMyTriangleList;
      127. LinkedList<CTriangle> aList1;
      128. LinkedList<CTriangle> aList2;
      129. LinkedList<CTriangle> aList3;
      130. aMyTriangleList = new CTriangleList();
      131. aList1 = aMyTriangleList.getListV2();
      132. System.out.println(aList1);
      133. System.out.println("----------------");
      134. //nun ein Dreieck zur (lokalen) Liste hinzufügen
      135. aList2 = aMyTriangleList.getList();
      136. aList2.add(new CTriangle(p(3,3), p(2,3), p(3,2)));
      137. System.out.println(aList2);
      138. System.out.println("----------------");
      139. //und originale Liste verändern
      140. aMyTriangleList.addTriangle(p(1,1), 0, 2);
      141. aList3 = aMyTriangleList.getList();
      142. System.out.println(aList3);
      143. //und nun noch einmal alle Listen ausgeben
      144. System.out.println("\n#########################################\n");
      145. System.out.println(aList1);
      146. System.out.println("----------------");
      147. System.out.println(aList2);
      148. System.out.println("----------------");
      149. System.out.println(aList3);
      150. }
      151. }
      Alles anzeigen

    • Vielen vielen Dank an dich! Ich melde mich sobald ich die Aufgabe habe.

      Muss aber erst meine Theoriesachen weitermachen bevor ich am Programm weiterschreibe und wollte kurz fragen ob das was ich habe stimmt, falls sich jemand mit Komplexität auskennt?

      Ich muss mich mit asymptotischer Komplexität befassen. Ich habe 3 Aufgaben dazu.
      Die erste besteht darin, folgende Funktionen nach Komplexität zu sortieren. Ich habe mich mal ranversucht und wollte fragen, ob das so Sinn ergibt..

      e^ln e < 42^42 < log(log(n)) < Wurzel(log(n)) < e^log(log(n²)) <log(n²) < log(n)^log(log(n)) < log(n)^3,5 < Wurzel(n) < 1.337^n < 2^n < (n+1)!

      Stimmt das so? :S
      If I can't even protect my captain's dream, then whatever ambition I have is nothing but just talk.