Pseudo-Code Aufgabe

[Unstoppable]

Ich habe eine Aufgabe von der letzten Abschlussprüfung, zu der ich keine Lösung habe. Ich würde gerne eine Bewertung des pseudo-Codes und Verbesserungsvorschläge von euch holen. 

-------------------------------------------------------------------------------------------------------------------------------------

AUFGABE

Die Wings GmbH führt Frachtflüge zwischen mehreren Orten durch. So können beispielsweise Routen von A nach B (ggf. Einbeziehung von Zwischenstopps) auf unterschiedliche Weise durchgeführt werden.

Die Wings GmbH benötigt nun eine Funktion, mit der die kostengünstigte Route zu vorgegebenen Startorten und Zielorten unter Berücksichtigung von freien Frachtkapazitäten ermittelt werden kann.

Die möglichen Routen zwischen Ausgangsort (A) und Zielort (B) liegen stets in einer zweidimensionalen Tabelle Routen vor. Routen für einen Flug von A nach B:

A - B

A - C - B

A - D - E - B

Der Ausgangsort steht immer in Spalte 0, der Zielort ist immer der letzte nicht leere Eintrag einer Zeile.

Folgende Funktionen stehen zu Verfügung:

holeStreckeGewicht(SB:String, SE:String) : Integer - Holt für eine Strecke die freie Kapazität in kg

holeStreckePreis(SB:String, SE:String):Double - Holt für eine Strecke die Frachtkosten

SB = Strecken-Beginn

SE = Strecken-Ende

Erstellen Sie einen Algorithmus für eine Funktion findeRoute(gewicht:Integer):Integer, die für eine Fracht mit dem Gewichtgewicht die kostengünstigste Route unter Berücksichtigung von freien Kapazitäten ermittelt. Die Funktion soll den Index der Tabellenzeile zurückgeben, in der die günstigste Route gefunden wurde. 

------------------------------------------------------------------------------------------------------------------------------------------

MEINE LÖSUNG (eine Mischung aus Java, C# und pseudo-Code)

findeRoute(Gewicht:Ineteger):Integer

{

Dictionary (int, int) prices = new Dictionary<int, int>();

     foreach (Zeile in Routen)

    {

          strecken_beginn = Zeile.Spalten[0];

          strecken_ende = Zeile.Spalten.Anzahl - 1;

          frachtkapazitaet = holeStreckeGewicht(strecken_beginn, strecken_ende);

          if(frachtkapazitaet>=Gewicht)

         {

              preis = holeStreckePreis(strecken_beginn, strecken_ende);

              prices.Elements.Add(Zeile.Index, preis)

         }

     }

     foreach(dictionaryItem1 in prices)

    {

           indexOfTheCheapestFlight;

            foreach(dictionaryItem2 in prices)

           {

                  if(dictionaryItem1.Value<=dictionaryItem2.Value)

                  {

                         indexOfTheCheapestFlight = dictionaryItem1.Index;

                        continue;

                   }

                  else

                {

                      dictionaryItem.1 = NULL;

                      break;

                }

           }

    }

}

Vielen Dank im Voraus!

Bearbeitet 18. Oktober 2017 von Unstoppable

[arlegermi]

Erstmal vorweg: Das sieht im Großen und Ganzen ok aus. Es gibt aber ein paar Stellen, die mich verwundern und es gibt auch durchaus noch Optimierungspotenzial (auch im Rahmen einer Pseudocode-Aufgabe).

1. Du kannst dir die zweite foreach-Schleife eigentlich komplett sparen, wenn du in der ersten dir einfach die aktuell günstigste Route merkst und immer nur damit vergleichst. Also in etwa so:

   minPreis = -1
   minIndex = -1
   foreach Zeile in Routen:
       strecke_beginn = Zeile[0]
       strecke_ende = Zeile[Zeile.Length - 1]
       strecke_kapazitaet = holeStreckeGewicht(strecke_beginn, strecke_ende)
       if(Gewicht <= strecke_kapazitaet):
           strecke_preis = holeStreckePreis(strecke_beginn, strecke_ende)
           if(strecke_preis < minPreis or minPreis == -1):
               minPreis = strecke_Preis
               minIndex = Zeile.Index
               
   return minIndex

   So umgehst du auch das Problem, "komplizierte" Datenstrukturen wie Dictionaries in Pseudocode nutzen zu müssen, was ich immer etwas unglücklich finde.

2. Du gibst aus deiner Methode nichts zurück. Üblicherweise würde ich ein "return" o.ä. erwarten.

3. Ich verstehe nicht, wieso du dein eines "dictionaryItem" auf null setzt - was versprichst du dir davon?

4. Ich würde an deiner Stelle auch versuchen, konsistent zu bleiben, was die Notation angeht. Du schreibst z.B.
    

   Dictionary (int, int) prices = new Dictionary<int, int>(); 

   Wieso ist das links mit runden, rechts aber mit spitzen Klammern? Das ist jetzt nichts, weshalb du die Aufgabe nicht bestehst, ich würde dir aber aber dazu raten, darauf zu achten, um selber einfacher den Überblick zu behalten.

5. Du sagst, dass du eine Mischung aus C#, Java und Pseudocode schreibst. Wieso machst du es dir dann z.T. so umständlich, wenn die echten Sprachen kompakter sind? Ich meine konkret:
    

   prices.Elements.Add(Zeile.Index, preis)
   //sowohl in Java als auch C# wäre das entweder
   prices.Add(Zeile.Index, preis)
   //oder
   prices[Zeile.Index] = preis

   Auch wieder nur eine Kleinigkeit. Aber gerade, wenn man auf Papier sowas schreibt sollte man sich so kurz wie möglich halten, um selber den Überblick zu behalten (natürlich nur so kurz, dass alles noch verständlich bleibt).

6. Es ist übrigens völlig in Ordnung, in der Prüfung Kommentare zu schreiben, um deine Annahmen zum Ausdruck zu bringen. Beispielsweise, dass eine Zeile ihren Index kennt, ist so eine Annahme. Das ist völlig in Ordnung, das anzunehmen - mir wurde damals geraten, solche Sachen aber ganz kurz als Kommentar zu schreiben, um dem Prüfer zu zeigen, dass du dir dieser Annahme bewusst bist.

[Whiz-zarD]

strecken_beginn = Zeile.Spalten[0];
strecken_ende = Zeile.Spalten.Anzahl - 1;
frachtkapazitaet = holeStreckeGewicht(strecken_beginn, strecken_ende);

Das kann doch nicht funktionieren, da strecken_beginn immer A und strecken_ende immer B ist. Demnach ist frachtkapazitaet immer gleich. Auch ist strecken_ende bei dir ein Integer ist und kein String.

Demnach müsste man z.B. bei der zweiten Route ( A - C - B ) die freie Kapazität für A - C und C - B ermitteln. Hier müsste man also eine verschachtelte Schleife bauen, die für alle Streckenabschnitte ermittelt, ob eine Strecke genügend Kapazität liefert

 

 

 

[Unstoppable]

vor 15 Stunden schrieb Whiz-zarD:

strecken_beginn = Zeile.Spalten[0];
strecken_ende = Zeile.Spalten.Anzahl - 1;
frachtkapazitaet = holeStreckeGewicht(strecken_beginn, strecken_ende);

Das kann doch nicht funktionieren, da strecken_beginn immer A und strecken_ende immer B ist. Demnach ist frachtkapazitaet immer gleich. Auch ist strecken_ende bei dir ein Integer ist und kein String.

Demnach müsste man z.B. bei der zweiten Route ( A - C - B ) die freie Kapazität für A - C und C - B ermitteln. Hier müsste man also eine verschachtelte Schleife bauen, die für alle Streckenabschnitte ermittelt, ob eine Strecke genügend Kapazität liefert

 

 

 

oooooh shit!!!!!! Du hast Recht...Gut erkannt!

[Unstoppable]

Wie formatiert er eigentlich den Code-Anschau hier im Forum?

Das ist meine verbesserte Variante:

findeRoute(Gewicht:Integer):Integer{

index;

foreach (Zeile in Route)

{

        strecken_beginn = Zeile.Spalten[0];

        aktuellerPreis;

       minPreis;

       for(i=1; i<Zeile.Spalten.Anzahl-1; i++)

       {

              nextPoint=Route.Spalten;

              //hier sehe ich eigentlich ein Problem. Angenommen laufe ich die Strecke ADEB durch. Was passiert, wenn 

             //die Frachtkapazität für A-D ausreicht (die untere Bedingung kommt als true zurück) und für D-E eben nicht (kommt false

             //zurück)? Wäre dieser Fall als Fehler bewertet?

              if(holeStreckeGewicht(strecken_beginn, next_point))

              {

                    preis+=holeStreckePreis(strecken_beginn, next_point)

              }

       }

      if(preis < minPreis || minPreis == -1)

      {

             min.Preis = preis;

            index = Zeile.index;

     }

}

return index;

}

@Whiz-zarD, @arlegermi 

Bearbeitet 19. Oktober 2017 von Unstoppable

[Unstoppable]

Kann nicht mehr bearbeiten, Korrektur: 

nextPoint=Route.Spalten;

P.S. ok, ich kann es nicht korrigieren, da es automatisch gelöscht wir. Vielleicht wird das funktionieren - 

nextPoint= Route.Spalten/[/i/]/

Bearbeitet 19. Oktober 2017 von Unstoppable

[Whiz-zarD]

Ich würde versuchen, nicht alles in eine Methode zu klopfen, sondern daraus mehrere Methoden machen, um da ein Überblick zu behalten. Mein Anfang würde so aussehen:

findeRoute(Gewicht : Integer) : Integer 
{
    int indexGuenstigsteRoute;
    double preisGuenstigeRoute;
    bool isInitialized;
    
    for(int i = 0; i < Routen.Length; i++)
    {
        route = Routen[i];
        if(hatGenugKapazitaet(route, Gewicht))
        {
            preisRoute = berechnePreis(route);
            if(preisRoute < preisGuenstigeRoute || !isInitialized)
            {
                indexGuenstigsteRoute = i;
                preisGuenstigeRoute = preisRoute;
                isInitialized = true;
            }
        }
    }
  
    return indexGuenstigsteRoute;
}

Jetzt müsste man noch die Methode hatGenugKapazitaet() und berechnePreis() implementieren:

hatGenugKapazitaet(Route : Route, Gewicht : Integer) : Boolean
{
    for(int i = 0; i < Route.Length - 1; i++)
    {
        if(holeStreckeGewicht(route[i], route[i + 1]) < Gewicht)
            return false;
    }
    
    return true;
}

berechnePreis(Route : Route) : double
{
    double preis = 0;
    
    for(int i = 0; i < Route.Length - 1; i++)
    {       
        preis = preis + holeStreckePreis(route[i], route[i + 1]);
    }
    
    return preis;
}

Glücklich bin ich aber mit der Lösung nicht. Da sind noch einige Dinge, die man evtl. verbessern kann.

Zu deiner Frage: Wir nehmen die Route A - D - E - B:
Wenn es genug Kapazität bei A - D gibt aber bei D - E nicht, dann muss false zurückgegeben werden, weil die Route von A nach B in einer Teilstrecke nicht genug Kapazität hat.

So verstehe ich zumindest die Aufgabe. 
 

Bearbeitet 19. Oktober 2017 von Whiz-zarD

[Unstoppable]

vor einer Stunde schrieb Whiz-zarD:

Ich würde versuchen, nicht alles in eine Methode zu klopfen, sondern daraus mehrere Methoden machen, um da ein Überblick zu behalten.
 

Darf man das überhaupt? Die Aufgabenstellung lautet "Erstellen Sie eine entsprechende Funktion erstelleFluege()". Es geht um prozeduralen Programmierung.

Bearbeitet 19. Oktober 2017 von Unstoppable

[arlegermi]

Du erstellst ja auch die genannte Funktion. Nur eben noch zwei weitere, um die Übersichtlichkeit zu gewährleisten. Funktional macht das ja keinen Unterschied, ob du den Code in eine Methode schreibst oder an der entsprechenden Stelle eine andere aufrufst.

Ich hoffe mal, dass es keinen Prüfer gibt, der einem dafür Punkte abzieht.

[Whiz-zarD]

vor 31 Minuten schrieb arlegermi:

Ich hoffe mal, dass es keinen Prüfer gibt, der einem dafür Punkte abzieht.

Da habe ich auch so meine Bedenken, dass es da welche gibt, die Punkte abziehen, wenn es von der offiziellen Lösung abweicht. Zu mal viele der offiziellen Lösungen falsch sind.

[Rienne]

vor 17 Stunden schrieb Unstoppable:

Die Aufgabenstellung lautet "Erstellen Sie eine entsprechende Funktion erstelleFluege()". Es geht um prozeduralen Programmierung.

Also ich lese in der Aufgabenstellung übrigens etwas von Algorithmus:

Am 18.10.2017 um 15:44 schrieb Unstoppable:

Erstellen Sie einen Algorithmus für eine Funktion findeRoute(gewicht:Integer):Integer

So wie ich das verstehe, ist nur davon die Rede, dass dieser Algorithmus eine Funktion "findeRoute(gewicht: Integer):Integer" beinhalten soll. Für mich ist es also durchaus legitim, dort weitere Funktionen bzw. Methoden zu nutzen.

Ich hätte es vermutlich übrigens in etwa so gelöst:

findeRoute(gewicht:Integer):Integer
{
int guenstigsteStrecke = -1; //weil 0 ein legitimer Index wäre
double guenstigsterPreis = -1.0; //Zum Vergleichen
double preis = 0.0
int zeilencounter = 0;
bool streckeOkay;
foreach Zeile in Routen
 {
   streckeOkay = true;
   for(int i=0; i++; i < Zeile.length-1) //weil immer zwei Einträge vergleicht werden
    {
	  preis = preis + holeStreckePreis(Zeile[i], Zeile[i+1]);
	  //wenn ein Teil der Strecke nicht mehr passt:
	  if ( holeStreckeGewicht(Zeile[i], Zeile[i]+1)>gewicht)
	   {
	     streckeOkay = false;
	   }
	}
	//wenn Strecke okay und vorher noch keine Strecke okay oder Preis niedriger:
	if ((streckeOkay == true && guenstigsterPreis == -1.0) ||
       (streckeOkay == true && preis < guenstigsterPreis && guenstigsterPreis != -1.0))
	{
	  guenstigsterPreis = preis;
	  guenstigsteStrecke = zeilencounter;
	}
	zeilencounter++;
 }
 //falls es keine legitime Strecke gibt, wird hier -1 zurückgegeben. Dieser Wert muss außerhalb korrekt behandelt werden.
 return guenstigsteStrecke;
}

 

Bearbeitet 20. Oktober 2017 von Rienne

[Whiz-zarD]

Wirklich optimal ist der Code auch nicht, da du gnadenlos jeden Teilabschnitt durchläufst, auch wenn klar ist, dass schon ein Teilabschnitt nicht genug Kapazität besitzt und die Route somit ausgeschlossen werden kann. Also müsstest du die Abbruchbedingung der for-Schleife noch anpassen.

Aber hier sieht man die Tücken, wenn eine Funktion mehr als eine Sache tun soll. Es wird schnell unübersichtlich. Zum einen wird man am Anfang der Funktion mit Variablendeklarationen erschlagen. Variablen sollten so lokal wie möglich deklariert werden. z.B. streckeOkay brauchst du nur in der foreach-schleife aber sie wurde außerhalb des Scopes deklariert und steht somit der gesamten Funktion zur Verfügung.

Zum anderen muss man sehr viel "Schmutz" einbauen, damit der Code auch funktioniert, wie z.B.

streckeOkay = true;

so etwas stört den Lesefluss. Ja, ich habe sowas auch drinnen aber im Nachhinein ist die Variante mit der Initialisierung des günstigsten Preises auf -1 wohl eine bessere Alternative und ich könnte mir die isInitialized-Variable sparen.

Man sollte sich immer im klaren sein, dass Code mehr gelesen wird, als geschrieben. Daher sollte der Code sauber und klar sein. Man kann schon an den Kommentaren erkennen, dass der Code eben nicht klar und sauber ist, weil die Kommentare den Code erklären müssen. Wenn man Kommentare schreiben muss, um den Code zu erklären, sollte man die Finger von der Tastatur nehmen und mal überlegen, wieso es ein Kommentar bedarf und nicht der Code für sich selbst sprechen kann?

Der folgende Code ist schon großer Mindfuck. 

if ((streckeOkay == true && guenstigsterPreis == -1.0) ||
       (streckeOkay == true && preis < guenstigsterPreis && guenstigsterPreis != -1.0))
{
	...
}

Das muss man mehrmals lesen, um es überhaupt richtig zu verstehen. Man kann es auch einfacher schreiben:

if (streckeOkay 
    && (preis < guenstigsterPreis || guenstigsterPreis == -1.0))
{
	...
}

Dann wird es vielleicht schneller deutlicher, was gemeint ist und bedarf ggf. kein Kommentar mehr.

Auch in Sachen Testbarkeit ist es nicht klug, mehr Dinge auf einmal zu tun (Streckenabschnitt überprüfen, Preis berechnen und günstigste Route ermitteln). Wenn in der Funktion ein Fehler auftreten sollte, muss die gesamte Funktion überprüft werden und das ist wesentlich aufwendiger,  als wenn man in einer Unterfunktion den Fehler findet. Daher: Funktionen so klein wie möglich halten und Teilaufgaben in Unterfunktionen ausgliedern.  Die Funktion findeRoute() soll die günstigste Route finden. Nicht mehr und auch nicht weniger. Es ist nicht ihre Aufgabe, den Preis zu ermitteln oder schauen, welche Routen geeignet sind. Das sollen Unterfunktionen erledigen, die dann isoliert betrachtet und getestet werden können.

Das ist vielleicht alles Meckern auf hohem Niveau und für die Abschlussarbeit reicht es aber im produktiven Einsatz wäre so ein Code mehr hinderlich als nützlich. Man hat hier schon angefangen Code zu optimieren (eine Route wird einmal durchgegangen) aber durch die Optimierung muss man einiges drumherum bauen, was eben stört und man hat sich damit sogar einiges verbaut.

[Rienne]

Das mag ja alles stimmen @Whiz-zarD, aber du musst bedenken, dass wir hier von einer IHK-Aufgabe und einer ungefähren Bearbeitungszeit von ~20 Minuten reden. Wenn du jetzt vorher z.B. noch alles in eine while-Schleife packst um die Abbruchbedingung zu prüfen nur um etwas Laufzeit zu sparen  (wir reden hier übrigens von kleinen Arrays in dem Beispiel, wo das kaum ins Gewicht fällt), kostet das weitere Überlegungszeit, die du in der Prüfung nicht hast.

Die Kommentare sind übrigens auch da, da wir hier im Forum nicht nur fertige Entwickler mit 5+ Jahren Berufserfahrung haben.

Nicht von Abschlussprojekten und auch nicht von produktiv genutzten Code.

Zu der If-Abfrage am Ende: Dein Code ist vllt kürzer, meiner repräsentiert jedoch die menschliche Denkweise besser, da beide Fälle für sich gekapselt sind, so wie man es sich eben herleitet. Optimieten kann man dann später gerne noch. Wie jemand etwas leichter versteht, ist mMn von der Person abhängig.

Ich kann dir übrigens garantieren, dass du auch in Unternehmen seltenst auf perfekten Code triffst und alles so gekapselt und minimiert hast, wie man es tun sollte.

Und da bin ich dann echt froh, wenn man lieber mehr kommentiert als zu wenig. Gerade für Azubis und Neulinge ist es immer angenehmer per Kommentar zu wissen, was der Abschnitt macht, egal wie einfach er letzten Endes ist.

Bei uns ist es übrigens beispielsweise ganz normal, dass mit "Continue" und "Exit" programmiert wird...

[Gast here]

Hi,

ich stecke noch ganz am Anfang meiner Ausbildungaber habe mich trotzdem an der Aufgabe versucht und ca. 30min für diese Lösung gebraucht. Ich habe mit Absicht danach gestoppt, auch wenn das Ergebnis jetzt falsch sein sollte.

Was würde ein Prüfer dazu sagen?


 

int preisACD ()          {

                  preisACB = holeStreckePreis(A, C) + holeStreckePreis(C,B)

				  if  GewichtAC < maxGewicht and GewichtCB<maxGewicht {
                                    antworte  preisACB;
                  }


int preisADEB ()       {

                  preisADEB = holeStreckePreis(A, D) + holeStreckePreis(D, E) + holeStreckePreis(E, B)

				  if  GewichtAC < maxGewicht and GewichtCB < maxGewicht and GewichtCB < maxGEwicht {
                  antworte  preisADEB;

}

 

findeRoute(gewicht:Integer):{

int GewichtAB = holeStreckeGewicht(A, B);
int GewichtAC = holeStreckeGewicht(A, C);
int GewichtCB = holeStreckeGewicht(C, B);
int GewichtAD = holeStreckeGewicht(A, D);
int GewichtDE = holeStreckeGewicht(D, E);
int GewichtEB = holeStreckeGewicht(E, B);
int maxGew = maxGewicht;

int preisAB = holeStreckePreis(A, B)

int preisACD = preisACD();

int preis ADEB = preisADEB();


liste = [preisAB, preisACD, preisADEB]

for i=1, i< Länge von Liste, i++{

                  if (liste[i] > liste[0]):
                                   liste[0] = liste[i];

                  antworte "Die beste Route ist" + liste[0];

 

Bearbeitet 20. Januar 2021 von here

[stefan.macke]

vor 6 Stunden schrieb here:

Was würde ein Prüfer dazu sagen?

Der würde dir leider wenige bis gar keine Punkte dafür geben. Du hast nämlich nicht das allgemeingültige Problem gelöst, sondern nur das angegebene Beispiel. Dein Algorithmus muss aber mit beliebigen Kombinationen von Strecken aus mehreren Teilabschnitten klarkommen. Deine Variablen, in deren Namen schon die einzelnen Teilstrecken stecken, deuten schon auf das Problem hin. Du darfst nicht an ABCD denken, sondern musst mit beliebigen Strecken arbeiten können.

Aber ich finde es super, dass du bereits früh beginnst, dich auf diese Art von Aufgaben vorzubereiten. Also versuch es doch einfach noch mal und zeige uns einen neuen Vorschlag.

[Gast here]

Hi Stefan, danke für das Feedback.
Ich habe mir nochmal 20 oder 30min Zeit genommen für den nächsten Versuch. Mir fällt es sehr schwer mit Pseudocode und finde das unter Prüfungsstress nicht machbar. Ist das Niveau der Aufgaben immer so für eine 20min. Prüfungsaufgabe?

Ich habe arge Probleme, den Code gequetscht zu bekommen, Platzprobleme, dadurch auch Übersichtlichkeitsprobleme bei mir selber.

Wie bereite ich mich am besten auf diese Aufgabentypen vor? Ich habe in einem anderen Thread gelesen, dass diese Aufgaben zu Bewältigungsproblemen in der Prüfung führen können.

Int Counter=0
Int Niedrigster Preis=0
Int Aktuelle Route = 0;
Array GünstigsteRoute = []
Array RoutenListe;
Array Result;



Für alle Routen in Tabelle:

        Aktuelle Route ++;                                      //zählt hoch für jede vorhandene Route

        RoutenGesamtPreis = 0 ;                           		//Gesamtpreis für alle Routenpunkte einer Route, unter Einhaltung der Frachtkap.

        falls (RoutenGesamtpreis < Günstigste Route[0]:)

            GünstigsteRoute[0]=Routengesamtpreis;           //günstigste Route steht immer an erster Stelle im Array GünstigsteRoute

            ArrayResult[0]=Routenliste[AktuelleRoute];     // 


                        für jeden Routenpunkt in Routen:

                        Counter++;
                        falls  (holeStreckeGewicht(Punkt[0+counter], Punkt[1+counter] > zulässige Kapazität):

                        							Return;

                                                    Sonst (RoutenGesamtPreis + holeStreckePreis(Punkt[0+counter], Punkt[1+counter])
	


"Die beste Route ist" + Array Result

[Rienne]

vor einer Stunde schrieb here:

Mir fällt es sehr schwer mit Pseudocode und finde das unter Prüfungsstress nicht machbar. Ist das Niveau der Aufgaben immer so für eine 20min. Prüfungsaufgabe?

Du musst es so sehen: Du hast für den Prüfungsteil GA1 90 Minuten Zeit. In dieser Zeit musst du 4 von 5 gestellten Aufgaben bearbeiten. D.h. du hast etwas mehr als 20 Minuten Zeit dafür, wenn man das Lesen aller Aufgaben mal ausklammert.

Was genau fällt dir schwer beim Pseudocode? Das Strukturieren des Programmablaufs oder der Pseudocode selber? Bei Letzterem kann ich dich beruhigen. Pseudocode hat keine formellen Vorgaben, d.h. du kannst die Lösung theoretisch auch einfach in einer dir bekannten Programmiersprache schreiben. Wichtig ist, dass der Prüfungsausschuss versteht, was an welcher Stelle passieren soll.
Wenn es am Ersteren liegt: Du bist ja erst ganz am Anfang deiner Ausbildung. Du hast noch viel Zeit bis zu deiner Abschlussprüfung und wirst bis dahin (hoffentlich) noch so einiges in Berufsschule und Betrieb lernen und auch ein Gefühl für die verschiedenen Code-Komponenten bekommen und wie man darazs einen Algorithmus zu einem gegebenen Problem schreibt.

vor einer Stunde schrieb here:

Wie bereite ich mich am besten auf diese Aufgabentypen vor?

Wie bei fast allem: Üben! Zum Beispiel durch alte Prüfungsaufgaben. Es gibt aber auch diverse Internetseiten, die dir kleine Probleme geben, für die du dann eine Lösung coden sollst. Sowas stärkt dein Verständnis dafür, was mit der Aufgabenstellung von dir verlangt wird und wie man das dann auch programmier-technisch umsetzt.

[Visar]

An deiner Stelle würde ich vor allem versuchen, bei einem Lösungsstil zu bleiben. Entweder, sofern es IHK-seitig erlaubt ist, Programmcode oder halt dieses Pseudocodegeschwurbel. Wenn du die Wahl hast, nimm unbedingt das, was dir wirklich besser liegt.

Pseudocode ist mir nie so leicht von der Hand gegangen wie eine normale For-Schleife (Fand immer dumm das so zu beschreiben wie z.B. "Für alle Routen in Tabelle"), weswegen ich in der Prüfung auch in C#/PHP gescribbled hab, um meine Lösung dann noch kurz vor Ende auf den Lösungsbogen zu übertragen. Nicht unbedingt das beste Vorgehen in Sachen Zeitmanagement, aber solange es funktioniert..

[Gast here]

vor 6 Stunden schrieb Rienne:

 

Was genau fällt dir schwer beim Pseudocode? Das Strukturieren des Programmablaufs oder der Pseudocode selber?

Wie bei fast allem: Üben! Zum Beispiel durch alte Prüfungsaufgaben. Es gibt aber auch diverse Internetseiten, die dir kleine Probleme geben, für die du dann eine Lösung coden sollst. Sowas stärkt dein Verständnis dafür, was mit der Aufgabenstellung von dir verlangt wird und wie man das dann auch programmier-technisch umsetzt.

In dem Fall tatsächlich erst einmal der Unterschied zum sonstigen spezifischen Code einer Sprache. Ich habe noch nie Pseudocode geübt, bzw. mal ein bewusst ein richtiges Beispiel studiert. 

Wenn ich die Aufgabe in einer mir gängigen Sprache löse, dann muss die Syntax stimmen. Fehler sind dort ja schneller gemacht als mit Pseudocode, darum möchte ich lieber diesen anwenden lernen (und natürlich das Problem richtig lösen können).

Ansonsten sehe ich die Schwierigkeit, es zu kompliziert anzugehen und mich dann zu verzetteln. Genau auch das Problem, keinen Ansatz zu finden, bzw. zu lange zu brauchen, um das Problem aus dem Text zu erfassen.

Ich brauche da von Anfang eine gute Herangehensweise.
 

[Whiz-zarD]

"Pseudocode" ist auch nicht standadisiert. Der kann irgendwie aussehen. Es hat sich aber eine Pascal-ähnliche Syntax etabliert. Im Wikipedia-Artikel siehst du einige Beispiele, wie es aussehen kann.

Es gibt auch keine Zauberformel, an die man halten kann, um die Aufgaben zu erledigen. Man muss halt die Aufgabe in kleine Teilprobleme zerlegen und dann zusammenfügen. Da heißt es aber üben, üben, üben.