Winter 2011/2012 GA1 Handlungsschritt 1b und 4 - Programmcode

[lali]

Hi,

die GA1 war in meinen Augen allgemein bescheiden (SQL-Abfragen fuer 10 Punkte und solche Scherze), aber besonders die Handlungsschritte 1 und 4 fielen mir schwer und wurmen mich jetzt.

Bei 1b habe ich den Algorithmus nicht annaehernd hinbekommen. Das war fuer mich eine Gleichung mit 3 Unbekannten. (Und das gab 5 Punkte weniger als die wirklich billige 1a)

Und bei Handlungsschritt 4 gehe ich mal davon aus, dass es eine schlaue einfach Loesung gibt, auf die ich nicht gekommen bin und auch jetzt nicht komme, denn in meinen Augen gibt es 1000 Faelle, die unterschieden und abgefangen werden muessen, beim Beladen der Container.

Waere super, wenn sich jemand bereit erklaeren wuerde, mir diese Aufgaben mal (fuer Doofe) zu erklaeren.

Danke

Bearbeitet 23. November 2011 von lali

[Strebertussi]

Ne Erklärung kann ich leider nicht liefern. Stattdessen würd ich mich gern anhängen an die Bitte nach ner Erklärung für Doofe.

HS4 hab ich gestrichen. Das roch mir zu sehr nach "Türme von Hanoi"...

1b war für mich ebenfalls ne Gleichung mit drei Unbekannten.

Ausgang war ja (glaub ich):

(((x * 91 + y ) * 91 + z ) * 51 + KW ) * 2003 + Jahr = f (-> f bekannt)

ich habs dann umgeformt zu

zwischenergebnis = (f - Jahr) / 2003

zwischenergebnis = ( zwischenergebnis - KW ) / 51

übrig blieb:

zwischenergebnis = ( x * 91 + y ) * 91 + z

und dann war bei mir Schicht im Schacht... ich hatte allerdings auch keine Zeit mehr ^^

mir fällt grad auf, dass man das evtl. nach Binomi oder nach Vieta weiter hätte auflösen können... -.-

aufgelöst ist die Klammer doch:

91^2 x + 91 y + z - zwischenergebnis = 0

vereinfacht man die Gleichung, indem man die 91 durch "a" ersetzt, ergibt sich:

x * a^2 + y * a + b (wobei b = z - zwischenergebnis)

das sieht dann schon irgendwie lösbar aus.... aber hm *schultern zuck* Das ist jetzt nur ins Blaue vermutet. Ich wüsste jetzt auch nicht weiter.

[lali]

Ist auf jedenfall mehr, als ich geschafft habe. Aber loesbar sieht das fuer mich immer noch nicht aus. Zudem sind das Jahr und die Woche (in deinem Fall 2003 und 51) meiner Meinung nach ebenfalls unbekannt. Du hast ja nur den berechneten Code als Parameter. Fuer mich klang es zumindest nicht so, als wuerde sich 1b konkret auf das Beispiel zur Codeberechnung beziehen, sondern eher so, dass eine allgemein gueltige Funktion gesucht wird.

[flashpixx]

Generell sollte hier auch die Aufgabenstellung gepostet werden, denn jemand der die Prüfung nicht vorliegen hat, kann es nicht nachvollziehen.

Das Lösung von n linearen Gleichungen mit n Unbekannten kann via Gaußsches Eliminationsverfahren auf dem Papier und numerisch mit LR / LU Zerlegung gemacht werden. Bei 3 Unbekannten kann man es eben händisch wie auf dem Papier machen.

[yamukud]

Die Containeraufgabe war einfach, ich habe sie mir aber auch schwerer gemacht als sie war (suche den aktuell schwersten Container selbst).

1b schaue ich mir noch sehr genau an und melde mich dann. Wer mich von der Zwischenprüfungsdebatte noch kennt weiß ja, was die IHK erwartet^^

@VP²: Es ist eine Gleichung mit drei Unbekannten, da hilft der Gauß nicht. Und es war sicher nichts allgemeingültiges gefragt, was sollte denn noch allgemeiner sein? (Und in Pseudocode darstellbar)

Bearbeitet 23. November 2011 von yamukud

[Goldie01]

1b war in der Tat knackig. Zum Einen weil weder Jahr noch Kalenderwoche gegeben waren und zum Anderen weil auch unklar war, welcher Code in der Aufgabenstellung eigentlich gemeint war. Dafür nur 10 Punkte im Vergleich zu den leicht verdienten 15 von 1a? Nun gut.

[blx]

Kannst du mal deine Lösung für 1a posten?

[lali]

Ja ok. Da haste Recht. Ich probiers mal zusammenzufassen.

1a)

Man hat den Laendercode (GER), die Woche (51) und das Jahr (2011) eines Auftrages gegeben. Nach dem Algorithmus

>> (((ASCII G * 91 + ASCII E ) * 91 + ASCII R ) * 51 + KW ) * 2003 + Jahr = Zahlencode << soll man in einem Programm diesen Zahlencode berechnen. (Also je nach Laendercode muss da wo jetzt ASCII G steht die ASCII Zahl des jeweiligen ersten Buchstaben des Laendercodes hin; beim ASCIIE der 2. und beim ASCII R der Dritte.) Im Prinzip ist dsa nur in Pseudocode Abtipperei.

1b)

Man soll eine Funktion schreiben, der dieser Zahlenode uebergeben wird, welche daraus den Laendercode (GER) zurueckberechnet. (In diesem Beispiel GER, aber soll sicherlich mit allen Laendercodes und Daten klappen. Mehr Angaben gab es nicht.)

4)

Du sollst ein Programm schreiben, dass Container auf Stapelplaetze (Bay) verteilt. Es gibt 3 Stapelplaetze, auf welche jeweils maximal 4 Container koennen. Die Container sind in einem nach Gewicht absteigend sortiertem Array uebergeben. Der erste Container soll immer auf Bay 1 gelegt werden. Von da an sollen die Restlichen irgendwie verteilt werden mit der Bedingung, dass der naechste Container immer auf den Bay kommt, wo das geringste Gesamtgewicht ist. Sind alle Bays voll oder keine Container mehr da ist's vorbei.

So, jetzt koennen alle mitmachen und nicht nur die, die heute das Vergnuegen hatten

Bearbeitet 23. November 2011 von lali

[Jordinar]

Die Aufgabenstellung war etwa so (aus dem Kopf heraus formuliert):

allgemein:

Ein Code soll aus folgender Formal generiert werden:

gegeben:

Ländercode xxx (z. B. 'GER')

KWJahr wwyyyy (z. B. '132009' für 13. KW im Jahr 2009)

beide Werte als String (bzw. char-Array, war nicht konkret gesagt)

Die Formel war so vorgegeben:

(((Ascii-Wert vom 1. Buchstaben aus xxx * 91 + Ascii-Wert vom 2. Buchstaben aus xxx ) * 91 + Ascii-Wert vom 3. Buchstaben aus xxx ) * 51 + ww) * 2300 + yyyy

Beispielrechnung war vorgegeben, das Ergebnis war entsprechend eine große Zahl - größer als 32bit ermöglicht.

Nun gabs Aufgabenteile a) und

a) Mit gegebenem Ländercode bzw. KWJahr soll der Code generiert werden. Das war sicher gut machbar.

Aus einem gegebenen Code (also der nach Algorithmus aus a) errechneten Zahl) soll der Ländercode errechnet werden, ohne dass man Woche bzw. Jahr kennt. Insgesamt sehe ich hier potenziell 5 Unbekannte mit der bekannten Formel.

[yamukud]

1b) ist mithilfe von Modulo zu erreichnen (Jeweils Zwischenzahl % feste Werte) *batsch*

[Goldie01]

Im Prinzip steht der Code für 1a ja schon zu 80% da - die Formel muss halt nur mit entsprechenden Variablennamen und Funktionsaufrufen ergänzt werden. Zwei Funktionen waren ja noch gegeben - eine zum Umwandeln des Datums in ein wwyyyy-Format und eine zum Auslesen der Länderkennung anhand der Kundennummer. Rest ergibt sich. Hab weder ne Schleif noch eine Bedingungsprüfung in der Funktion gebraucht. Bekomme aber gerade den Kopf nicht frei genug um das nochmal aufzuschreiben.

[flashpixx]

Du sollst ein Programm schreiben, dass Container auf Stapelplaetze (Bay) verteilt. Es gibt 3 Stapelplaetze, auf welche jeweils maximal 4 Container koennen. Die Container sind in einem nach Gewicht absteigend sortiertem Array uebergeben. Der erste Container soll immer auf Bay 1 gelegt werden. Von da an sollen die Restlichen irgendwie verteilt werden mit der Bedingung, dass der naechste Container immer auf den Bay kommt, wo das geringste Gesamtgewicht ist. Sind alle Bays voll oder keine Container mehr da ist's vorbei.

Das ist ein "klassischer" Greedy-Algorithmus den man hier umsetzen kann. Es können max 12 Container benutzt werden.

D.h. für jedes Bay habe ich eine Variable mit dem aktuellen Gewicht, nachdem dann der erste Container auf 1 abgelegt wurde und ich den zweiten Container nehme, lege ich diesen eben auf das nächst kleiner Bay ab (sprich, das Bay, bei dem die schon abgelegten Container in Summe das kleinste Gewicht liefern). Das mache ich eben so lange, bis auf jedem Bay 4 Container liegen bzw. ich 12 Container verarbeitet habe. Eine kleine Beachtung muss drin sein, wenn auf einem Bay schon 4 Container liegen, dann ignoriert man diesen und nimmt dann den nächst kleineren

[lali]

Das generelle Vorgehen und die 'Sonderfaelle' sind mir klar. Ich weiss nur nicht, wie ich das sauber in Programmcode umsetzen soll, ohne 1000 IF-Abfragen oder Schleifen zu nutzen.

Also genauer gesagt das folgende Vorgehen:

1) Bay pruefen und feststellen, dass sie nicht die leichteste ist

2) naechste Bay(s) pruefen und feststellen, dass die zwar leichter, aber voll beladen ist (sind)

3) Zurueck zur zuerst geprueften Bay gehen und diese trotz des Gewichts beladen.

Das kann ja in zahlreichen Kombinationen auftreten, welche statisch garnicht abzufangen sind. Besonders Schritt 3 faellt mir in Anbetracht dieser Tatsache schwer.

Ich werde mir diesen Greedy-Algorithmus mal ansehen. Vielleicht klaert sich dann fuer mich, wie man das in Programmcode umsetzt. Danke auf jeden Fall schonmal.

Achso und @yamukud, kannst du das vielleicht etwas ausfuehrlicher erklaeren und vllt an einem kurzen Beispiel zeigen?

[Fak0r]

Ja, so weit so gut, ich bin auf der Rückfahrt auch noch einmal alle Aufgaben durchgegangen. Die Aufgaben aus GA1 waren im Groben schon machbar, aber kaum in der Zeit zu schaffen. Es regt mich echt auf, dass JEDES JAHR der Großteil der Prüflinge ankreuzt, dass die Zeit zu kurz war und die IHK es NIE schafft, die Aufgaben demnach nach der Zeit zu richten.

Bis man erstmal die Aufgabe verinnerlicht und verstanden hat, dauert es schon etwas... Zudem find ich es auch "bescheiden", dass es Handlungsschritte gibt, die nur aus einer Aufgabe bestehen und dann 25 Punkte Wert sind. Und die letzte Aufgabe sollte man nicht auf den "Heftrücken" drucken, da man eher damit rechnet, dass die Arbeit mit einem "leeren" Blatt beendet wird (quasi wie jedes normale Buch -.-)

Edit: Im Grunde könntest du für das Gesamtgewicht ein Array anlegen, welches das Gesamtgewicht aller Bays speichert, also ArrayBayGewicht[0] = Gewicht Bay0, ArrayBayGewicht[1] = Gewicht Bay1 und ArrayBayGewicht[2] = Gesamtgewicht Bay3. Die einzelnen Werte aktualisierst du dann mit jeder "Verladung". Mit jedem neuen Container gehst du das Array durch und ermittelst den geringensten Wert. Damit hast du die Bay. Wenn die Bay nicht voll ist, verlädst du den Container, sonst weiter etc.

Leider ist mir der Lösungsweg erst in der Straßenbahn eingefallen xD

Bearbeitet 23. November 2011 von Fak0r

[lali]

Jo ich fand's zeitlich auch zu knapp bemessen.

Dieses Vorgehen habe ich auch gewaehlt. Damit ist jedoch nicht der Fall abgedeckt, dass bspw. Bay 1 beladen wird, obwohl sie nicht den geringsten Wert hat, weil Bay 3 und 2 voll sind oder weil nur Bay 3 voll ist und Bay 1 zwar nicht den geringsten, aber einen niedrigeren Wert als 2 hat. Und fuer diese Szenarien gibt's viele unterschiedliche Auspraegungen, die moeglichst dynamisch abgefangen werden muessen.

Wie flashpixx das schon sagte, muessten die vollen Bays von der Ermittlung der am wenigsten beladenen Bays ausgeschlossen werden. Aber keine Idee wie. Vielleicht warte ich einfach den Loesungsvorschlag der IHK ab. Das ist dann sicherlich ein total billiger 10 Zeiler xD

[Fak0r]

Stimmt... allein für diese Aufgabe hätte man 90 Min gebraucht ich hoffe, dass es da n paar "Gnaden"punkte gibt, ansonsten sieht das alles nicht so rosig aus. Vllt hätte ich doch das Aktivitätsdiagramm zeichnen sollen, obwohl ich mir die Aufgabe nicht mal komplett durchgelesen hab .

[Misssy]

puhh..ich hab das Aktivitätsdiagramm gezeichnet...ich glaub das war eine gute Entscheidung.

In der Zeit war die GA1 kaum machbar..= bescheiden schön

Die GA2 war recht Hardwarelastig..eh nicht mein Ding = hoffe es reicht trotzdem

[flashpixx]

1) Bay pruefen und feststellen, dass sie nicht die leichteste ist

2) naechste Bay(s) pruefen und feststellen, dass die zwar leichter, aber voll beladen ist (sind)

3) Zurueck zur zuerst geprueften Bay gehen und diese trotz des Gewichts beladen.

Mit Arrays z.B. in der Form

    double[4] bayweightsum;

    uint[4] enthaltenecontainer;


    container = hole_neuen_container();

    bayweightsum[0] += container.getWeight();

    enthaltenecontainer[0]++;


    for( uint i = 0; i < 11; ++i) {

         indexmin = 0;

         for(uint n=0; n < 4; n++)

             if (enthaltenecontainer[n] < 4)

                indexmin = min(indexmin, bayweightsum[n])


        container = hole_neuen_container();

        bayweightsum[indexmin] += container.getWeight();

        enthaltenecontainer[indexmin]++;

}  

[steeno]

Zu beachten ist auch noch das das zweidimensionale Array von unten nach oben und beginnend mit der letzten Spalte gefüllt wird. Die Aufgabe ist auf dem Blatt, mit Druck, und ohne Del/Backspace Taste zumindest nicht sonderlich schön

Für die 1b hat wohl niemand ne Lösung? Die etwas genauer ist als "ah das geht ganz easy per modulo"?

[flashpixx]

Für die 1b hat wohl niemand ne Lösung? Die etwas genauer ist als "ah das geht ganz easy per modulo"?

Wenn das die Formel ist

(((Ascii-Wert vom 1. Buchstaben aus xxx * 91 + Ascii-Wert vom 2. Buchstaben aus xxx ) * 91 + Ascii-Wert vom 3. Buchstaben aus xxx ) * 51 + ww) * 2300 + yyyy

dann muss man eben das ganze als lineares Gleichungssystem auffassen, Ergebnis ist bekannt, so dass man die Gleichungen aufstellen muss und diese kann man dann mit Hilfe des Gauß-Eliminationsverfahren (wie unten erwähnt) lösen und hat dann für jede Unbekannte den Wert. Evtl sollte man aber anstatt Gauß ein numerisches Verfahren LR / LU nehmen, so etwas bekommt man aber fertig durch Bibliotheken wie die GSL oder LAPack

[JaIchBins]

Für die 1b hat wohl niemand ne Lösung? Die etwas genauer ist als "ah das geht ganz easy per modulo"?

Ich zitier mich mal selber aus dem anderen Thread, danach sollte es etwas klarer sein:

Ja, man mußte mit modulo arbeiten. Die Folge durch modulo 2300, Rest ist das Jahr. Folge minus Jahr, dann durch 2300. Nächster mod ist dann die Woche usw. Selbstverständlich bin ich erst in der Pause draufgekommen und hab in der Prüfung nichts stehen...

[steeno]

OMG du hast recht, + ftw..

also in etwas so

(((Ascii-Wert vom 1. Buchstaben aus xxx * 91 + Ascii-Wert vom 2. Buchstaben aus xxx ) * 91 + Ascii-Wert vom 3. Buchstaben aus xxx ) * 51 + ww) * 2300 + yyyy


Zum einfacheren Lesen:


a = Ascii-Wert vom 1. Buchstaben aus xxx

b = Ascii-Wert vom 2. Buchstaben aus xxx

c = Ascii-Wert vom 3. Buchstaben aus xxx

d = ww

e = yyyy


=> (((a * 91 +  * 91 + c) * 51 + d) * 2300 + e = 1234567


e = 1234567 % 2300

zwischenergebnis = 1234567 - e / 2300


d = zwischenergebnis % 51

zwischenergebnis = zwischenergebnis - d / 51


c = zwischenergebnis % 91

zwischenergebnis = zwischenergebnis - c / 91


b = zwischenergebnis % 91

a = zwischenergebnis - b / 91

[/code]

Bearbeitet 24. November 2011 von steeno

[Strebertussi]

bis auf ein paar mehr Klammern (Punkt vor Strichrechnung ) scheint das nach den Infos hier im Forum zu passen ... da muss man erstmal drauf kommen

[steeno]

kann es jetzt leider nicht mehr editieren, aber hast natürlich recht =) sollte jetzt nicht mathematisch korrekt sein sondern einfach nur die lösung verdeutlichen. dem da muss man erst mal drauf kommen kann ich nur beipflichten, oft denkt man da einfach zu kompliziert.. wäre ne super aufgabe für einen iq test

[Fak0r]

Ich bin auf die Modulo-Lösung in den letzten Minuten gekommen, dann schnell alles hingequetscht, weil andere Lösungsversuche schon gescheitert waren, dann musste ich noch das ER-Diagramm mitm Kuli nachziehen, Bleistift gilt ja nicht... und dann war's auch schon vorbei. Für die 4. Aufgabe (Bay etc.) hätte ich viel mehr Zeit benötigt. Da sieht's bei mir sehr schlecht aus. Hoffe, dass ich da ein paar Gnadenpunkte abgreifen kann :(

Aber vom logischen Aspekt her, war die GA1 ziemlich knifflig. Natürlich gibt's auch mal schwierigere Aufgaben im Berufsleben, aber für diese Prüfung sollten m. E. egtl nur die Fertigkeiten der Darstellung etc (bisschen Logik ist immer dabei) abgefragt werden.

Ich fand die Aufgaben teilweise ziemlich ungünstig gewählt. Die IHK wird wohl selber kaum die Musterlösungen in 90Min erstellt haben (ausgehend davon, dass eine Person die Lösung erstellen würde, die die Aufgaben nicht erstellt hat. Wenn man sie erstellt, hat man natürlich schon eine Vorstellung davon, was man erreichen will )