2D Array + Fehler bei Rundung der Eingabe nach Division



  • #include <iostream>
    using namespace std;
    
    struct fliese
    {
    float x; // Breite (x−Richtung) in cm
    float y; // Laenge (y−Richtung) in cm
    };
    
     int b_raum, l_raum;
     float b_fliese, l_fliese;
    
    
    int main()
    {
    
    cout.precision(2);
    
    
    cout << "Eingabe fuer die Breite min. 10cm" <<endl; // x-Richtung
    cin >> b_fliese ;
    cout << "Eingabe fuer die Laenge min. 10cm"<<endl; // y-Richtung
    cin >> l_fliese;
    cout << "Eingabe fuer die Breite des Raumes max. 800cm" << endl; // x-Richtung
    cin >> b_raum;
    cout << "Eingabe fuer die Laenge des Raumes max. 800cm" << endl; // y-Richtung
    cin >> l_raum;
    
    if (b_raum < b_fliese || l_raum < l_fliese) {
        cout << "Fehler: Die Fliese darf nicht groesser als der Raum sein"<<endl;
        return 0;
    } 
    // WENN FLIESE QUAD. ~~und Ganzzahl DANN Matrix mit 1 ausfüllen~~
    
    if (b_fliese == l_fliese) {
    
    /* FEHLER BEI DER RUNDUNG KONNTE NICHT GELÖST WERDEN, DAHER IST MATRIXAUSGABE 
    FALSCH
    RUNDUNGSBETRAG IMMER 1 WERT ZU HOCH */
    
    int f_anzahlproreihe = (b_raum/b_fliese);
    int aufrunden_b = (b_raum/b_fliese) - (10 * ((int)((b_raum/b_fliese)/10))); // AUFRUNDEN DES 
    REIHEN RESTWERTS
    
    if (aufrunden_b > 0) {
        f_anzahlproreihe += 1;
    }
    
    int f_anzahlprospalte = (l_raum/l_fliese);
    int aufrunden_l = (l_raum/l_fliese) - 10 * ((int)((l_raum/l_fliese)/10)); // AUFRUNDEN DES SPALTEN 
    RESTWERTS
    if (aufrunden_l > 0) {
        f_anzahlprospalte++;
    }
    
    // RUNDUNG BEENDET
    
    int f_anzahlges = f_anzahlproreihe * f_anzahlprospalte;
    
    cout <<fixed<<"Insgesamt werden " << f_anzahlges << " Fliesen benoetigt." << endl;
    
    
    fliese raum [f_anzahlprospalte][f_anzahlproreihe];
    int l_raum2= l_raum;
    for (int p = 0; f_anzahlprospalte > p ; p++) {
            int b_raum2 = b_raum;
      for (int q = 0; f_anzahlproreihe > q; q++) {
        if (p < f_anzahlprospalte -1 && q == 0) {
          raum[p][q].x = 1;
          raum[p][q].y = 1;
          b_raum2 = b_raum2 - b_fliese ;
          continue;
        }
     if (b_raum2  >= b_fliese) {
          raum[p][q].x = 1;
          b_raum2 = b_raum2 - b_fliese ;
        } else {
          raum[p][q].x = (int(b_raum2/b_fliese *100))/100.0; //FÜR DEZIMALSTELLEN
        }
    
        if (l_raum2 > l_fliese) {
          raum[p][q].y = 1;
        } else {
          raum[p][q].y = (int(l_raum2/l_fliese*100))/100.0;
        }
      }
      l_raum2 = l_raum2 - l_fliese;
    }
    
    // AUSGABE DER MATRIX
    for (int p = 0; p < f_anzahlprospalte ; p++) {
      for (int q= 0; q < f_anzahlproreihe ; q++)
        {
    cout << "      " <<raum[p][q].x << "          "<< raum[p][q].y << "      "  << "|";
      }
      cout << endl;
    }


  • Hey Leute!

    Ich weiß, dass ich nicht alles in die main Funktion packen sollte und das auf jeden Fall kein guter Stil ist. Mein Ziel ist es jedoch erstmal ein funktionierendes Grundgerüst zu haben 🙂

    Wie man sicherlich merkt, bin ich ein blutiger Anfänger. Die Aufgabe sieht wie folgt aus:

    • Nutzung von anderen Bibliotheken nicht erlaubt
    • Ausgabe einer Matrix mit einheitlichen Abständen, Werte gerundet auf zwei Nachkommastellen
    • Werte zwischen 1 und 0 erlaubt

    Mein Problem ist die Rundung (das denke ich zumindest :D)
    Der Wert ist, sowie ich es gesehen habe immer 1 zu hoch. Sodass die ausgegebene Matrix weder einheitlich, noch mit richtigen Werten gefüllt wird und außerdem die

     for (int p = 0; f_anzahlprospalte > p ; p++) 
    

    ein mal zu oft durchlaufen wird, womit die Breite und auch die Höhe ebenfalls falsch sind.

    Ich hoffe jemand hat ne Idee wie man das lösen kann.

    P.S die Aufgabe geht weiter, aber das ist mein Kernproblem (sowas wie floor() oder round() soll nicht genutzt werden).



  • @UPF4CK sagte in 2D Array + Fehler bei Rundung der Eingabe nach Division:

    Hey Leute!
    Ich weiß, dass ich nicht alles in die main Funktion packen sollte und das auf jeden Fall kein guter Stil ist. Mein Ziel ist es jedoch erstmal ein funktionierendes Grundgerüst zu haben

    Das ist oft der falsche Weg. Mach doch gleich Funktionen, das ist einfacher. Zum Beispiel hast du für die Breite und Länge schon einmal so ziemlich den gleichen Code. Das ist unnötig.

    Nutzung von anderen Bibliotheken nicht erlaubt

    Was sind "andere Bibliotheken"? Ist "include <cmath>" verboten? Du kannst natürlich sowas wie static_cast<int>(my_double + 0.5) zum Runden nehmen - nur ist das nicht empfehlenswert und funktioniert für std::nextafter(0.5, 0) nicht richtig. Es soll also irgendeine Krückenkonstruktion zum Runden gefunden werden?

    Am besten liest du Millimeter ein und vermeidest Fließkommazahlen.

    Ausgabe einer Matrix mit einheitlichen Abständen, Werte gerundet auf zwei Nachkommastellen
    Werte zwischen 1 und 0 erlaubt

    Abstände im Raum sind Längen und tragen somit Einheiten. Meinst du "Werte zwischen 1cm und 0cm erlaubt"? Aber was für Abstände sollen das sein, also Abstand zwischen was und was?

    Mein Problem ist die Rundung (das denke ich zumindest :D)
    Der Wert ist, sowie ich es gesehen habe immer 1 zu hoch.

    Wenn das wirklich immer so ist, dann ist die Lösung doch einfach: subtrahiere einfach 1.

    P.S die Aufgabe geht weiter, aber das ist mein Kernproblem (sowas wie floor() oder round() soll nicht genutzt werden).

    Wenn runden dein Kernproblem ist, dass schreib dir eine Funktion "runden". Zunächst nutzt du einfach lround und testest das Programm fertig. Danach ersetzt du es durch deine eigene Rundungsfunktion.



  • @UPF4CK sagte in 2D Array + Fehler bei Rundung der Eingabe nach Division:

    Die Aufgabe sieht wie folgt aus:

    • Nutzung von anderen Bibliotheken nicht erlaubt
    • Ausgabe einer Matrix mit einheitlichen Abständen, Werte gerundet auf zwei Nachkommastellen
    • Werte zwischen 1 und 0 erlaubt

    Mhm. Und was soll das ding tun?



  • @wob

    Vielen Dank für die Tipps.

    Mit anderen Bibliotheken ist z.B. sowas wie cmath gemeint, genau!
    Das mit den Funktionen wollte ich angehen, sobald der Code funktioniert, aber womöglich hast du Recht und es macht mir nur mehr Ärger.

    Die Rundung habe ich gelöst.
    Zumindest bei der Eingabe von den selben Werten für x und y habe ich nun die richtigen Ergebnisse!
    Falls es wen interessiert kommt unten der Code dazu.
    Ich habe einfach total verpeilt, dass mein Datentyp ein Integer war! Somit konnte mein Ergebnis gar nicht richtig sein.

    int f_anzahlproreihe = (b_raum/b_fliese);
    float aufrunden_b = (b_raum/b_fliese) - f_anzahlproreihe; // AUFRUNDEN DES REIHEN RESTWERTS
      if (aufrunden_b > 0) {
        f_anzahlproreihe += 1;
    }
    
    int f_anzahlprospalte = (l_raum/l_fliese);
    float aufrunden_l = (l_raum/l_fliese) - f_anzahlprospalte; // AUFRUNDEN DES REIHEN RESTWERTS
        if (aufrunden_l > 0) {
        f_anzahlprospalte++;
    }
    
    // RUNDUNG BEENDET


  • @Swordfish

    Am Ende soll man über die Matrix einen Verlegeplan für den Raum ausgeben.
    Die Werte in der Matrix sollen die Fliesen darstellen, die im Raum verlegt werden.
    Deshalb sollen die Werte in der Matrix im Zahlenbereich von 0 (keine Fliese) und 1 (1 ganze Fliese) dargestellt werden.
    Die Darstellung sieht dann z.b. so aus

    1 1 | 1 1
    1 1 | 1 1

    Das würd ebedeuten, dass man jeweils in x und y Richtung eine ganze Fliese verlegen muss. in Diesem Fall müssten dann insgesamt 4 Fliesen verlegt werden.

    Ich will den Aufgabentext nicht kopieren, so in etwa sieht es aber aus.


Anmelden zum Antworten