printPermuation of Array. Mal Hand aufs Herz ist der Algorithmus einfach oder schwer. Auf ner Skala von 1 bis 5 würde ich sagen sau schwer = 5 .

z.B. int* arr [3] = {1,2,3};

Ausgabe 1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

Ich weiß nicht, welchen Algorithmus du meinst, aber es gibt einen, der wäre eine 1 auf deiner Skala. Eher schon eine 0.

Ich würde ihm eine zwei geben.

template<class BidirIt>
bool next_permutation(BidirIt first, BidirIt last)
{
    if (first == last) return false;
    BidirIt i = last;
    if (first == --i) return false;

    while (1) {
        BidirIt i1, i2;

        i1 = i;
        if (*--i < *i1) {
            i2 = last;
            while (!(*i < *--i2))
                ;
            std::iter_swap(i, i2);
            std::reverse(i1, last);
            return true;
        }
        if (i == first) {
            std::reverse(first, last);
            return false;
        }
    }
}

Ich würde ihm eine zwei geben.

Deiner ist ja auch wesentlich komplizierter, als das, was ich machen würde.

----

Funktioniert dein "einser" Algorithmus auch wenn es Duplikate in dem Array gibt?

Funktioniert dein "einser" Algorithmus auch wenn es Duplikate in dem Array gibt?

Kommt drauf an, welches Ergebnis du in dem Fall wünscht. Mein Algorithmus glaubt nicht an die Ununterscheidbarkeit gleicher Werte

void list_permutations( int* arr, std::size_t len, std::size_t previous_len=0 ) {
	if (len==1) {
		while (previous_len--)
			std::cout << *arr--;
		std::cout << *arr << std::endl;
		return;
	}

	for (std::size_t p = 0; p != len; ++p) {
		std::iter_swap(arr, arr+p);
		list_permutations(arr+1, len-1, previous_len+1);
		std::iter_swap(arr, arr+p);
	}
}

ein - ist aber IMO keine 1.

Schliesslich wird vorausgesetzt dass die Elemente sortierbar sind.

Ich dachte eher daran dass es nicht um Ganzzahlmengen mit lediglich konsekutiven Elementen geht, die auch noch mit 1 beginnen.

"Für beliebige Mengen" finde ich eine komische Forderung, da der next_permutation der STL (den du ja gezeigt hast) gerade nicht für beliebige Mengen funktioniert.

Ich stelle eine Forderung an seine Implementierung. Was hat mein gepasteter Code damit überhaupt zu tun? Den nahm ich lediglich zum vorzeigen der Komplexität.
Edit: Gut, ich hätte erwähnen sollen dass ich next_permutation nicht als tatsächlichen Kandidat vorschlug. Mea culpa.

Welches ist die Reihenfolge?

Welches ist die Reihenfolge?

Offensichtlich wäre es nicht schlecht wenn die Permutationen in lexikographischer Reihenfolge durchlaufen werden.

Verstehe ich da gerade richtig? Das ist irgendwie eine komische Anforderung.

Mir geht es darum dass dein Algo kein Spezialisierter ist, der lediglich die Permutationen der ersten N natürlichen Zahlen ausgibt. Es soll ein allgemeiner Algo sein. Wenn deiner tatsächlich allgemeine ist, wie soll er dann den in meinem obigen Post in Einfachheit übertreffen?

Mir zumindest fällt nix einfacheres ein.
Und wenn std::next_permutation für dich ne 2 ist, dann wundert es mich dass du das nicht als 1 durchgehen lässt.

Hier ein Code im Anfängerstil:

#include <iostream>
#include <iterator>
#include <algorithm>
using namespace std;

void permprint(int *arr, int size, int curr=0) {
	if (curr+1 >= size) {
		for (int i=0; i<size; ++i)
			cout << arr[i] << ' ';
		cout << '\n';
	} else {
		for (int i=curr; i<size; ++i) {
			swap(arr[curr], arr[i]);
			permprint(arr, size, curr+1);
			swap(arr[curr], arr[i]);
		}
	}
}

int main() {
	int arr[] = {1, 2, 3, 4};
	permprint(arr, 4);
}

SeppJ schrieb:

hustbaer schrieb:

Funktioniert dein "einser" Algorithmus auch wenn es Duplikate in dem Array gibt?

Kommt drauf an, welches Ergebnis du in dem Fall wünscht. Mein Algorithmus glaubt nicht an die Ununterscheidbarkeit gleicher Werte

Aufgrund der undeutlichen Fragestellung dachte ich, es würde etwas erwartet, das aus der Menge {1, 1, 2} die Ausgabe
1 1 2
1 2 1
1 1 2
1 2 1
2 1 1
2 1 1
generiert. Fällt euch jetzt eine triviale Umsetzung ein, die wirklich ein 0 verdient?

Fällt euch jetzt eine triviale Umsetzung ein, die wirklich ein 0 verdient?

Mir nicht.
Ich wüsste nicht wie man den von Arcoth bzw. auch trivialo implementierten Algorithmus noch weiter vereinfachen könnte.
Will sehen!

Ich wüsste nicht wie man den von Arcoth bzw. auch trivialo implementierten Algorithmus noch weiter vereinfachen könnte.
Will sehen!

Ich meine den von trivialo bzw. den zweiten von Arcoth. Das ist in meinen Augen wesentlich einfacher als die Nummer 1 von Arcoth und verdient eine 1 oder weniger.

Dass Arcoth den für "schwerer als 1" hält hat er ja schon geschreiben.

Ich würde ihm ne 1 geben. Ne 0 finde ich übertrieben.

@SeppJ
Ich dachte dass du was anderes meinst, da dieser Algorithmus ja bereits 2x gepostet wurde bevor du gefragt hast ob uns was einfaches einfällt.

trivialo hat geantwortet, während ich meine Antwort formuliert habe und Arcoths iter_swap-Code habe ich nicht wirklich gelesen. Zu anstrengend.

Wenn man will, kann man die gleiche Idee auch noch einfacher formulieren, wobei es aber für den Computer aufwändiger wird:

template<typename Vector> void print_combinations(Vector data, Vector history)
{
  if (data.empty())
    {
      for (const auto& e: history)
        std::cout << e << '\t';
      std::cout << '\n';
    }
  else
    {
      for (std::size_t i = 0; i < data.size(); ++i)
        {
          auto new_data = data;
          auto new_history = history;
          new_data.erase(new_data.begin() + i);
          new_history.push_back(data[i]);
          print_combinations(new_data, new_history);
        }
    }
}

ich hab jetzt mal den Algo gefunden . Ist der gut ? Leider versteh ich den überhaupt nicht. Allgemein hab ich große Probleme mit Rekursion. Sollte man sich das am besten mathematisch herleiten ?

void permute(int k,int size){
    int i;

    if (k==0)
        printArray(size);
    else{
        for (i=k-1;i>=0;i--){
            swap(i,k-1);
            permute(k-1,size);
            swap(i,k-1);
        }
    }

    return;
}