Schleifen wiederholen

[himitsu]

Zitat von Kegasetu:

Das ist aus älteren Beiträgen zu entnehmen. Die Bezeichnung hilft mir bei meinen Formeln nicht durcheinander zu kommen.

Und was ist dann der Unterschied zwischen l14, l[14], myvars[l14] und myvars['l14'] ?

OK, Letzteres ist unünstiger, da der Compiler hier nicht schon alles prüfen kann und ein ungültiger Bezeichner erst zur Laufzeit knallen "kann"
und natürlich auch die Codevervollständigung hier nicht hilft.

[delphifan2004]

Zitat von Kegasetu:

Hallo Zusammen.
Ich stoße mittlerweile ein Bisschen an meine Grenzen. Das Problem, ich will über einen Integer einen Wert eingeben, über welchen bestimmt wird, wie oft eine Schleife durchlaufen wird. Diese Schleifen können als Exponenten angesehen werden.

Hier ein kleines Beispiel zu der manuellen Lösung des Problems:

Delphi-Quellcode:

for z1 := 1 to 10 do
  begin
    l12 := l11 +0.1;
    l11 := l11 + 0.1;              
      for z2 := 1 to 10 do
      begin
        l13 := l12 + 0.1;
        l12 := l12 + 0.1;
          for z3 := 1 to 10 do
          begin
          l14 := l13 + 0.1;
          l13 := l13 + 0.1;
            for z4 := 1 to 10 do
            begin
              l15:= l14 + 0.1;
              l14:= l14 + 0.1;
                for z5 := 1 to 10 do
                   ..

Das ist so natürlich überaus unpraktisch. Ich kam nun auf die Idee eine Funktion entsprechend zu erstellen, jedoch bin ich auch nach längerem Überlegen nicht auf eine Lösung gekommen...

Noch ein Hinweis, es werden maximal 20 Loops durchlaufen.

Hat jemand vielleicht eine Idee?

Rekursion?

[Kegasetu]

Also ich bin mir nicht mehr ganz sicher, wie ich weiterkommen soll. Ich will mein Problem mal so beschreiben.

Der Sachverhalt lautete wie folgt: Es gibt n Elemente, die auf k Stellen platziert werden können. Bedingung ist, dass sich alles der Reihe nach bewegen muss, also Elemente 1 wird niemals vor Element 2 sein. Hier ein Beispiel mit 5 Elementen und 7 Stellen.

*****---

****-*--

****--*-

****---*

***-**--

***-*-*-

***-*--*

**-***--

**-**-*-

**-**--*

*-****--

*-***-*-

*-***--*

-*****--

-****-*-

-****--*

-***-**-

-***-*-*

-**-***-

-**-**-*

-*-****-

-*-***-*
usw.

Von mir aus, packe ich die Längen auch alle in Arrays rein, aber bezüglich der Kombination bin ich mir unsicher.

Um das mal Verbal zu beschreiben: Am Anfang sind alle Halterungen im Abstand von 0,1 m voneinander entfernt. Dann geht die letzte Halterung bis ganz nach außen. Ist sie dort angekommen, dann rück die Vorletzte nach und die letzte Halterung ist wieder 0,1 m von der Vorletzten entfernt und bewegt sich nun nochmal bis ganz nach außen. Dann rückt die Vorvorletzte nach...
Leider bekomme ich es nicht hin, dieses logisch Problem zu verpacken...

[angos]

Zitat von Kegasetu:

Also ich bin mir nicht mehr ganz sicher, wie ich weiterkommen soll. Ich will mein Problem mal so beschreiben.

Der Sachverhalt lautete wie folgt: Es gibt n Elemente, die auf k Stellen platziert werden können. Bedingung ist, dass sich alles der Reihe nach bewegen muss, also Elemente 1 wird niemals vor Element 2 sein. Hier ein Beispiel mit 5 Elementen und 7 Stellen.

*****---

****-*--

****--*-

****---*

[...]

Hi,

ich interpretiere mal, dass das mehrere Beispiele waren und in meinem Quote das erste Beispiel zu sehen ist. Dann ist das m.E. ein einfacheres Problem und auch ich würde hier einen (dynamischen) array vorschlagen.

Länge des arrays ist dann die Anzahl der Stellplätze.
Jeder einzelne Wert ist dann das "Objekt" (oder was auch immer da liegt)

Auf das Beispiel von dir bezogen:

Delphi-Quellcode:

SetLength(myArray, 8);
myArray[0] := 1;
myArray[1] := 2;
myArray[2] := 3;
myArray[3] := 4;
myArray[4] := 5;
myArray[5] := 0;
myArray[6] := 0;
myArray[7] := 0;

Dann hättest du die Vorgabe dafür und musst nur noch eine Routine schreiben, welche die Items (Bei mir die Integer 1-5) beginnend mit dem letztmöglichen verschiebt.

Zumindest, wenn ich deine Aufgabe verstanden habe

[Kegasetu]

Zitat von angos:

Zitat von Kegasetu:

Also ich bin mir nicht mehr ganz sicher, wie ich weiterkommen soll. Ich will mein Problem mal so beschreiben.

Der Sachverhalt lautete wie folgt: Es gibt n Elemente, die auf k Stellen platziert werden können. Bedingung ist, dass sich alles der Reihe nach bewegen muss, also Elemente 1 wird niemals vor Element 2 sein. Hier ein Beispiel mit 5 Elementen und 7 Stellen.

*****---

****-*--

****--*-

****---*

[...]

Hi,

ich interpretiere mal, dass das mehrere Beispiele waren und in meinem Quote das erste Beispiel zu sehen ist. Dann ist das m.E. ein einfacheres Problem und auch ich würde hier einen (dynamischen) array vorschlagen.

Länge des arrays ist dann die Anzahl der Stellplätze.
Jeder einzelne Wert ist dann das "Objekt" (oder was auch immer da liegt)

Auf das Beispiel von dir bezogen:

Delphi-Quellcode:

SetLength(myArray, 8);
myArray[0] := 1;
myArray[1] := 2;
myArray[2] := 3;
myArray[3] := 4;
myArray[4] := 5;
myArray[5] := 0;
myArray[6] := 0;
myArray[7] := 0;

Dann hättest du die Vorgabe dafür und musst nur noch eine Routine schreiben, welche die Items (Bei mir die Integer 1-5) beginnend mit dem letztmöglichen verschiebt.

Zumindest, wenn ich deine Aufgabe verstanden habe

Ich musste gerade feststellen, dass mein Ansatz nicht richtig ist. Ich kann bestimmte Kombinationen so nicht erreichen.

[Incocnito]

Hi du,

ich würde im ersten Schritt nur die Positionen beachten und die Längen außen vor lassen.
Ich würde die Elemente auch nicht positionieren, sondern nur Elemente verteilen und am
Ende sagen "das Element ganz links ist Element 1, das daneben 2, ...", damit du
die Problematik erstmal aus dem Kopf bekommst.

Es bietet sich halt ein Array an mit der angegebenen Länge.
Dann halt eine Funktion, welche ein Element platziert.
Zunächst muss das erste Element im Bereich 0 bis L-N platziert werden.
Nur L-N, da du ja wenigstens Platz für die verbleibenden Elemente benötigst.
Danach wechselnd die verbleibenden Elemente aufteilen.
Unterm Strich also eine Liste mit allen Möchlichkeiten und dort dann je eine Liste mit den verwendeten Elementen.
"Array of Array of Boolean" vielleicht!? Funktion könnte für jeden Durchgang die Liste selbst erweitern,
oder du errechnest zuerst die Anzahl der Möglichkeiten und setzt die Listenlänge zuerst.
Letztes müsstest du machen, falls du zu viele Variationen hast und du sonst zu oft
die Listenlänge neu setzen würdest ... das müsste dann aber schon echt oft sein ... merkst du,
wenn dein Programm zu lange braucht ... Arraylängen neu setzen (=Arrays umkopieren) dauert auf
dem PC noch mit am Längsten.

Im Gegensatz zu meinem Vorgänger wäre das die "einfachere" Brute-Force-Methode.

Nur so als Denkanstoß. Ich hoffe das hilft bei der Lösungsfindung.

MfG
Incocnito

[Monday]

Zitat von Kegasetu:

Also ich bin mir nicht mehr ganz sicher, wie ich weiterkommen soll. Ich will mein Problem mal so beschreiben.

Der Sachverhalt lautete wie folgt: Es gibt n Elemente, die auf k Stellen platziert werden können. Bedingung ist, dass sich alles der Reihe nach bewegen muss, also Elemente 1 wird niemals vor Element 2 sein. Hier ein Beispiel mit 5 Elementen und 7 Stellen.

*****---

****-*--

****--*-

****---*

***-**--

***-*-*-

***-*--*

**-***--

**-**-*-

**-**--*

*-****--

*-***-*-

*-***--*

-*****--

-****-*-

-****--*

-***-**-

-***-*-*

-**-***-

-**-**-*

-*-****-

-*-***-*
usw.

Von mir aus, packe ich die Längen auch alle in Arrays rein, aber bezüglich der Kombination bin ich mir unsicher.

Um das mal Verbal zu beschreiben: Am Anfang sind alle Halterungen im Abstand von 0,1 m voneinander entfernt. Dann geht die letzte Halterung bis ganz nach außen. Ist sie dort angekommen, dann rück die Vorletzte nach und die letzte Halterung ist wieder 0,1 m von der Vorletzten entfernt und bewegt sich nun nochmal bis ganz nach außen. Dann rückt die Vorvorletzte nach...
Leider bekomme ich es nicht hin, dieses logisch Problem zu verpacken...

Wenn es so wie bei den Beispielen aussehen soll, könnte ich mir vorstellen dass man Binärzahlen hochzählt. Dann hätte man auch alle Positionen und würde sich so verhalten von rechts nach links. Weiß nicht ob das weiterhilft.

[jfheins]

In jedem Fall solltest du die Variation der Zustände von der Berechnung trennen.

Falls die Variationen tatsächlich so diskret sind, sind das ja Kombinationen. Dafür gibt es auch für Delphi einige Beispiele: https://www.delphipraxis.net/194333-...inationen.html

Dein erstes Problem wäre dann:
=> Wie viele Möglichkeiten gibt es, 5 Stützstellen auf 7 Positionen zu verteilen

Das zweite Problem:
=> Gegeben eine Anordnung von Stützstellen, berechne die Lasten

Software Entwicklung ist die systematische Zerlegung von Problemen in kleinere Teile, solange bis man sie lösen kann