Mehrere Strings müssen nach Substrings sortiert werden.

Stringsbeispiele:

"[8A][Dings da][Orange-Blau]"
"[MOD][Weiss][UKE]"
"[GF][MOD3][Dings da]"
"[MOD][Black][UKE]"

Es gibt mehrere Gruppen von Substrings:

1. Gruppe:
   "[8A]"
   "[UKE]"

2. Gruppe.
   "[Dings da]"
   "[DingsBums]"

3. Gruppe.
   "[GF]"
   "[MOD]"
   "[MOD3]"
   "[MOD6]"

4. Gruppe.
   "[Weiss]"
   "[Rot]"
   "[Orange-Blau]"

Die Substrings müssen innerhab des Stringes nach Gruppenrang sortiert werden. Der String darf nur einen Substring aus einer Gruppe beinhalten.

Beispiele:
"[8A][Dings da][Orange-Blau]" -> "[8A][Dings da][Orange-Blau]"
"[MOD][Weiss][UKE]" -> "[UKE][MOD][Weiss]"
"[GF][MOD3][Dings da]" -> Fehler - [GF] und [MOD3] sind beide aus der Gruppe 3!
"[MOD][Black][UKE]" -> Fehler - [Black] ist nicht in den Substrings vorhanden!

Löse ich die Aufgabe am besten mit einem Container oder C-Array? Falls Container, welcher Art: vector, map, multimap usw.?
Und das wichtigste: wie am effektivsten (Algorithmus)?

Im Voraus besten Dank!

Nimm auf gar keinen Fall jemals C-Strings oder Arrays für irgendwas, wenn std::string & Co. erlaubt sind!

Von hier aus ist ad-hoc im Kopf programmiert, wie ich das ungefähr machen würde. Ich will dir ja nicht die Aufgabe komplett lösen

Du willst im Hintergrund wahrscheinlich eine map<int, vector<string>> haben, wo du deine vorgegebenen Wortgruppen drin gespeichert hast.

Dann beginnst du deinen jeweiligen String zu zerlegen, und merkst dir Paare der Substrings und der Gruppe aus der sie sind. Also vermutlich als vector<pair<string, int>>. Aus deinem Beispiel "[MOD][Weiss][UKE]" wird also die Paarfolge {("[MOD]", 3), ("[Weiss]", 4), ("[UKE]", 1)}. Man kann beim Zerlegen auch Mitzählen (auf allerlei Weise), ob und wie oft jede Gruppe vorkommt. Sobald man eine Gruppe zum 2. Mal sieht, kann man mit einem Fehler abbrechen.

Das kannst du dann mit sort nach dem zweiten Teil des Paars sortieren, du bekommst also die Folge {("[UKE]", 1), ("[MOD]", 3), ("[Weiss]", 4)}

Dann soll daraus ja wieder ein String werden. Dazu hängt man einfach die jeweils erste Hälfte der Paare wieder zu einem String zusammen. Spätestens dabei muss man aber prüfen, ob es Doppelungen gibt, etwa indem man guckt, ob das nächste Paar die gleiche Nummer wie der Vorgänger hat.

Das sind jetzt relative viele unnötige Stringoperationen, weil man bei den Paaren viele neue Strings erzeugt und durch die Gegend verschiebt. Wenn man dies optimieren möchte, kann man statt der Strings den Index der Subgruppe speichern (Also zum Beispiel statt {("[MOD]", 3), ("[Weiss]", 4), ("[UKE]", 1)} merkt man sich {(1, 3), (0, 4), (2, 1)}. Das ist dann eine Abstraktionsschicht mehr, dafür ist es effizienter. Musst du wissen, ob du dir das zutraust. Die naive Methode ist einfacher zu verstehen und einfacher bei eventueller Fehlersuche.

Oder es gibt auch die vollständig andere Methode, dass man sich gar nix zwischenspeichert. Man weiß schließlich, in welcher Reihenfolge die Subgruppen später stehen müssen. Also könnte man einfach gucken, ob ein String aus Subgruppe 1 vorkommt, wenn ja, dann kommt er direkt ganz nach vorne. Falls Nein, dann tut man halt nix. Und falls mehrere vorkommen, dann direkt Fehler. Und dann fährt man immer so fort mit Subgruppe 2 und so weiter. Das ist denkbar simpel und direkt. Aber das fliegt einem um die Ohren, wenn es Doppeldeutigkeiten oder unbekannte Bestandteile gibt. Daher müssen diese ausgeschlossen sein, sonst ist diese Methode nix.

Meine erste Methode ist robust, aber eventuell überkompliziert. Die simple Methode ist zum Angeben, wie gut man darin ist, die einfachste Abstraktion zu finden. Aber wenn dann eine leichte Änderung der Anforderung kommt, steht man dumm da. Im echten Leben würde ich die robuste Methode wählen, die simple Methode ist eher für den Informatikunterricht (Aber ich nehme an, das hier ist aus dem Informatikunterricht?).