Problem bei Logik für Algorithmus...

K

kwmaster

Mitglied
Hallo,

ich habe eine Excel-Tabelle mit folgendem Aufbau:

ProcessName Schritt Variante
X 10
X 20 A
X 20 B
X 30 A
X 30 B
X 40
Y 10 .......

Nun möchte ich in einem neuen Excelblatt alle Möglichkeiten als Processe auflisten:

X 10
X 20 A
X 30 A
X 40
X 10
X 20 A
X 30 B
X 40
X 10
X 20 B
X 30 A
X 40
X 10
X 20 B
X 30 B
X 40
Y 10 .......

Ich habe nur keine Idee, wie die Schleifen, Rekursionen etc. hierfür aussehen müssen...
Obiges ist auch nur ein Beispiel, also es kann durchaus noch komplexer werden mit mehreren Varianten und weiteren Prozessschritten.

Gruß

Kai
 
Kannst du mal etwas genauer (oder besser: überhaupt) sagen, wie du von der ersten Liste zur zweiten kommst? Evtl. kann ich dir dann helfen.
Dir mag der Ausdruck "alle Möglichkeiten als Processe" etwas sagen, mir allerdings nicht.
 
In der Hilfe von Excel findest du auch vieles.

Du musst das entweder mit einem Makro machen oder mit oder VBA.

Bin mir aber nicht sicher, müsste aber eigentlich so gehen:

ActiveCell.SetRange("A1")
ActiveCell.Offset(x,y)
ActiveCell.Formula

Der erfahrene bin ich auch nicht in den Dingen :D

Aber die Hilfe von Excel sollte dir schon helfen.

MfG
KD3
 
Danke erstmal für die schnelle Antwort:

Also ich habe eine Excel-Datei mit 3 Spalten:

1. Spalte: Prozessname
2. Spalte: Prozessschritt
3. Spalte: Variante

Beispiel:
Prozess Einkaufen

Prozessname-Prozessschritt-Variante
Einkaufen-Aus dem Haus gehen-EMPTY
Einkaufen-Zum Edeka bewegen-Zu Fuß gehen
Einkaufen-Zum Edeka bewegen-mit Fahrrad fahren
Einkaufen-Zum Edeka bewegen-mit Auto fahren
Einkaufen-Edeka betreten-EMPTY
Einkaufen-Sachen in Wagen legen-EMPTY
Einkaufen-Bezahlen-Bar
Einkaufen-Bezhalen-mit EC Karte

So und nun will ich dies so aufdröseln, dass ich alle Prozesse in allen Variationen habe:
Prozessname-Prozessschritt-Variante
Einkaufen-Aus dem Haus gehen-EMPTY
Einkaufen-Zum Edeka bewegen-Zu Fuß gehen
Einkaufen-Edeka betreten-EMPTY
Einkaufen-Sachen in Wagen legen-EMPTY
Einkaufen-Bezahlen-Bar

Einkaufen-Aus dem Haus gehen-EMPTY
Einkaufen-Zum Edeka bewegen-Zu Fuß gehen
Einkaufen-Edeka betreten-EMPTY
Einkaufen-Sachen in Wagen legen-EMPTY
Einkaufen-Bezhalen-mit EC Karte

Einkaufen-Aus dem Haus gehen-EMPTY
Einkaufen-Zum Edeka bewegen-mit Fahrrad fahren
Einkaufen-Edeka betreten-EMPTY
Einkaufen-Sachen in Wagen legen-EMPTY
Einkaufen-Bezahlen-Bar

Einkaufen-Aus dem Haus gehen-EMPTY
Einkaufen-Zum Edeka bewegen-mit Fahrrad fahren
Einkaufen-Edeka betreten-EMPTY
Einkaufen-Sachen in Wagen legen-EMPTY
Einkaufen-Bezhalen-mit EC Karte

...

Ich hoffe, dass es damit etwas verständlicher geworden ist ;-)
 
Hallo KD3,

ich denke mal, dass das Coding kein Problem ist, ich brauche nur einen Algorithmus hierfür in Pseudocode á la:

Lese Prozessname
Lese Prozessschritt
Lese Variante
Wiederhole...

sowas in der Art, da ich icht weiß, wie ich es von der Logik her programmieren soll...

Schomal Danke im Voraus
 
Hmmm... ich grübel mal bei einer Zigarette drüber, ich bilde mir nämlich fast ein, daß sich da mit Baumalgorithmen einiges erreichen lässt.

@diejenigen, die (im Gegensatz zu mir) ihr Studium durchgehalten haben:
Zückt mal bitte die Sedgewicks und gebt Bescheid, ob ich da nur halluziniere oder ob es da wirklich was gibt. :)
 
Grüß dich.

Hier ist mein Vorschlag. Dafür musst du allerdings vorher wissen, wie viele Prozesschritte es mit Varianten gibt und wie viele Varianten sie haben, wenn sich dass aber nicht dauernd ändert sollte es so passen.

Also im Beispiel hat Prozessschritt "bewegen" 3 Varianten,
Prozesschritt "kaufen" 2 Varianten und Prozessschritt "gehen" wieder 3 Varianten.

D.h es gibt insgesamt 3*2*3 = 18 mögliche Kombinationen.
Wenn man sie alle hintereinander auflistet wechseln die Varianten von Prozessschritt "bewegen" jedesmal durch. Von Prozessschritt "kaufeb" nur alle 3 mal und von Prozessschritt "gehen" alle 3*2 = 6 mal.

Also so:
bewegen fuß kaufen bar
bewegen auto kaufen bar
bewegen fahhrad kaufen bar
bewegen fuß kaufen EC
....

Ich schreib es mal in Code:
PHP: 
for ( int i = 0; i < 3* 2* 3; i++)
{
   Prozess1.Variante[i%3];
   Prozess2.Variante[floor(i/3)%2];
   Prozess3.Variante[floor(i/3*2)%3];
}

Das liefert bei uns folgendes Ergebnis:
Zählervariable prozess1 prozess 2 prozess 3
0 0 0 0
1 1 0 0
2 2 0 0
3 0 1 0
4 1 1 0
5 2 1 0
6 0 0 1
7 1 0 1
8 2 0 1
9 0 1 1
...

Wie du siehst verwende ich hier den MOD-Operator und die Abrundefunktion. Je nachdem, in welchem Code du schreibst, sollte es das bei dir auch geben.

Vorgehen: Immer bei dem Prozess die Zählvariable modulo die Anzahl der Varianten. Bei den nächsten Prozessen immer abrunden die Division von Zählervariable mit allen Modulovarianten vorher.

Ich hoffe, dass war einigermaßen verständlich, ansonsten versuch ichs gerne nochmal zu erklären.

mfg
 
(nach der Kippe)

Ok, also ich persönlich glaube auch, daß es für eine echte Implementierung darauf ankäme, zu welchem Zweck du diese Alternativenmatrix brauchst. Allgemein brösel ich so etwas jedoch gerne von hinten nach vorne auf:

1. Alternative 1 -> 2. Alternative 1-> 3. Alternative 1 -> 4. Alternative 1
1. Alternative 1 -> 2. Alternative 1-> 3. Alternative 1 -> 4. Alternative 2
1. Alternative 1 -> 2. Alternative 1-> 3. Alternative 1 -> 4. Alternative 3
1. Alternative 1 -> 2. Alternative 1-> 3. Alternative 1 -> 4. Alternative 4

1. Alternative 1 -> 2. Alternative 1-> 3. Alternative 2 -> 4. Alternative 1
1. Alternative 1 -> 2. Alternative 1-> 3. Alternative 2 -> 4. Alternative 2
1. Alternative 1 -> 2. Alternative 1-> 3. Alternative 2 -> 4. Alternative 3
1. Alternative 1 -> 2. Alternative 1-> 3. Alternative 2 -> 4. Alternative 4

1. Alternative 1 -> 2. Alternative 1-> 3. Alternative 3 -> 4. Alternative 1
1. Alternative 1 -> 2. Alternative 1-> 3. Alternative 3 -> 4. Alternative 2
1. Alternative 1 -> 2. Alternative 1-> 3. Alternative 3 -> 4. Alternative 3
1. Alternative 1 -> 2. Alternative 1-> 3. Alternative 3 -> 4. Alternative 4

etc.pp.

Ich tue mich mit dieser Art deswegen leichter als mit der von DonDozone, da es dem normalen mathematischen Stellenwertsystem entspricht, mit dem ich vertraut bin und somit die Gefahr, daß ich eine Alternative vergesse, deutlich geringer ist.
 
Hi DonDozone,

und genau das ist mein Problem.
Ich weiß weder welcher schritt Varianten hat und wieviele.

Es kann also sein, dass Prozess X 10 Schritte hat, wobei Schritt 2 fünf Varianten und Schritt 7 drei Varinaten aufweist und es kann sein, dass Prozess Y nur 5 Schritte hat und überhaupt keine Varianten...

@CSANecromancer

Die Baumidee klingt interessant, aber ich kann mir darunter nichts vorstellen... kenne das nur vom Sortieren her...
 
Mit einem Baum wäre das möglich, da aber einige Schritte statisch sind und die Knoten mehrere Eltern haben könnten (und es damit eher ein Netz als ein Baum ist) würde ich eher zu einem angepassten Backtracingverfahren raten, dass allein über die variablen Zustände läuft.

In einer Liste von Listen hast Du also:
Code: 
Liste1: A   
Liste2: B1 B2
Liste3: C  
Liste4: D1  D2  D3
Liste5: E1  E2

Dann iterierst Du über jedes Element von Schritt x (nur!) die folgenden Listen x-1 rekursiv, solange x nicht 0 (oder NULL oder NIL) ist.

Dann hast Du die Menge M der Permutationen, mit M={(A,B1,C,D1,E1), (A,B1,C,D1,E2), (A,B1,C,D2,E1),...,(A, B2,C,D3,E2)}
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück