Hilfe - Matrix umgekehrt ausgeben



  • Hallo,

    ich suche dringend nach Hilfe und hänge über dem Problem schon eine ganze Weile.

    Ich würde gerne eine Matrix umgekehrt ausgeben.
    Mein Einlagerungscode wäre dieser:

    for (int s=0; s<4; s++) {
    if (feld2[ebene][s] < 30) {
    while (feld2[ebene-1][s] < 30 && werkstuecke > 0) {
    feld2[ebene-1][s] = feld2[ebene-1][s] +1;
    werkstuecke--;
    };
    }
    else s++; //ein Fach weiter
    };

    Nun soll das Programm quasi von "rechts" die vorher eingelagerten "werkstuecke" wieder heraus nehmen, dabei sollte die Fächer dieser Ebene von links nach rechts wieder genullt werden. Also quasi nachgeschoben werden.
    Ich weiß aber leider nicht wie ich diesen Code "umdrehen" soll..

    Vielleicht kann mir ja hier jemand behilflich sein.

    Danke+ Gruß, 🙂



  • Du hängst da schon eine ganze Weile? Ist nich wahr. Hast du bei dem Teil mit den Vorschleifen geschlafen oder fehlt es dir an der Logik selbst?
    Achja, und benutze bitte Codetags!



  • Ich versuch mal etwas Klarheit zu bekommen

    Du hast 4 Fächer.
    In diese passen 30 Werkstücke rein.
    Wenn ein Fach voll ist, dann soll das nächset genommen werden.

    Es gibt noch verschiedene Ebenen von den 4 Fächern

    Aber trotzdem verstehe ich 2 Sachen nicht:

    for (int s=0; s<4; s++) {       // gehe alle Fächer der Ebene durch
                if (feld2[ebene][s] < 30) {   // wenn noch Platz ist
                        while (feld2[ebene-1][s] < 30 && werkstuecke > 0) { // Warum denn jetzt ebene-1 ?
                            feld2[ebene-1][s] = feld2[ebene-1][s] +1;       // Einlagern
                            werkstuecke--;
                            };
                        }
                 else s++; //ein Fach weiter // wird das nicht schon im Schleifenkopf (Zeile 1) gemacht?
            };
    

    Deine while-Schleife kannst du auch berechnen lassen.

    FlyingBull schrieb:

    Nun soll das Programm quasi von "rechts" die vorher eingelagerten "werkstuecke" wieder heraus nehmen, dabei sollte die Fächer dieser Ebene von links nach rechts wieder genullt werden. Also quasi nachgeschoben werden.

    Du willst aus dem Fach 3 etwas rausnehmen und dann soll das wieder mit Teilen aus dem Fach 2 aufgefüllt werden.
    Und das Fach 2 dann mit Teilen aus Fach 1 ?

    Das Wäre dann eine Mischung aus LIFO, wenn die Fächer noch nicht voll sind und LILO wenn die Fächer schon mal voll waren.

    Wie erkennst du den Unterschied, ob das Teil aus Fach 3 oder Fach 0 kommt?
    Im Augenblick sind es ja nur Werte im Fach. Da gibt es keinen Unterschied ob du erst Fach 0 leer machst und dann Fach 1 ...



  • Richtig DirkB,

    Die else Funktion könnte ich weg lassen.
    Das [Ebene-1]: Die Matrix muss bei der Zeilenabfrage 1,2 o 3 belegt werden. Deshalb Ebene-1 sodass ich nicht ins "Leere" schreibe.
    Das läuft auch so.

    Die Frage ist nur: wie kann ich das Feld nun umdrehen um mir Pro Zeile eine Ausgabe, von den eingegebenen Werkstücken, zu erhalten.

    Danke + Gruß



  • Der Code räumt die Fächer von 3 nach 0 leer

    for(int i=3;i>=0 && werkstuecke>0;i--) 
    {
      if (feld2[ebene][s] > werkstuecke ) 
      { feld2[ebene][s] -= werkstuecke;  // es sind genug Werkstücke im Fach
        werkstuecke = 0;
      } 
      else
      { werkstuecke -= feld2[ebene][s];
        feld2[ebene][s] = 0;
    }
    


  • Danke DirkB,

    Es läuft soweit mit dem auslagern.
    Leider zieht er die Werkstücke noch nicht von links nach Rechts.

    Gruß,



  • Du lagerst von 0 nach 3 ein, willst aber von 3 nach 0 auslagern.
    Was passiert in der Zeit, wo du nur in Fach 0 eingelagert hast (z.B: 20)
    Nach dem Auslagern von 15 sollen dann die restlichen 5 in Fach 3 sein?

    Wo werden dann die Nächsten 20 eingelagert? Fach 0?

    Welchen Vorteil hat das?

    for(int i=0;i<4 && werkstuecke>0;i++)  // maximal 4 Durchläufe oder alle Werkstücke sind geholt
    {
      if (feld2[ebene][3] > werkstuecke )
      { feld2[ebene][3] -= werkstuecke;  // es sind genug Werkstücke im Fach
        werkstuecke = 0;                 
      }
      else
      { werkstuecke -= feld2[ebene][3];         // jetzt ist Fach 3 leer
        for (int j=3;j>0;j--)                   // Darum auffüllen
        { feld2[ebene][j] = feld2[ebene][j-1];  // Fach 2 -> Fach 3, Fach 1 -> Fach 2, Fach 0-> Fach 1
        }
        feld2[ebene][j]=0;                      // Fach 0 ist jetzt leer
      }
    }
    

    ungetestet



  • Glaube ich hab das Falsch dargestellt... sorry.

    Meine Ebenen sind meine Zeilen und meine Spalten meine Fächer

    Gruß,



  • Ich habe die Kommentare nochmal angepasst.

    FlyingBull schrieb:

    Nun will ich eben aus dem 4. Fach herausnehmen und beim Auslagern werden zuerst Werkstücke aus Fach 4 entnommen.

    Zeile 3 - 5

    FlyingBull schrieb:

    Sind nicht genügend Werkstücke in Fach 4, dann werden die vorhandenen Werkstücke entnommen.

    Zeile 8

    FlyingBull schrieb:

    Darauf läuft die Automatisierung und alle Fächer dieser Ebene werden um ein Fach nach rechts geschoben.

    Zeile 9-12

    FlyingBull schrieb:

    Wieder werden Werkstücke entnommen.

    Zeile 3-8

    FlyingBull schrieb:

    Reicht es wieder nicht, erfolgt der nächste Rechts-Shift

    Zeile 9-12

    FlyingBull schrieb:

    usw. maximal viermal.

    Zeile 1



  • Es läuft!
    Perfekt.
    Danke! 🙂


Log in to reply