drei Integer-Werte einzugeben



  • Nun besitze ich >>Einführung in die Programmierung mit C++ Bjarne Stroustrup
    und hab neue Herausforderungen:
    Schreiben sie ein Programm das den Benutzer auffordert, drei
    Integer-Werte einzugeben, und dann die Werte in numerischer Reihenfolge getrennt durch Komma ausgibt. Wenn der Benutzer die Werte 10 4 6 eingibt, sollte die Ausgabe „4, 6, 10“. Wenn zwei Werte gleich sind
    sollten sie zusammen stehen; d.h., die Eingabe 4 5 4 sollte „4, 4, 5“ ergeben.

    Die Lösung wird Anfänger - Niveau sein, aber für mich zu hoch.
    Zu viel if und was mach ich mit else, Operatoren müssen auch rein. 😕

    Brauche einige Tips 😞
    Viele Dank im Voraus

    #include <iostream>
    using namespace std;
    
    int main()
    {
        cout << "geben sie drei int werte ein\n";
        int wertTest1,wertTest2,wertTest3;
    
        cin>>wertTest1>>wertTest2>>wertTest3;
     //??????????????????????????????????????   
            if (wertTest1<wertTest2)
            if (wertTest2<wertTest3)
            if (wertTest1<wertTest2)
    //???????????????????????????????????????
        cout<<wertTest1<<" , "<<wertTest2<<" , "<<wertTest3<<'\n';
    }
    


  • Paar Tipps für Google:

    std::vector
    std::sort
    std::copy in Verbindung mit std::ostream_iterator



  • Soll das nur mit if / else usw. gelöst werden oder wie weit bist du in dem Buch`?



  • daddy_felix schrieb:

    Paar Tipps für Google:

    std::vector
    std::sort
    std::copy in Verbindung mit std::ostream_iterator

    Um drei Werte zu sortieren reichen drei bedingte Swaps ohnehin völlig aus. Wieso du bei einer fixen Anzahl an Werten mit einem std::vector ankommst verstehe ich nicht.



  • juhu123 schrieb:

    Die Lösung wird Anfänger - Niveau sein, aber für mich zu hoch.
    Zu viel if und was mach ich mit else, Operatoren müssen auch rein. 😕

    Ja, aber mehr als ein bisschen if brauchst du auch nicht.

    Die Lösung sollte ungefähr so aussehen: Vergleiche zwei Werte und vertausche sie, falls sie in der falschen Reihenfolge stehen. Du musst dir überlegen, welche Werte du vergleichen musst und wie oft du vergleichen musst, um sicher zu sein, dass du alle Möglichkeiten erwischt hast. Es kann sich anbieten, sich das ganze als Entscheidungsbaum aufzuzeichnen.

    std::vector, std::sort usw. würde ich an der Stelle vermeiden, das ist nicht Sinn der Übung.

    Alternativ kannst du auch ein paar (wie viele brauchst du?) ifs hinschreiben, die prüfen, welche der möglichen Anordnungen vorliegt. Die vertauschen-Lösung ist aber das einfachste.



  • Bashar schrieb:

    juhu123 schrieb:

    Die Lösung wird Anfänger - Niveau sein, aber für mich zu hoch.
    Zu viel if und was mach ich mit else, Operatoren müssen auch rein. 😕

    Ja, aber mehr als ein bisschen if brauchst du auch nicht.

    Die Lösung sollte ungefähr so aussehen: Vergleiche zwei Werte und vertausche sie, falls sie in der falschen Reihenfolge stehen. Du musst dir überlegen, welche Werte du vergleichen musst und wie oft du vergleichen musst, um sicher zu sein, dass du alle Möglichkeiten erwischt hast. Es kann sich anbieten, sich das ganze als Entscheidungsbaum aufzuzeichnen.

    std::vector, std::sort usw. würde ich an der Stelle vermeiden, das ist nicht Sinn der Übung.

    Alternativ kannst du auch ein paar (wie viele brauchst du?) ifs hinschreiben, die prüfen, welche der möglichen Anordnungen vorliegt. Die vertauschen-Lösung ist aber das einfachste.

    Mit zwei geht das so, ist aber bestimmt keine saubere Arbeit
    und bei drei das reine Chaos
    brauche noch einen Tip

    #include <iostream>
    using namespace std;
    
    int main()
    {
        cout << "geben sie drei int werte ein\n";
        int wertTest1,wertTest2,wertTest3;
    
        cin>>wertTest1>>wertTest2>>wertTest3;
    
            if (wertTest1<wertTest2)
    
                cout<<wertTest1<<" , "<<wertTest2<<'\n';
                else
                {
                    cout<<wertTest2<<" , "<<wertTest1<<'\n';
                }
    
    }
    


  • juhu123 schrieb:

    Mit zwei geht das so, ist aber bestimmt keine saubere Arbeit
    und bei drei das reine Chaos

    Das ist schon OK so (mit vernünftiger Einrückung).



  • Es geht auch der altbewährte swap-Trick:

    if (b < a)
      std::swap(a, b);
    if (c < a)
      std::swap(a, c);
    if (c < b)
      std::swap(b, c);
    // a ist nun der kleinste, b der zweitkleinste, c der größte
    

    Oder geschicktes Nutzen von std::min:
    [code="cpp"]a = std::min(a, b);
    a = std::min(a, c);
    b = std::min(b, c);[/code]



  • Nathan schrieb:

    Oder geschicktes Nutzen von std::min:

    a = std::min(a, b);
    a = std::min(a, c);
    b = std::min(b, c);
    

    Das ist keine gute Idee, wenn b < a verlierst Du nach dem ersten Statement den Inhalt von a.

    mfg Martin



  • mgaeckler schrieb:

    Nathan schrieb:

    Oder geschicktes Nutzen von std::min:

    a = std::min(a, b);
    a = std::min(a, c);
    b = std::min(b, c);
    

    Das ist keine gute Idee, wenn b < a verlierst Du nach dem ersten Statement den Inhalt von a.

    Arg, stimmt.



  • Bashar schrieb:

    std::vector, std::sort usw. würde ich an der Stelle vermeiden, das ist nicht Sinn der Übung.

    Nein? Woher soll ich wissen, was Sinn der Übung ist?

    Apfelkuchen um 4 schrieb:

    Wieso du bei einer fixen Anzahl an Werten mit einem std::vector ankommst verstehe ich nicht.

    Weil man dann nicht alles anpassen muss, wenn sich die Zahl ändert oder sogar variabel wird?


  • Mod

    daddy_felix schrieb:

    Bashar schrieb:

    std::vector, std::sort usw. würde ich an der Stelle vermeiden, das ist nicht Sinn der Übung.

    Nein? Woher soll ich wissen, was Sinn der Übung ist?

    Musstest du nie Aufgaben dieser Art lösen?



  • Zum Vergleich mal die saubere Lösung (ungetestet):

    #include <iostream>
    #include <array>
    #include <algorithm>
    
    int main()
    {
    	std::cout << "geben sie drei int werte ein\n";
    	std::array<int, 3> elements;
    	for (int &e : elements)
    	{
    		std::cin >> e;
    		//Fehlerbehandlung?
    	}
    	std::sort(begin(elements), end(elements));
    	std::copy(begin(elements), end(elements), std::ostream_iterator<int>(std::cout, ", "));
    	std::cout << '\n';
    }
    


  • [quote="Bashar"][quote="juhu123"]
    Mit zwei geht das so, ist aber bestimmt keine saubere Arbeit
    und bei drei das reine Chaos [/quote]
    Das ist schon OK so (mit vernünftiger Einrückung).[/quote]

    Der Sinn der Aufgabe ist mir schon klar, es wird um den logischen Einsatz der Operatoren gehen. 😕
    Aber was ich hier mache ist totaler Käse. Den Käse erspare ich euch.

    Es müssen wahrscheinlich mehrere Operatoren richtig verbunden werde. Darin bin ich leider nicht gut (keine Erfahrung) 😞
    brauche noch einen Tipp, Danke



  • Herzlichen Glückwunsch an die üblichen Verdächtigen, die hier wieder einmal gezeigt haben, wie ach so gut sie C++ können. 👎 Und nun bitte leise sein und die Leute erklären lassen, die nicht vorhaben, sich zu profilieren, sondern dem TE tatsächlich helfen möchten (z.B. Bashar).



  • Wie weit bist du in dem Buch.
    Darfst /Kannst du für die Aufgabe eine Funktion benutzen? z.B. ein selbst gemachtes swap oder nur vergleichen und if else ?

    Du hast ja schon gezeigt wie es mit 2 Werten geht, versuch das Vorgehen mit 3 Werten auszubauen. bzw, zeig mal was du schon hast.



  • Es müssen wahrscheinlich mehrere Operatoren richtig verbunden werde. Darin bin ich leider nicht gut (keine Erfahrung)
    brauche noch einen Tipp, Danke

    Tipps sind wie von Nathan , swap (evtl. selbst gemacht) nutzen oder eben das if Konstrukt ausbauen.

    Oder willst du lieber eine komplette Lösung?



  • Ich finde die Aufgabe ziemlich schwierig für einen Anfänger. Ich wüsste auf Anhieb auch nicht wie man drei Zahlen mit Vergleichen und Vertauschen am besten in die richtige Reihenfolge bringt. Natürlich kann man das durch Herumprobieren lösen, aber was soll das? Ich kann das systematisch herleiten, aber das kann ein Programmieranfänger nicht.

    Ich habe die Aufgabe mal ohne std::sort gelöst. Ich hoffe man kann das nachvollziehen (also als fortgeschrittener Mitleser).

    #include <iostream>
    #include <array>
    #include <algorithm>
    #include <cassert>
    
    template <class RandomAccessIterator>
    void bubble_sort(RandomAccessIterator begin, RandomAccessIterator end)
    {
      //Ist für n=3 gut genug.
      //Kann man ein wenig effizienter umsetzen, aber das ist hier auch egal.
      for (RandomAccessIterator i = begin; i != end; ++i)
      {
        if ((i + 1) == end)
        {
          break;
        }
        for (RandomAccessIterator k = begin; (k + 1) != end; ++k)
        {
          if (k[0] > k[1])
          {
            std::swap(k[0], k[1]);
          }
        }
      }
    }
    
    void unrolled_bubble_sort(std::array<int, 3> &elements)
    {
      //Ich habe manuell Inlining von bubble_sort(begin(elements), end(elements)) durchgeführt,
      //Schleifen und toten Code entfernt.
      if (elements[0] > elements[1])
      {
        std::swap(elements[0], elements[1]);
      }
      if (elements[1] > elements[2])
      {
        std::swap(elements[1], elements[2]);
      }
      if (elements[0] > elements[1])
      {
        std::swap(elements[0], elements[1]);
      }
    #if 0 //Diese Vergleiche wurden in bubble_sort gemacht, sind aber redundant.
      if (elements[1] > elements[2])
      {
        std::swap(elements[1], elements[2]);
      }
      if (elements[0] > elements[1])
      {
        std::swap(elements[0], elements[1]);
      }
      if (elements[1] > elements[2])
      {
        std::swap(elements[1], elements[2]);
      }
    #endif
    }
    
    void test_sort()
    {
      //probiere alle 6 Möglichkeiten durch, um unrolled_bubble_sort zu testen (dass die Funktion für {1, 2, 2} etc korrekt ist, sehe ich so)
      std::array<int, 3> elements = {{1, 2, 3}};
      do
      {
        auto sorting = elements;
        ::unrolled_bubble_sort(sorting);
        assert(std::is_sorted(begin(sorting), end(sorting)));
      } while (std::next_permutation(begin(elements), end(elements)));
    }
    
    int main()
    {
      test_sort();
    
      std::cout << "geben sie drei int werte ein\n";
      std::array<int, 3> elements;
      for (int &e : elements)
      {
        std::cin >> e;
        //Fehlerbehandlung?
      }
    
      //std::sort(begin(elements), end(elements));
      ::unrolled_bubble_sort(elements);
    
      std::copy(begin(elements), end(elements), std::ostream_iterator<int>(std::cout, ", "));
      std::cout << '\n';
    }
    

    Existierende Funktionalität der Sprache zum Sortieren zu nutzen halte ich in jeder Hinsicht für die beste Lösung. Es würde mich wundern, wenn das nicht gerade für Stroustrup die optimale Lösung wäre.
    Steht die Aufgabe denn vor der Einführung von std::sort in dem Buch?
    Es kann natürlich auch sein, dass das Herumprobieren und die damit verbundene Beschäftigung mit Sprache und Werkzeugen die eigentliche Aufgabe sind.



  • Habs ohne kompliziertes Sortieren gepackt, musste aber ganz leicht von der Aufgabenstellung abweichen:

    #include <iostream>
    using namespace std;
    
    int main()
    {
        cout << "geben sie drei int werte zwischen -1Mrd und 1Mrd ein\n";
        int wertTest1,wertTest2,wertTest3;
    
        cin>>wertTest1>>wertTest2>>wertTest3;
    
        for(int i=-1000000000;i<=1000000000;++i)
        {
    		if(i==wertTest1) cout<<i<<' ';
    		if(i==wertTest2) cout<<i<<' ';
    		if(i==wertTest3) cout<<i<<' ';
        }
    }
    


  • int a, b, c; 
    	int count = 0;
    
    	std::cout << "Enter 3 Int's : ";
    	std::cin >> a >> b >> c ;
    
    	do{
    	  count++;
    
    	  if (a > b){
    	     std::swap(a, b);
    	     std::cout << "\n Swapped a and b\n";
    	  } else if (b > c){
    	  	         std::swap(b, c);
    	  	         std::cout << "\n Swapped b and c\n";
    	  	 } else if(c < a){
    	  	 	        std::swap(c, a);
    	  	 	        std::cout << "\nSwapped c and a\n";
    	  	 	}
    
      	 }while ( ! ( (a <= b) && (b <= c) && (c > a) ) );
    
      	 std::cout << "In # " << count << " # Changes  following Result : \n" << a << ',' << b << ',' << c << "\n";
    

    Nicht besonders schön, der c > a zweig ist eigentlich für die Katz , aber so würd ichs jetzt auf die Schnelle angehen.


Log in to reply