while Schleife



  • Auf dem Bildschirm soll es so angezeigt:Beispiel

    Rundenanzahl: 5
    Zeit pro Runde: 75
    1 75
    2 152
    3 231
    4 312
    5 395
    Maximale Zeit in [h]: 1
    In 1 Stunde(n) koennen 33 Runden gefahren werden.
    Das Programm funktioniert soweit. Die maximale Zeit in Stunden wird von der Tastatur gelesen .
    Es sollen die Anzahl der Runden gerechnet, in der vorgegebene Zeit
    Ich habe es matematisch gelöst.
    könnte man es mit mit While Schleife lösen, wenn ja wie

    #include <iostream>
    #include<math.h>
    
    using namespace std;
    
    int main()
    {
    
    
    int Zeit;
    
       unsigned Zahl = 0;
    unsigned Zeit_pro_Runde;
    
         cout<<"Rundezahl :";
      cin>>Zahl;
      cout<<" Zeit_pro_Runde :";
      cin>> Zeit_pro_Runde;
       for ( unsigned i = 1;i <= Zahl;i++ ) {
    
           cout << i << ' ' <<  (i*Zeit_pro_Runde) +i*(i-1)<< '\n';
    
    
    
       }
       cout<<"Maximale Zeit in [h]:";
       cin>>Zeit;
       int x =(((Zeit_pro_Runde-1)*(Zeit_pro_Runde-1))/4)+Zeit*3531;
       float  y=(Zeit_pro_Runde-1)/2;
       int z=-y+sqrt(x);
       cout<<"In "<< Zeit<< " Stunde(n) koennen "<< z<<" Runden gefahren werden."<<endl;
    
    
    
       return 0;
    }
    
    

    Übrigens ich bin ein Anfänger
    Danke


  • Mod

    Jede Schleifenart lässt sich in jede andere Art Schleife übersetzen.

    for(A; B; C)
    {
        D;
    }
    

    ist identisch zu

    {
        A;
        while (B)
        {
            D;
            C;
        }
    }
    


  • @SeppJ ich meinte diese Funktion

     cout<<"Maximale Zeit in [h]:";
       cin>>Zeit;
       int x =(((Zeit_pro_Runde-1)*(Zeit_pro_Runde-1))/4)+Zeit*3531;
       float  y=(Zeit_pro_Runde-1)/2;
       int z=-y+sqrt(x);
    
    


  • Bist du dir sicher, dass dein rechnerischer Ansatz stimmt? Es kanns sein, dass ich einfach noch was müde bin, aber mir erscheint das etwas komisch. Willst du nicht mal die ganze Aufgabe 1 zu 1 posten?


  • Mod

    Soll das darauf hinauslaufen, dass du, anstatt X*Y zu rechnen, X mal Y in einer Schleife addieren möchtest?

    Ich schließe mich @Schlangenmensch an. Am besten postest du mal die genaue Aufgabenstellung, damit klar ist, wo und warum eine while-Schleife benutzt werden soll.



  • Die Aufgabe
    Entwickeln Sie einen Formel 1-Rundenzähler, der einzelne Rundenzeiten auf dem Bildschirm ausgibt.
    Hierzu sind zuvor die Anzahl der Runden und die anfängliche Zeit pro Runde in Sekunden von der
    Tastatur einzulesen. Beachten Sie, dass aufgrund des Reifenverschleißes, die Zeit pro Runde um 2s
    anwächst. Verwenden Sie für die Ausgabe eine for-Schleife. Berechnen Sie, wie viele Runden in einem
    vorgegebenen Zeitraum vollständig durchfahren werden können. Hierzu lesen Sie zuvor die
    maximale Zeit in Stunden von der Tastatur ein. Verwenden Sie zur Berechnung eine while-Schleife
    und geben Sie das Ergebnis auf dem Bildschirm aus.



  • @dooni Und wie hängt das mit deiner Zahl 3531, mit den Divisionen und der Wurzel zusammen?



  • @wob ich habs nach diese Formel umgestellt (iZeit_pro_Runde) +i(i-1)
    bei dieser Formel wird die Zeit in Sekunden gerechnet.
    1Stunde=>3600s
    Damit er die Rundenzahl nicht rundet habe ich 3531 s verwendet,



  • Und wie bist du auf die magische Zahl 3531 gekommen? Hast du solange ausprobiert, bis bei deiner Testeingabe zufällig das richtige Ergebnis raus gekommen ist?

    Rechne lieber genau und überlege dir warum da "jemand rundet".

    Ansonsten kannst du natürlich mit der PQ Formel deine quadratische Gleichung nach der Anzahl der Runden auflösen und berechnen.

    Oder du zählst z.B. solange 😉 noch Zeit über ist, die Anzahl der Runden, die bis dahin geschafft worden sind.



  • Generell ist noch zu sagen, dass eine (natürlich korrekte!) Rechnung hier generell eine gute Sache ist. Allerdings sollte dann zumindest die pq-Formel dokumentiert sein und die Variablen nicht x, y und z, Zeit_pro_Runde und Zeit heißen. Fraglich ist auch, warum dann der /4-Teil mit integer-Division gemacht wird.
    Vor allem wenn mal Sekunden und mal Stunden verwendet werden, blickt keiner mehr durch. Am besten verwende std::chrono::duration! Also: generell gute Idee, das einfach zu errechnen. 3531 sollte aber nicht vorkommen. Und 3600 sollte benannt sein bzw. durch Verwendung von chrono überflüssig werden.

    In der Aufgabe soll aber eine Schleife verwendet werden. Ist zum Üben von Schleifen sicherlich in Ordnung.



  • @wob habs umgeschrieben , damit es übersichtlicher wird.Hat funktioniert

    #include <iostream>
    #include<math.h>
    
    using namespace std;
    
    int main()
    {
    
    
    int Zeit;
    
       unsigned Zahl = 0;
    unsigned Zeit_pro_Runde;
    
         cout<<"Rundezahl :";
      cin>>Zahl;
      cout<<" Zeit_pro_Runde :";
      cin>> Zeit_pro_Runde;
       for ( unsigned i = 1;i <= Zahl;i++ ) {
    
           cout << i << ' ' <<  (i*Zeit_pro_Runde) +i*(i-1)<< '\n';
    
    
    
       }
       cout<<"Maximale Zeit in [h]:";
       cin>>Zeit;
       int x ;
       int p=Zeit_pro_Runde-1;
       int q=Zeit*3600;
         x=(-(p/2.0))+sqrt((-p/2.0)*(-p/2.0)-(-q));
          
       
       cout<<"In "<< Zeit<< " Stunde(n) koennen "<< x<<" Runden gefahren werden."<<endl;
    
    
    
       return 0;}
    
    

    wie kann ich es statt pq Formel mit While Schleife lösen
    hat einer eine Idee?



  • Hm....

    Vielleicht so? Irgendwie frage ich micht, ob das nicht einfacher geht (und ja, es wäre normalerweise besser, die Anzahl der Runden mit einer Formel zu ermitteln)

    #include <chrono>
    #include <iostream>
    
    using namespace std;
    
    auto read_rundenzeit() {
        cout << "Zeit_pro_Runde [s]: ";
        int zpr;
        cin >> zpr;
        return chrono::seconds(zpr);
    }
    
    auto read_max_zeit() {
        cout << "Maximale Zeit [h]: ";
        int h;
        cin >> h;
        return chrono::hours(h);
    }
    
    auto read_runden_to_display() {
        int max_runden;
        cout << "Rundezahl: ";
        cin >> max_runden;
        return max_runden;
    }
    
    int main() {
        const int runden_to_display = read_runden_to_display();
        // Hier überall explizit Sekunden nehmen, damit wir uns duration_casts
        // ersparen können.
        const chrono::seconds initial_rundenzeit = read_rundenzeit();
        const chrono::seconds max_zeit = read_max_zeit();
        const chrono::seconds rundenzeit_addition = chrono::seconds(2);
    
        auto time_elapsed = initial_rundenzeit;
        auto aktuelle_rundenzeit = initial_rundenzeit;
        int aktuelle_runde = 0;
        int max_runden_in_zeit = 0;
        // Wir müssen loopen, solange die anzuzeigende Anzahl Runden nicht erreicht
        // ist oder die Rundenzeit nicht größer als das Maximum ist (damit die
        // beiden Fälle maximale Zeit < Rundenzeit sowie Zeit der anzuzeigenden
        // Runden länger als maximale Zeit abgedeckt sind)
        while ((time_elapsed += aktuelle_rundenzeit) <= max_zeit ||
               aktuelle_runde < runden_to_display) {
            ++aktuelle_runde;
            if (time_elapsed <= max_zeit)
                ++max_runden_in_zeit;
            if (aktuelle_runde <= runden_to_display)
                cout << "Runde " << aktuelle_runde << ", Rundenzeit "
                     << aktuelle_rundenzeit.count()
                     << " s, Gesamtzeit: " << time_elapsed.count() << " s\n";
            aktuelle_rundenzeit += rundenzeit_addition;
        }
        cout << "Es können maximal " << max_runden_in_zeit
             << " Runden gefahren werden.\n";
    }
    


  • Ich glaube du machst es dir zu kompliziert wob. Der Aufgabensteller will den ersten Teil in einer For Schleife und nur den zweiten Teil in einer while Schleife.

    @dooni du musst mir den i(i-1) Teil noch mal erklären. Du hast jede Runde 2 Sekunden mehr, dass ist für mich ein lineares Wachstum. Du kommst mit i=4 in der vierten Runde schon auf 12 Sekunden extra. Sollten aber nur 6 Sekunden extra sein (1. Runde = 0 extra, 2. Runde =2, 3. =4 und 4.=6).

    Außerdem frage ich mich grade, ob mit Rundenzeit die Dauer einer Runde, oder der relative Zeitpunkt, wann die xte Runde abgeschlossen ist, gemeint ist. Ich tippe auf ersteres. Das ist aber nicht, was du implementiert hast.

    Edit: Sry, bin offenbar nicht konzentriert genug. Wenn du den relativen Zeitpunkt berechnen willst, hast du mit deiner Formel recht, ist aber nicht das, was erwartet wird (wie ich glaube).

    Da ich grade auf dem Smartphone tippe, spare ich mir konkreten Code zur Verdeutlichung zu schreiben. Ergänze ich vlt morgen, wenn ich am Computer bin.



  • @Schlangenmensch Jede Runde 2 Sekunden (pro bisher gefahrener Runde) mehr als in der vorherigen Runde. Das passt schon, (i-1)*i ist schon die für das Problem angepasste Summenformel.
    12 Sekunden nach 4 Runden ist zumindest nach der Aufgabenstellung korrekt (ich bin zwar kein Experte, aber ich dachte, mit steigender Rundenzahl wird der Grip bis zu einem bestimmten Punkt besser - mal abgesehen von dem sinkenden Gewicht).

    1. 0
    2. 2
    3. 2+2*2
    4. 6+3*2

    Nullstelle
    ->i^2+(Zeit_pro_Runde-1)*i-3600 *h=0

    In der Schleife kann natürlich auch jede Runde direkt berechnet werden, eben i^2+(Zeit_pro_Runde-1)*i. Kürzer wäre das zumindest.



  • @yahendrik Danke, ich sollte so spät nicht mehr schreiben, das geht nur schief.
    Ich glaube trotzdem, dass der Aufgabensteller die Zeit pro Runde haben möchte und nicht die insgesamt verstrichene Zeit.

    Um den Code von @wob aufzugreifen, für den mit while zu lösenden Teil, sollte das ausreichen:

    
    #include <chrono>
    #include <iostream>
    
    using namespace std;
    
    auto read_rundenzeit() {
        cout << "Zeit_pro_Runde [s]: ";
        int zpr;
        cin >> zpr;
        return chrono::seconds(zpr);
    }
    
    auto read_max_zeit() {
        cout << "Maximale Zeit [h]: ";
        int h;
        cin >> h;
        return chrono::hours(h);
    }
    
    
    
    int main() {
        
        // Hier überall explizit Sekunden nehmen, damit wir uns duration_casts
        // ersparen können.
        const chrono::seconds initial_rundenzeit = read_rundenzeit();
        const chrono::seconds max_zeit = read_max_zeit();
        const chrono::seconds rundenzeit_addition = chrono::seconds(2);
    
        auto time_elapsed = chrono::seconds(0);
        auto aktuelle_rundenzeit = initial_rundenzeit;
        int max_runden_in_zeit = 0;
     
        while ((time_elapsed += aktuelle_rundenzeit) <= max_zeit) 
        {
            ++max_runden_in_zeit;
            aktuelle_rundenzeit += rundenzeit_addition;
        }
        cout << "Es können maximal " << max_runden_in_zeit
             << " Runden gefahren werden.\n";
    }
    


  • Ich danke euch für eure Bereitschaft und eure Hilfe


Anmelden zum Antworten