Advertisement
Guest User

Programmlogik Kantinenverwaltung (pseudo-Code) ALEX

a guest
Dec 4th, 2016
431
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 12.16 KB | None | 0 0
  1.  
  2. /**
  3.  *
  4.  * @author alexanderkahl
  5.  */
  6. import java.util.Scanner;
  7.  
  8. /**
  9.  */
  10. public class tempPseudoCode
  11. {
  12.  
  13.     // TODO Declare and initialise class variables here
  14.  
  15.     /**
  16.      * @param args
  17.      */
  18.     public static void main(String[] args)
  19.     {
  20.        
  21.         // TODO: Declare and initialise local variables here:
  22.        
  23.         Erstelle eine Rezeptliste;
  24.         rezeptliste == new Rezeptliste();;
  25.         INPUT Rezeptliste;
  26.         - Pfad und Dateiname aus Parameterliste, Abfrage oder GUI-Element;
  27.         - Datei öffnen;
  28.         - Text auslesen bis EOF;
  29.         ;
  30.         Dabei gilt:;
  31.         for (dummy_counter = Für jede Zeile (REZEPT) in Rezepte.csv; dummy_counter <= null; dummy_counter += (1))
  32.         {
  33.             if (Rezept bereits enthalten? rezeptliste.findRezept(String REZEPT_Spalte1);)
  34.             {
  35.                 Rezeptverweis holen;
  36.                 rezept == Rezepteliste.getRezept(REZEPT_Spalte1);;
  37.             }
  38.             else
  39.             {
  40.                 Erstelle ein neues Objekt vom Typ Rezept;
  41.                 rezept == new Rezept(REZEPT_Spalte1);;
  42.             }
  43.             Zutat hinzufügen (Menge, Maßeinheit, Zutatbezeichnung);
  44.             rezept.addZutat(REZEPT_Spalte2, REZEPT_Spalte3, REZEPT_Spalte4);;
  45.             ;
  46.             (Arbeitshypothese: Zutaten werden innerhalb der Klasse Rezept in einem;
  47.             einfachen Vektor, Array, o. ä. gespeichert; keine Klasse Zutat, keine zu-;
  48.             gehörige Verwaltungsklasse Zutatenliste);
  49.         }
  50.         INPUT Hitliste;
  51.         - Pfad und Dateiname aus Parameterliste, Abfrage oder GUI-Element;
  52.         - Datei öffnen;
  53.         - Text auslesen bis EOF;
  54.         ;
  55.         Dabei gilt:;
  56.         for (dummy_counter = Für jede Zeile (HITLISTE) in Hitliste.csv; dummy_counter <= null; dummy_counter += (1))
  57.         {
  58.             if (rezeptliste.findRezept(HITLISTE_Spalte2);)
  59.             {
  60.                 rezeptliste.getRezept(HITLISTE_Spalte2).setRanking(HITLISTE_Spalte1);;
  61.             }
  62.             else
  63.             {
  64.                 Gericht der Hitliste ist nicht auf der Rezeptliste;
  65.                 Ausgabe eines entsprechenden Hinweis (nachrichtlich);
  66.             }
  67.         }
  68.         MERKER;
  69.         ;
  70.         Erstellen einer Collection, eines Arrays, Vector o. ä., um die Preislisten zu sammeln;
  71.         z. B.;
  72.         ;
  73.         ArrayList<Preisliste> preislisten_container == new ArrayList<Preisliste>();;
  74.         Erstelle eine Lieferantenliste;
  75.         Klasse Lieferantenliste == Verwaltungsklasse für Objekte des Typ Lieferant;
  76.         ;
  77.         lieferantenliste == new Lieferantenliste();;
  78.         INPUT Preisliste;
  79.         - Pfade und Dateinamen aus Parameterliste, Abfrage oder GUI-Element;
  80.         - Dateien öffnen;
  81.         - jeweils Text auslesen bis EOF;
  82.         ;
  83.         Dabei gilt:;
  84.         for (dummy_counter = Für jede CSV-Datei (preisliste_x.csv); dummy_counter <= null; dummy_counter += (1))
  85.         {
  86.             Einlesen der Lieferantendaten (Zeile 1 == LIEFERANT);
  87.             if (Lieferant in Lieferantenliste? lieferantenliste.findLieferant(LIEFERANT_Spalte2);)
  88.             {
  89.                 Verweis auf Lieferantenobjekt holen;
  90.                 lieferant == Lieferantenliste.getLieferant(LIEFERANT_Spalte2);;
  91.             }
  92.             else
  93.             {
  94.                 Erstellen eines neuen Objektes Lieferant (Firmenname, Typ, Lieferkostengrundlage);
  95.                 lieferant == new Lieferant(LIEFERANT_Spalte2, LIEFERANT_Spalte1, LIEFERANT_Spalte3);
  96.                 Hinzufügen des Objektes Lieferant in Lieferantenliste;
  97.                 lieferantenliste.addLieferant(lieferant);;
  98.             }
  99.             Erstellen einer Preisliste (mit Verweis auf Lieferanten);
  100.             preisliste == new Preisliste(Lieferant lieferant);;
  101.             ;
  102.             // lieferant == Attribut von Preisliste;
  103.             for (dummy_counter = Für die Zeilen 2 bis n in CSV (==Artikelpositionen); dummy_counter <= null; dummy_counter += (1))
  104.             {
  105.                 // Spalte 1: Mengenangabe pro Verkaufseinheit
  106.                 // Spalte 2: Maßeinheit einer Verkaufseinheit  
  107.                 // Spalte 3: Name der Produkts
  108.                 // Spalte 4: "m" steht für Fleisch(Meat); "f" steht für Fisch, leer bedeutet weder Fleisch noch Fisch
  109.                 // Spalte 5: Preis pro Verkaufseinheit
  110.                 // Spalte 6: tatsächlich vorhandene Menge an Verkaufseinheiten des Produkts
  111.                 Objekt Artikel erstellen und der Preisliste hinzufügen;
  112.                 ;
  113.                 preisliste.addArtikel(new Artikel(;
  114.                 PREISLISTE_Spalte3,      // Name des Produkts;
  115.                 PREISLISTE_Spalte1,      // Mengenangabe je Verkaufseinheit;
  116.                 PREISLISTE_Spalte2,      // Maßeinheit einer Verkaufseinheit;
  117.                 PREISLISTE_Spalte5,      // Preis pro Verkaufseinheit;
  118.                 PREISLISTE_Spalte4,      // Sonderkennzeichen (m, f, LEER);
  119.                 PREISLISTE_Spalte6,      // vorhandene Menge an Verkaufseinheiten des Produkts));;
  120.             }
  121.             Preisliste dem Container hinzufügen;
  122.             preislisten_container.add(preisliste);;
  123.         }
  124.         Für jedes Werk ein entsprechendes Objekt anlegen;
  125.         ;
  126.         werkn == new Werk(Anzahl der MA,;
  127.         Anzahl der Gerichte pro Tag (Durchschnitt?);
  128.         Budget (falls je Werk relevant; == Anzahl MA * Pauschale));;
  129.         ;
  130.         MERKER:;
  131.         Kantinenplanung je Werk, aber Einkaufsplanung global;
  132.         kantinenplanung == new Kantinenplanung();;
  133.         // kantinenplanung.addWerk(Werk werk);;
  134.         kantinenplanung.addWerk(werkn);;
  135.         // Preislisten hinzufügen (optional);
  136.         // kantinenplanung.updatePreislisten(ArrayList<Preisliste> preislisten);  ==> Alternative: eig. Verwaltungsklasse, s. Anm. oben!;
  137.         kantinenplanung.updatePreislisten(preislisten_container);;
  138.         // Rezeptliste hinzufügen (optional);
  139.         // kantinenplanung.updateRezeptliste(Rezeptliste rezeptliste);;
  140.         kantinenplanung.updateRezeptliste(rezeptliste);;
  141.         // Kalkulationsbasis schaffen: Kosten pro Gericht ohne Berücksichtigung von Mindestabnahmemengen;
  142.         // Mindestabnahmemenge ggf. betrachten, bei Wochenplanerstellung;
  143.         // gleichzeitig RankingGesamt bestimmen (Kosten gewichtet nach Ranking);
  144.         for (dummy_counter = Für alle Gerichte gericht in rezeptliste; dummy_counter <= null; dummy_counter += (1))
  145.         {
  146.             // Grundidee: Alle Zutaten durchgehen und für jede Zutat den günstigsten Einkaufspreis;
  147.             // ermitteln. Dabei Maßeinheit und Mengenangabe werden hierbei berücksichtigt, die "Mindest-;
  148.             // abnahmemenge" jedoch zur Vereinfachung nicht.;
  149.             for (dummy_counter = Für jede Zutat zutat in rezeptliste.rezept.zutaten; dummy_counter <= null; dummy_counter += (1))
  150.             {
  151.                 // für Folgendes sei eine eigene Verwaltungsklasse für Preisliste unterstellt;
  152.                 // die Methode double findGuenstigstenPreis(String Zutat); dieser Klasse durchsucht alle Preislisten nach dem günstigsten;
  153.                 // Preis der gesuchten Zutat / des gesuchten Artikels;
  154.                 ;
  155.                 gericht.setKalkulatKosten == gericht.getKalkulatKosten + preislisten_container.findGuenstigstenPreis(String Zutat, int Menge, String Mass);;
  156.             }
  157.             // Nachdem die Gerichte nun sowohl ein Ranking als auch;
  158.             // kalkulatorische "Produktionskosten" ausweisen, kann ein Gesamt-;
  159.             // ranking ermittelt werden;
  160.             ;
  161.             gericht.rankGericht();;
  162.             ;
  163.             // rankGericht zieht den mittels getKalkulatKosten ermittelten kalkulatorischen Preis heran und gewichtet diesen;
  164.             // mit der Position in der Hitliste;
  165.             // z. B. RankingGesamt == Preis * (1 + (Hitlistenposition/Gesamtzahl in Hitliste);
  166.             //         RankingGesamt == kalkulatKosten * (1 + Ranking);;
  167.             ;
  168.             // Unterstellt, dass die Gesamtzahl zuvor gesondert gespeichert wird oder .setRanking statt der Position;
  169.             // jenen Wert speichert (Position/Gesamtzahl);
  170.         }
  171.         // Nun kann die Rezeptliste nach dem Gesamtranking sortiert werden;
  172.         // Die Methode void sortNachRanking(); sortiert die ArrayList dann nach RankingGesamt;
  173.         rezeptliste.sortNachRanking();;
  174.         // Anlegen einer Einkaufsliste;
  175.         einkaufsliste == new Einkaufsliste();;
  176.         // Anzahl der Werke ermitteln;
  177.         anzahlWerke == kantinenplanung.countWerke();;
  178.         // Def. der Mindestanzahl von Fisch-, Fleisch- und vegetarischen Gerichten;
  179.         // 5 steht stellv. für Anzahl der Wochentage;
  180.         anzahlMinFleisch == 5 * ;;
  181.         anzahl;
  182.         // Ausgangssituation;
  183.         // - rezeptliste ist absteigend nach Ranking sortiert;
  184.         // Idee:;
  185.         // - jedes Rezept, das von der Rezepteliste genommen wird, wird in der Gerichteliste (gerichteliste);
  186.         //    hinzugefügt und von rezepteliste gestrichen;
  187.         // - pro Bedingung (Fisch, Vegetarisch, Fleisch) wird ein Durchgang durch die Liste vorgenommen,;
  188.         //    sodass keine Gerichte doppelt verwendet werden;
  189.         for (dummy_counter = Für jedes Werk werk erstelle Wochenspeisepläne und ergänze fortlaufende die Einkaufliste // ArrayList<Werk> werke == kantinenplanung.getAllWerke(); // for each werk in werke; dummy_counter <= null; dummy_counter += (1))
  190.         {
  191.             // Planungshorizont == Anzahl der zu planenden Wochen;
  192.             // anzahlWochen ==> ggf. Attribut in Kantinenplanung ?;
  193.             // ggf. als Parameter erfassen;
  194.             anzahlWochen == 3;;
  195.             // Die Anzahl der benötigten Gerichte ergibt sich aus;
  196.             // Anzahl der Wochentage * Anzahl der Gerichte pro Tag;
  197.             // Berücksichtigung des Planungskalenders hier einbauen bzw. zumindest;
  198.             // berücksichtigen ???; ansonsten 5;
  199.             anzahlGerichte == 3 * 5;;
  200.             // Anlegen einer Gerichteliste (enthält alle Gerichte, die in der Planungsperiode angeboten werden sollen);
  201.             gerichteliste == new Rezeptliste();;
  202.             // Duplikat der Rezeptliste erschaffen;
  203.             tempRezepteliste == rezepteliste.clone();;
  204.             for (dummy_counter = Für Woche 1 bis anzahlWochen; dummy_counter <= null; dummy_counter += (1))
  205.             {
  206.                 // Hilfsvariablen für jede Woche;
  207.                 int anzahlFleisch == 0;                           // 1 pro Tag, i.d.R. 5 pro Woche;
  208.                 int anzahlFisch == 0;                              // 1 pro Woche;
  209.                 int anzahlVeget == 0;                             // 1 pro Tag, i.d.R. 5 pro Woche;
  210.                 // Zuerst die Mindestanzahl an Fischgerichten sicherstellen;
  211.                 // Rezeptliste mit allen Verweisen auf Fischrezepte abfragen (sortiert);
  212.                 Rezeptliste fischRezepte == tempRezepteliste.getFischRezepteSortiert();;
  213.                 // Initialisieren eines Iterators;
  214.                 ListIterator<T> it == fischRezepte.listIterator();;
  215.                 while (Solange (it.hasNext() && 1 > anzahlFisch))
  216.                 {
  217.                     // Nächstes Rezept der Liste betrachten;
  218.                     T gericht == it.next();;
  219.                     gerichteliste.addRezept(gericht);;
  220.                     tempRezepteliste.removeRezept(gericht);;
  221.                     anzahlFisch++;;
  222.                 }
  223.                 // Nun die nächste Minimalbedingungen erfüllen ==> 1 Fleischgericht pro Tag;
  224.                 // Rezeptliste mit allen Verweisen auf Fleischrezepte abfragen (sortiert);
  225.                 Rezeptliste fleischRezepte == tempRezepteliste.getFleischRezepteSortiert();;
  226.                 // Initialisieren eines Iterators;
  227.                 ListIterator<T> it == fleischRezepte.listIterator();;
  228.                 while (Solange (it.hasNext() && 5 > anzahlFleisch) // Statt 5 müsste ggf. Anzahl der Wochentage als Variable stehen (==> Planungskalender?))
  229.                 {
  230.                     // Nächstes Rezept der Liste betrachten;
  231.                     T gericht == it.next();;
  232.                     gerichteliste.addRezept(gericht);;
  233.                     tempRezepteliste.removeRezept(gericht);;
  234.                     anzahlFleisch++;;
  235.                 }
  236.                 // Nun die noch die letzte Minimalbedingungen erfüllen ==> 1 vegetarisches Gericht pro Tag;
  237.                 // Rezeptliste mit allen Verweisen auf veget. Gerichte abfragen (sortiert);
  238.                 Rezeptliste vegetRezepte == tempRezepteliste.getVegetRezepteSortiert();;
  239.                 // Initialisieren eines Iterators;
  240.                 ListIterator<T> it == vegetRezepte.listIterator();;
  241.                 while (Solange (it.hasNext() && 5 > anzahlVeget) // Statt 5 müsste ggf. Anzahl der Wochentage als Variable stehen (==> Planungskalender?))
  242.                 {
  243.                     // Nächstes Rezept der Liste betrachten;
  244.                     T gericht == it.next();;
  245.                     gerichteliste.addRezept(gericht);;
  246.                     tempRezepteliste.removeRezept(gericht);;
  247.                 }
  248.                 ListIterator<T> it == list.listIterator();;
  249.                 ;
  250.                 while (it.hasNext()) {;
  251.                 T t == it.next();;
  252.                 T prev == it.previous();;
  253.                 };
  254.                 // Starte mit ersten (bestgerankten) Rezept;
  255.                 tempRezepteliste.;
  256.                 // Und jetzt noch die übrigen Gerichte gemäß absteigenden Rankingpunkten ermitteln;
  257.                 // Initialisieren eines Iterators;
  258.                 ListIterator<T> it == tempRezepteliste.listIterator();;
  259.                 while (Solange (it.hasNext() && anzahlGerichte > gerichteliste.countRezepte()))
  260.                 {
  261.                     // Nächstes Rezept der Liste betrachten;
  262.                     T gericht == it.next();;
  263.                     gerichteliste.addRezept(gericht);;
  264.                 }
  265.                 // Nun sollte die gerichteliste exakt anzahlGerichte Rezepte enthalten;
  266.                 // Diese Gerichte/Rezepte müssen nun noch auf die Tage verteilt werden;
  267.                 Wochenspeiseplan speiseplan == new Wochenspeiseplan();;
  268.                 // Attribut speiseplan.containsFisch == false;
  269.                 for (dummy_counter = Für jeden Tag der Woche (1 to max. 5); dummy_counter <= null; dummy_counter += (1))
  270.                 {
  271.                     Tag tag == new Tag();;
  272.                     speiseplan.addTag(...);;
  273.                 }
  274.                 werk.addWochenspeiseplan(speiseplan);;
  275.             }
  276.             tempRezepteliste == null;;
  277.         }
  278.     }
  279.  
  280. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement