Schleifen wiederholen

[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 :wink:

[Kegasetu]

Zitat:

Zitat von bcvs (Beitrag 1476132)

Zitat:

Zitat von Kegasetu (Beitrag 1476009)

Das Problem, ein Balken mit mehr als zwei Halterungen gilt als unbestimmt. Nun gibt es Verfahren, um das zu lösen, aber meine Aufgabe lautet, alle Halterungen sollen in etwas gleich beansprucht werden. Um dies zu erreichen, will ich iterativ die Halterungen ein wenig verschieben und dann so lange rechnen, bis die Halterungen annähernd gleich viel Gewicht aufnehmen.

Interessantes Problem.
Da ich vom Fach bin, habe ich mir dazu mal ein paar Gedanken gemacht.

Wie wäre es mit einem anderen Lösungsansatz:
Du verteilst die Auflager zunächst gleichmäßig unter dem Balken. Damit hast du schon man eine Ausgangslage an Unterschieden in den Auflagerkräften. Dann verschiebst du die Auflager nur noch iterativ, bis alle in etwa die gleiche Auflagerkraft bekommen. Das Auflager mit der geringeren Auflagerkraft rückt näher an das benachbarte Auflager ran. Dann schaust du dir das nächste Feld an und so weiter.

Ist die Belastung eigentlich gleichmäßig verteilt? Dann kannst du die Verschiebungen ja gleich symetrisch durchführen.

Ich bin mir nicht sicher, ob das in allen Fällen funktioniert, insbesondere bei nicht gleichmäßg verteilter Belastung. Aber vielleicht ist das ein Denkanstoß.

Das mit dem gleichmäßgen Verteilen und dann iterativ rechnen ist mir auch schon in den Sinn gekommen, so ein Verfahren wird beim WMF-Balken angewandt. Ich selber habe mir diese Methode vorbehalten, sollte die Eigentliche nicht funktionieren.

Die Belastung ist nicht gleichmäßig verteilt. Die Berechnung soll nach diesem Prinzip(http://www.kulle.at/Statik/Unterlage...k/Statik64.pdf) erfolgen.

[Kegasetu]

Zitat:

Zitat von angos (Beitrag 1476131)

Zitat:

Zitat von Kegasetu (Beitrag 1476123)

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.

[bcvs]

Zitat:

Zitat von Kegasetu (Beitrag 1476153)

Die Belastung ist nicht gleichmäßig verteilt. Die Berechnung soll nach diesem Prinzip(http://www.kulle.at/Statik/Unterlage...k/Statik64.pdf) erfolgen.

Ah, der gute, alte Clapeyron

Zitat:

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

Genau. Und du rechnest ziemlich viele unsinnige Auflagerstellung durch, wie z.B. alle Lager nebeneinander am linken Rand.

[Kegasetu]

Zitat:

Zitat von bcvs (Beitrag 1476159)

Zitat:

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

Genau. Und du rechnest ziemlich viele unsinnige Auflagerstellung durch, wie z.B. alle Lager nebeneinander am linken Rand.

Das ist schon klar, aber wenn der Computer das alles macht und es nur unwesentlich länger dauert ist es mir egal.

[Michael II]

Hallo, ich habe die Bewertungsfunktion nicht angeschaut.

Wenn du zum Beispiel zehn feste Punkte hast, an vier Punkten was reinhängen willst und aufgrund der fest vorgegebenen Punkte lediglich an allen (10 tief 4) möglichen Kombinationen sowie an einer besten Lösung interessiert bist, dann könntest du es so tun.

Delphi-Quellcode:

type TBewertungstyp = integer;
     TBrett  = record
          wo : array[0..9] of byte; // hier speichern wir, wo wir was tun: 0=nix tun, 1=was tun
          anz, pos : integer; // In function bewerte gehen wir brett zum beispiel von links=0 nach rechts=9 durch. pos: da befinden wir uns gerade. anz: so oft haben wir was getan (d.h. wo[i]=1 gesetzt)
     end;

     TRes = record
      br : TBrett;
      bew : TBewertungstyp;
     end;


function meingebewertungsfunktion( brett : TBrett) : TRes;
var hres : TBewertungstyp;
begin
  Result.br := brett;
  Result.bew := ...; // hier musst du deine Bewertung abhängig von brett.wo einsetzen
end;


// hier werden alle (n tief k) Kombinationen aufgezählt und bewertet:

function bewerte( brett : TBrett ; n, k : integer ) : TRes;
var b0, b1 : TRes;
begin
  inc(brett.pos);

  if ( k-brett.anz > n-brett.pos ) then Result.bew := 0 // Abbruch, da wir noch k-brett.anz Mal was tun müssten, aber nur noch n-brett.pos Postionen frei sind
  else
  if brett.anz = k then // k Postionen sind besetzt => auswerten:
  Result := meingebewertungsfunktion( brett ) // hier werden alle (n tief k) Kombinationen ausgewertet
  else
  begin
      // Fall 1 - an brett.pos nix tun:
      b0 := bewerte( brett, n, k );

      // Fall 2 - an brett.pos was tun:
      brett.wo[brett.pos] := 1;
      inc(brett.anz); 
      b1 := bewerte( brett, n, k );

      // hier wählst du die bessere variante aus
      if b0.bew > b1.bew then Result := b0 else Result := b1;
  end;
end;

Aufruf:

Delphi-Quellcode:

function loesung_str( loesung : TRes ):string;
var hs : string;
begin
  hs := loesung.bew.ToString + ' : ';
  for var i := 0 to length( loesung.br.wo )-1 do
    hs := hs + loesung.br.wo[i].ToString;

  Result := hs;
end;

function loesung( n, k : integer ) : TRes;
var meinbrett : TBrett;
begin
  // Brett "initialisieren":
  fillchar(meinbrett.wo[0], n, 0 );
  meinbrett.pos := -1;
  meinbrett.anz := 0;
  // beste Kombination suchen: 
  Result := bewerte( meinbrett, n, k );
end;


procedure TForm29.Button1Click(Sender: TObject);
var best : TRes;
begin
  best := loesung( 10, 4 );
  showmessage( loesung_str( best ) );
end;

[Moombas]

Zumal du differenzieren solltest: Gleichmäßige Belastung der Lager oder des Balken? Bzw. minimalste Belastung der einzelnen Komponenten.

Beispiel Annahme: Der Balken wird von oben gleichmäßig belastet.
_****_ > Lager sind gleich stark belastet, der Balken jedoch hat in der Mitte die stärkste Belastung
**__** > Lager sind gleich stark belastet, der Balken jedoch hat außen die stärkste Belastung
*_**_* > Der Balken hat eine Gleichmäßige Belastung und die Lager auch.