Problemlösung (einfach)

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Problemlösung (einfach)

    Also...
    sind vor kurzem mit Java angefangen.
    Das Problem hat nicht speziell mit Java zu tun, sondern ich zweifle gerade an der Umsetzung / Rechnung zu einer Aufgabe.
    Hab einen Denk-Fehler drin, bin mir sicher.

    Kurze Frage vorab: Ich würde es eigentlich mit 3 Schleifen machen, womit dann jede Situation "simuliert" und auf korrekte Möglichkeit geprüft werden kann.
    War mir nun egal und wollte es nun einfach eben schicken, was ich geschafft hab:

    Aufgabe:

    Quellcode

    1. Die drei Freunde Linda, Tim und Markus haben nach einer durchzechten Nacht zusammen für eine Taxifahrt bezahlt. Leider wissen sie nicht mehr, wer wie viel Geld dazugetan hat. Sie wissen nur noch: insgesamt hat die Fahrt 8,42€ gekostet. Linda hat mehr bezahlt als Tim, aber weniger als Markus, und hat eine Schnapszahl. ims Betrag war ungerade und lag über 1,50 €. Markus hat nur mit 50 Cent Münsen bezahlt. Wer hat nun wieviel gegeben.
    2. [B]Zusammenfassung[/B]
    3. Linda + Tim + Markus = 842 (cent)
    4. Markus > Linda > Tim
    5. (Linda % 111) == 0
    6. (Tim % 2) != 0
    7. Tim > 150
    8. (Markus % 50) == 0


    Brainfuck-Quellcode

    1. class test {
    2. public static void main(String args[]) {
    3. int a,b,c,rest,betrag,erfolgreich;
    4. boolean ergebnis = false;
    5. betrag = 842-(151+50+111); // Betrag | Alle haben wenigstens einmal bezahlt. Tim hat mehr als 1,50 bezahlt, somit wenigstens 151 Cent
    6. a=b=c=erfolgreich=0;
    7. int i = (int) (betrag / 111); // Maximale Anzahl Lindas' Betrages
    8. while (i > 0) {
    9. rest = betrag - (i * 111); // Restbetrag nach xMal Lindas Betrag
    10. if (rest > 50) rest %= 50; // Wenn Restbetrag größer als 50 (Markus), dann Restbetrag nach Markus Betrag
    11. if ((rest%2) == 0) { // Wenn Rest gerade (Folgeergebnis von Tim ist ungerade)
    12. a = (i*111)+111; // Linda
    13. b = (int)((betrag-i*111)/50)*50+50; // Markus
    14. c = betrag - (i*111 + (((betrag)-(i*111))/50)*50)+151; // Tim
    15. erfolgreich++;
    16. /* Ausgabe */
    17. System.out.println(" ----- "+erfolgreich+". Moeglichkeit -----");
    18. System.out.println("| Linda: "+a+" |");
    19. System.out.println("| Tim: "+c+" |");
    20. if (b<100) System.out.println("| Markus: 0"+b+" |");
    21. else System.out.println("| Markus: "+b+" |");
    22. System.out.println(" ---------------------------\n");
    23. }
    24. i--;
    25. }
    26. }
    27. }
    Alles anzeigen


    Mir is grad mal aufgefallen, dass ich die Beziehung zwischen Linda's und Markus' Betrag (Markus > Linda) vergessen habe. Somit ist bei der Ausgabe nur letztere Möglichkeit "richtig".


    Würde mich über eine Antwort freuen.

    ´gruß
    [size=1][FONT="Courier New"]###############_###_####_
    #_ __ #___ _ _| |_(_)__(_)__ _ _ _###############new uploads: [1] [2] [3] [4] [5] [6] [7] [8]
    |#'##\/ _ \ '_|##_| / _| / _` | ' \
    |_|_|_\___/_|##\__|_\__|_\__,_|_||_|###############Bis 28. Sept. weg[/FONT][/size]
  • Ja also es kommt halt drauf an wieviel Logik ihr da reinsetzen dürft und wieviel ihr durch stupides Durchprobieren rausbekommen sollt.
    Bei uns war es eigentlich immer so, das man schon maximale Logik in das Programm setzen sollte.

    Und wie du richtig zusammen gefasst hast kommt man auf folgende Vorraussetzungen:
    Linda + Tim + Markus = 842

    Markus > Linda > Tim
    Linda % 111 == 0
    Tim > 150 && Tim % 2 == 1
    Markus % 50 == 0

    Dadurch kann man aber weiteres folgern:
    -> Tim mindestens 151
    -> Linda mindestens 222
    -> Markus mindestens 250
    = 623 -> Restbetrag 219

    Daraus folgt
    einzige möglichkeit:

    Linda 333
    Markus 350
    Tim 159

    Wie das ganze jetzt in Code aussähe müsst ich mich noch ein weilchen hinhocken :)


    Aber jetzt erstmal schnell Simpsons angucken :)

    *edit*
    Na das ging doch einfacher als gedacht :)
    Aber es kommt wie gesagt drauf an wieviel vorarbeit du mit deinem Brain leisten darfst ;)
    Hier ist mein Lösungsansatz, der sich von deinem ein wenig unterscheidet.
    Hab aber ausreichend kommentiert :P

    PHP-Quellcode

    1. class Test {
    2. public static void main(String args[]) {
    3. // Das haben alle zusammen gezahlt
    4. final int GESAMTBETRAG = 842;
    5. // Zähler er Möglichkeiten
    6. int erfolgreich = 1;
    7. /*
    8. * Linda zahlt mindestens 222
    9. * Tim mindestens 151
    10. * Markus mindestens 350
    11. * Daher bleiben nur noch 219 Cent übrig die auf alle verteilt werden können
    12. */
    13. /*
    14. * Wir wissen das Linda mindestens 222 Cent gezahlt haben muss.
    15. * Außerdem ist Lindas Betrag eine Schnappszahl deswegen immer um 111 Cent erhöhen
    16. * Die Grenze bildet 222 + Restbetrag ( 219 Cent) = 441
    17. */
    18. for(int linda = 222; linda < 442; linda+=111 ){
    19. /*
    20. * Wir wissen das Markus mindestens 250 Cent gezahlt haben muss.
    21. * Außerdem ist Markus Betrag ein Vielfaches von 50 Cent, also um 50 erhöhen
    22. * Die Grenze bildet 250 + Restbetrag ( 219 Cent) = 476
    23. */
    24. for(int markus = 250; markus < 470; markus+=50 ){
    25. /*
    26. * Wir wissen das Tim mindestens 151 Cent gezahlt haben muss.
    27. * Außerdem ist Tim Betrag ungerade, also immer um 2 erhöhen
    28. * Die Grenze bildet 151 + Restbetrag ( 219 Cent) = 370
    29. */
    30. for(int tim = 151; tim < 371; tim+=2 ){
    31. /*
    32. * Abschliessend Prüfen ob der Gesamtbetrag stimmt und ob noch die Beziehung
    33. * Markus > Linda > Tim zu trifft. Bei Erfolg, Lösung gefunden.
    34. */
    35. if( (tim + markus + linda == GESAMTBETRAG) && ( markus > linda) && ( linda > tim))
    36. {
    37. // Ausgabe
    38. System.out.println(" ----- "+erfolgreich+". Moeglichkeit -----");
    39. System.out.println("| Linda: "+linda+" |");
    40. System.out.println("| Tim: "+tim+" |");
    41. System.out.println("| Markus: "+markus+" |");
    42. System.out.println(" ---------------------------\n");
    43. // Falls es weitere Möglichkeiten gibt Zähler erhöhen
    44. erfolgreich++;
    45. }
    46. }
    47. }
    48. }
    49. }
    50. }
    Alles anzeigen


    Achja prinzipiell wird es sicher noch einige andere Lösungswege geben.
    Zu meinem sei gesagt, das 3 inneinander geschachtelte Schleifen eigentlich nicht umbedingt so eine tolle Laufzeit haben müssen.
    Es sind immerhin doch Stolze 1100 Durchläufe. Also man kann schon noch optimieren ;)
    Der Vorteil an dieser Lösung ist, das sie einfach straightforward ist und das Fehlerpotenzial minimiert ist weil sie sehr sehr leicht ist :)
    Achja noch als letzte Anmerkung, kommentiere mehr. Dann hat man es leichter deine Lösung nachzuvollziehen. Musst ja nicht so extrem kommentieren wie ich ^^
  • stelzi dank dir erstmal vieeeelmals. Du hast dir vieeel zu viel Mühe geben. Dafür echt erstmal dicken Dank.
    Haettest den ersten Beitrag vllt komplett gelesen haettes vllt simpsons zuende schaun koennen :P

    Kurze Frage vorab: Ich würde es eigentlich mit 3 Schleifen machen, womit dann jede Situation "simuliert" und auf korrekte Möglichkeit geprüft werden kann.


    Meinte damit natuerlich verschaltete Schleifen :P
    Das ist auch nach meinem Ermessen die beste Lösung.. da es wirklich alle Möglichkeiten durchcheckt.

    Ich Dank dir jedenfalls vielmals.. brauchst auch nix weiter kommentieren oderso :P

    ´gruß
    [size=1][FONT="Courier New"]###############_###_####_
    #_ __ #___ _ _| |_(_)__(_)__ _ _ _###############new uploads: [1] [2] [3] [4] [5] [6] [7] [8]
    |#'##\/ _ \ '_|##_| / _| / _` | ' \
    |_|_|_\___/_|##\__|_\__|_\__,_|_||_|###############Bis 28. Sept. weg[/FONT][/size]
  • Hehe keine Ursache.
    Nene ich hab schon Simpsons fertig geguckt.
    Und den Code hatte ich auch sehr schnell zusammen.
    Ist nämlich wie gesagt sehr sehr einfach wenn man einfach die Schleifen laufen lässt. Da muss man sich nicht gross Gedanken machen ;)
    Und ich hab schon zuende gelesen.
    Hatte nur grade Zeit und naja... :D
    Btw ich hab sogar noch nen Fehler in einem Kommentar entdeckt. Zum glück steckt er nicht im Code ^^
    Aber Interessant ist es schon. Man könnte noch die Lösung optimieren, mit dynamischen Obergrenzen z.b.
    Das wäre schon ganz lustig :)

    Wie gesagt mit der Lösung hast du halt den Vorteil das alle möglichen Lösungen gefunden werden und das das Fehlerpotential gering ist.
    Nachteil ist bei einer anderen Problemstellung, bzw anderen Beträgen könnte es schon mal länger Dauern.
    Denn eigentlich sollte man sich schon immer Gedanken über den Algorithmus machen und man kann nicht früh genug damit anfangen ;)

    Wennst mal wieder was hast... ;)