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

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

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.

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.

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

}

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

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]

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

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?

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?

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

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

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

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

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

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";

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