Ankündigung

Einklappen
Keine Ankündigung bisher.

Java in der Schule

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

    Java in der Schule

    PROJEKTBEZEICHNUNG: Kassensimulation
    PROJEKTZWECK: Mithilfe einer Simulation wollen wir feststellen, wie das zeitliche Warteverhalten zu optimieren ist.
    VERSION oder DATUM: Oktober, 2010
    WIE IST DAS PROJEKT ZU STARTEN:
    AUTOR(EN): Wir, Grundkurs 12 Informatik Schuljahr 2010/2011 erstes Halbjahr
    BENUTZERHINWEISE: Beteiligt waren: Max, Alex, Torben, Michael, Phillip, Alex, Mark, Jonas, Oliver, Jan, Pauker

    Aufgabenstellung:
    Supermarkt mit einer zu wählenden Anzahl von Kassen. (maxKassen)
    Pro Zeiteinheit (t1) kommen 0 - maxKunden zur Kasse. (kundenzahl)
    Jeder Kunde hat einen Warenkorb mit 1 - maxTeilen Inhalt.
    Jeder neue Kunde stellt sich an der kürzesten Schlange an.
    Gibt es mehrere Kassen mit gleich langer Schlange, wählt er eine beliebige.
    Hat sich ein Kunde einmal angestellt, wechselt er nicht mehr.
    Sobald er sich in die Schlange einreiht, beginnt die Wartezeit.
    Sobald er der erste in der Warteschlange ist, ist die Wartezeit beendet.
    Wird der Kunde an der Kasse bedient, nimmt man eine mittlere Scanzeit von t2 pro Warenstück an.
    (gesBearbeitungszeit= Anzahl Teile im Warenkorb * t2)
    Wenn der Kunde fertig ist, merkt man sich dessen Wartezeit bei der entsprechenden Kasse.
    Die Simulation erfolgt über einen vorher festgelegten Zeitraum. (t3)

    Lösungsidee:
    Wir haben eine Schleife, die t3 mal durchlaufen wird. (praktisch ein Durchlauf pro sec.)
    Nach jedem Zeitraum t1 kommen kundenzahl neue Kunden, die auf die Kassen verteilt werden.
    In jedem Durchlauf wird die Wartezeit jedes Kunden um 1 heraufgesetzt und gesBearbeitungszeit an
    der Kasse wird um 1 heruntergezählt.
    Sobald die Bearbeitungszeit = 0 ist der Kunde fertig und der vorderste in der Schlange ist der nächste.
    Sobald der Kunde fertig ist, merkt man sich an der Kasse seine Wartezeit.


    Kann mir jemand dabei helfen :( Das haben wir jetzz als längere aufgabe bekommen :( Ich hab absolut keine ahnng wie ich das angehen soll :(

    #2
    soll es realitätsnah mit der uhr ablaufen oder nur als modell? außerdem wärs gut zu wissen was ihr bisher so behandelt habt sonst merkt dein lehrer ja direkt dass du es nich selbst gemacht hast.

    Kommentar


      #3
      zunächst würde ich nen dynamischen array erstellen, der variiert je nachdem wieviele maxKassen ihr habt. der array bekommt dann noch ne 2. dimension mit sämtlichen Kunden, wobei jeder wiederum ne dimension maxArtikel bekommt.

      jetzt ne schleife die jeweils alle maxArtikel runterzählt und bei 0 den jeweiligen Kunden aus dem array entfernt und die restlichen nachrückt. anschließend noch ne funktion außerhalb der main basteln, die neue Kunden auf die einzelnen kassen verteilt (schleife zählt die 2. dimension durch und wählt die kasse mit den wenigsten kunden). bei gleicher anzahl an kunden math.random();

      Kommentar


        #4
        1. klassendiagramm skizzieren (1x/2x/x-mal zum verfeinern/verbessern) - das hilft bei völliger ahnungslosigkeit oft sehr!

        1.1 festlegen welche klassen du überhaupt brauchst + attribute, sichtbarkeiten, interfaces, etc..

        2. "Sobald der Kunde fertig ist, merkt man sich an der Kasse seine Wartezeit." bis das Programm beendet wird oder permanent ?

        3. "Grundkurs" -> habt oder macht ihr mit (mehrdimensionalen) arrays ?

        4. welche bibliotheken dürft ihr verwenden? oder seit ihr alg komplett auf euch selbst gestellt und dürft rumprobieren/nutzen was ihr wollt (diese frage gilt für alle meiner punkte außer 1.) ? ..vllt hab ich einfach übersehen DAS man bestimmte sachen einfach braucht und es erübrigt sich die ein oder andere frage von 1-3..

        5. da specter (#3) es erwähnt hat ("anschließend noch ne funktion außerhalb der main [..]") -> ich würde alle methoden außerhalb der main machen und von der main aus nur die verschiedenen methoden aufrufen (find ich übersichtlicher) -> also nur das nötigste in die main



        Kommentar


          #5
          Willst du es vernünftig machen? Dann schreib dir nen halbwegs allgemeinen Simulator - da du nicht viel brauchst, ist das auch relativ einfach (wenn du java halbwegs beherrschst ;-) ). Das ganze ist dann ein "Next-Event Simulator", der da rausspringen sollte (findest du sicher ne Menge zu).

          Das ganze bedeutet nicht mehr, als das du nen Terminkaleder hast, zu dem eine Zeit gespeichert ist und ein Event, das zu dem Zeitpunkt stattfindet. Es muss halt irgendwas da drin stehen, und dann gehts los: Das zeitlich vorderste Event (=Eregnis) nimmst du und arbeitest es ab. Dann das nächste usw. Ereignisse können naürlich auch neue erzeugen.

          Was brauchst du dafür?
          1. Eine SImulations-Klasse. Die hat den Terminkalender (Queue oder sowas), und arbeitet den nacheinander ab. Mach dir ne methode wie scheduleEventIn(Event pEvent, int time), um neue Events eintragen zu können. Und dann sowas wie runUntil(int time), um die Simulation zu starten.
          1. Eine abstrakte Klasse "Event" oder so, mit den methoden getEventTime() (gibt die Zeit zurück, zu dem das Event sattfinden soll) und ne abstracte mehtode run(). Und der Konstruktor sollte vielleicht auch noch die SImulationklasse bekommen, damit sich das Event neu in den Terminkalendar eintragen kann. Die abstrakte methode beinhaltet halt das, was gemacht werden soll wenn das event stattfinden und wir dann von der jeweiligen Ableitung implementiert.
          Bei deinem Beispiel muss es zum Beispiel das Ereignis: "Erzeuge Kunde" geben. Dann baust du dir die Klasse "class CustomerCreationEvent extends Event" und run muss dann hlat folgendes machen:
          - Auswürfeln, wie viele Kunden zu erzeugen sind
          - Kunden in die Warteschlangen verteilen
          - in t1 Zeiteinheiten neu in den Terminkalendar eintragen

          Genaus machst du das mit allen anderen EReignissen, die du oben beschrieben hast.

          Ich weiß halt nciht wie viel Ahnung du hast, das ganze wirkt vielleicht sehr umständlich, aber eigetnlcih ist es sehr elegant und da diene Simulation sehr einfach ist, musst du auch gar nicht so viel aufwand in das allgemeine Simulations-Framework stecken und erhästst trotzdem ein sehr eleganges Programm das man auch verstehen kann :-)

          Kommentar


            #6
            Der Vorschlag von Trulli klingt nach nem soliden Plan würde ich auch in einer ähnlichen Art realisieren.
            Das Problem ist wahrscheinlich nur, dass der TE wenn er schon hier nachfragt wahrscheinlich noch nicht soviel Ahnung von JAVA und Programmierparadigmen allgemein hat.
            Falls er noch G9 ist und erst seit ein paar Wochen Informatik GK hat, hat er mit Sicherheit von abstrakten Klassen etc. nichts gehört und es wird wahrscheinlich darauf hinaus laufen alles irgendwie in die static void main und andere static methoden in ner random Klasse reinzukloppen.

            Also ohne weitere Rückmeldung vom TE wird es schwer weiter zu helfen.

            Kommentar


              #7
              so auf die schnelle: http://pastebin.com/c0DqZT3t

              Kommentar


                #8
                danke schonmal an alle :) Ich bin jetzt gerade in der 12ten klasse o0 aber wie gesagt, ich versteh echt nichts von java, eigentich wollte ich informatik auch seit 2 jahren abwählen aber geht nicht :( also muss ich das gezwungenerweise machen :(

                Also wir haben gerade so ein thema dynamische datenstrukturen.. ICh weiß nicht ob euch das weiterhilft :P Mir zumindest nicht :(

                Kommentar


                  #9
                  Dann sollst du wahrscheinlich hauptsächlich die Queue selber programmieren. Wie lange beschäftigt ihr euch schon mit Java? Sind Referenzen und Klassen ein Begriff? Rekursion? Was "kannst" du in Java?

                  Wenn du nichts kannst, ist das wohl zu schwer.

                  Queues kannst du gut als Ringliste oder lineare Liste mit Zeiger auf Anfang und Ende implementieren.
                  http://de.wikipedia.org/wiki/Warteschlange_%28Datenstruktur%29

                  Hier mal ganz simpel implementiert:

                  Spoiler: 

                  public class Controller {

                  public void go(){
                  RingList list = new RingList();

                  list.insert(1);
                  list.insert(2);
                  list.insert(3);
                  list.insert(4);
                  list.insert(5);
                  list.insert(6);

                  list.delete(6);
                  list.delete(5);
                  list.delete(4);
                  //list.delete(3);
                  //list.delete(2);
                  //list.delete(1);

                  list.traverse();
                  }

                  public static void main(String[] args){
                  Controller c = new Controller();
                  c.go();
                  }
                  }



                  [spoiler]
                  public class RingList {

                  Node tail;
                  int size;

                  public RingList(){
                  this.tail=null;
                  this.size=0;
                  }

                  public void insert(int key){
                  Node temp= new Node(key);
                  if(tail==null){
                  tail=temp;
                  temp.setNext(tail);
                  size++;
                  return ;
                  }
                  temp.setNext(tail.getNext());
                  tail.setNext(temp);
                  size++;
                  }

                  public void traverse(){
                  int i=0;
                  Node aktuell = tail.getNext();
                  if(tail==null){
                  return ;
                  }
                  while(i

                  Kommentar


                    #10
                    Kann dir ne Implementation mit Threads und dem ganzen Krams anbieten.

                    Allerdings ohne die Wartezeit, aber das ist ja n Klaxx

                    Hatten ne ähnliche Aufgabe irgendwann mal an der uni.

                    Threadprogrammierung kann ein wenig too much sein für sowas, aber spricht das Problem mit Ressourcen (Kassen) und Nutzung durch viele Klienten (Threads) durchaus an.

                    Aber da hier irgendwas von Wartezeit bzw. ner Gesamtzeit die Rede ist musst du eigentlich zwangsweise auf Threads und Sleep funktionen ausweichen, mit Aktivem warten (Schleife zählen) zu programmieren ist humbug :)

                    Kommentar


                      #11
                      [quote]hi postete
                      Dann sollst du wahrscheinlich hauptsächlich die Queue selber programmieren. Wie lange beschäftigt ihr euch schon mit Java? Sind Referenzen und Klassen ein Begriff? Rekursion? Was "kannst" du in Java?

                      Wenn du nichts kannst, ist das wohl zu schwer.

                      Queues kannst du gut als Ringliste oder lineare Liste mit Zeiger auf Anfang und Ende implementieren.
                      http://de.wikipedia.org/wiki/Warteschlange_%28Datenstruktur%29

                      Hier mal ganz simpel implementiert:

                      Spoiler: 

                      public class Controller {

                      public void go(){
                      RingList list = new RingList();

                      list.insert(1);
                      list.insert(2);
                      list.insert(3);
                      list.insert(4);
                      list.insert(5);
                      list.insert(6);

                      list.delete(6);
                      list.delete(5);
                      list.delete(4);
                      //list.delete(3);
                      //list.delete(2);
                      //list.delete(1);

                      list.traverse();
                      }

                      public static void main(String[] args){
                      Controller c = new Controller();
                      c.go();
                      }
                      }



                      [spoiler]
                      public class RingList {

                      Node tail;
                      int size;

                      public RingList(){
                      this.tail=null;
                      this.size=0;
                      }

                      public void insert(int key){
                      Node temp= new Node(key);
                      if(tail==null){
                      tail=temp;
                      temp.setNext(tail);
                      size++;
                      return ;
                      }
                      temp.setNext(tail.getNext());
                      tail.setNext(temp);
                      size++;
                      }

                      public void traverse(){
                      int i=0;
                      Node aktuell = tail.getNext();
                      if(tail==null){
                      return ;
                      }
                      while(i

                      Kommentar


                        #12
                        MurkZ postete
                        Kann dir ne Implementation mit Threads und dem ganzen Krams anbieten.

                        Allerdings ohne die Wartezeit, aber das ist ja n Klaxx

                        Hatten ne ähnliche Aufgabe irgendwann mal an der uni.

                        Threadprogrammierung kann ein wenig too much sein für sowas, aber spricht das Problem mit Ressourcen (Kassen) und Nutzung durch viele Klienten (Threads) durchaus an.

                        Aber da hier irgendwas von Wartezeit bzw. ner Gesamtzeit die Rede ist musst du eigentlich zwangsweise auf Threads und Sleep funktionen ausweichen, mit Aktivem warten (Schleife zählen) zu programmieren ist humbug :)
                        sowas hatte er 100%ig noch nicht wenn sie gerade erst die dynamischen datenstrukturen machen.

                        Kommentar


                          #13
                          Naja, wie willst du sonst die Zeit reinbringen?

                          Wenn die Simulation nach ner bestimmten Zeit abbrechen soll muss man nunmal n zweiten Thread bauen, kannst ja nicht in der Main ne schleife laufen lassen...

                          Kommentar


                            #14
                            richtig krass.
                            bin jetzt oberstufe (13) in wirtschaftsinformatik (4 stündig) und wir haben im entferntesten nicht so schwere aufgaben stellungen wie ihr in der 12ten.

                            Kommentar


                              #15
                              MurkZ postete
                              Naja, wie willst du sonst die Zeit reinbringen?

                              Wenn die Simulation nach ner bestimmten Zeit abbrechen soll muss man nunmal n zweiten Thread bauen, kannst ja nicht in der Main ne schleife laufen lassen...
                              da steht zeiteinheit in der aufgabenstellung also muss man die zeit an sich nicht mit einbauen und kann es über schleifen lösen die einfach dann den vektor oder was auch immer er zum speichern der daten nimmt einzeln hochzählt.

                              Kommentar

                              Lädt...
                              X