drei Integer-Werte einzugeben

Bashar

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).

Nathan

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]

mgaeckler

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

Nathan

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.

daddy_felix

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?

SeppJ

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?

TyRoXx

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';
}

juhu123

[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?

TyRoXx

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.

volkard

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.

volkard

maybe schrieb:

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

Gute Idee. Habs ein wenig verbessert. Wenn genau fassen kann, wie weit die Sortierung schon vorangeschritten ist, und das vielleicht sogar aufschreibt, kann man (wie TyRoXx es gemacht hat) Schleifen abrollen und trotzdem genau wissen, daß man korrkt bleibt.

int a, b, c; 
//	int count = 0;//braucht keiner

	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
//jetzt steht von a,b der größere hinten
	if (b > c){
	  	         std::swap(b, c);
	  	         std::cout << "\n Swapped b and c\n";
	  	 } //else 
//und jetzt steht von a,b,c der größte hinten!
//nurnoch a,b in ordnung bringen und wir sind fertig. 
	if(a > b){
	  	 	        std::swap(a, b);
	  	 	        std::cout << "\nSwapped a and b\n";
	  	 	}

//  	 }while ( ! ( (a <= b) && (b <= c) && (c > a) ) );

  	 std::cout << "In # " << count << " # Changes  following Result : \n" << a << ',' << b << ',' << c << "\n";

Nathan

volkard schrieb:

maybe schrieb:

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

Gute Idee. Habs ein wenig verbessert. Wenn genau fassen kann, wie weit die Sortierung schon vorangeschritten ist, und das vielleicht sogar aufschreibt, kann man (wie TyRoXx es gemacht hat) Schleifen abrollen und trotzdem genau wissen, daß man korrkt bleibt.

Jetzt löscht man noch unnötige Debugausgaben:

int a, b, c;
//  int count = 0;//braucht keiner

    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
//jetzt steht von a,b der größere hinten
    if (b > c){
                 std::swap(b, c);
//               std::cout << "\n Swapped b and c\n";
         } //else
//und jetzt steht von a,b,c der größte hinten!
//nurnoch a,b in ordnung bringen und wir sind fertig.
    if(a < b){
                    std::swap(a, b);
//                  std::cout << "\nSwapped a and b\n";
            }

//       }while ( ! ( (a <= b) && (b <= c) && (c > a) ) );

     std::cout << "In # " << count << " # Changes  following Result : \n" << a << ',' << b << ',' << c << "\n";

Und schon erhält man das, was ich gepostet habe, nur andersherum:

Nathan schrieb:

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

Ich find die Lösung von Volkard auch gut. Darauf wär ich nicht gekommen.