Zufallszahlen, wer kann helfen?

[kunta]

In einem Experiment sollen die Zahlen von 1-16 (in genau dieser Reihenfolge) mittels eines Zufallgenerators erzeugt werden.
Es gibt insgesamt 16 Durchläufe. Im i-ten Durchlauf wird so lange eine Zufallszahl erzeugt, bis man die Zahl i erhält. Ein solcher Durchlaufwird per ButtonClick auf "Zufall berechnen"gestartet. Die dazu notwendige Anzahl der Versuche soll in ein Stringgrid der Größe 4x4 eingetragen werden. In einem zweiten Stringgrid (ebenfalls Größe 4x4) wird die Zahl i dargestellt.
Benutzt werden soll: randomize, random

Ich habe es selbst versucht aber da ich erst ein paar Tage damit zu tun habe komme ich nicht weiter. Wer kann mir helfen?

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
 var      Versuche,Zufall :integer;

Begin
Versuche:=0;
  repeat

    inc(Versuche);
    Zufall := random(16) + 1;   // mindestens die Zahlen von 1-20, oder was meint Ihrt? Wie stellt man  bis "unendlich" ein?
  until Zufall = 1;
  Stringgrid2.Cells[0,0]:=inttostr(Versuche);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  randomize;
  Zufall:=random(16) + 1;
  Versuche := 0;
end;

procedure TForm1.StringGrid1Click(Sender: TObject);
begin
  Stringgrid1.Cells[0,0]:='1';
  Stringgrid1.Cells[1,0]:='2';
  Stringgrid1.Cells[2,0]:='3';
  Stringgrid1.Cells[3,0]:='4';
  Stringgrid1.Cells[0,1]:='5';
  Stringgrid1.Cells[1,1]:='6';
  Stringgrid1.Cells[2,1]:='7';
  Stringgrid1.Cells[3,1]:='8';
  Stringgrid1.Cells[0,2]:='9';
  Stringgrid1.Cells[1,2]:='10';
  Stringgrid1.Cells[2,2]:='11';
  Stringgrid1.Cells[3,2]:='12';
  Stringgrid1.Cells[0,3]:='13';
  Stringgrid1.Cells[1,3]:='14';
  Stringgrid1.Cells[2,3]:='15';
  Stringgrid1.Cells[3,3]:='16';
end;

end.

[edit=alzaimar] Delphi-Tags eingefügt, Code ausgerichtet. Mfg, alzaimar[/edit]

[alzaimar]

Der Code, um die Anzahl der Versuche für die Zahl '1' ist doch schon recht brauchbar. Es fehlt nur vor der Schleife die Vorbelegung der Variablen 'Versuche' mit einem sinnvollen Anfangswert.

Du hast auch ganz richtig erkannt, das die Vorschrift "Berechnung einer Zufallszahl" auch einen Bereich beinhalten soll ("Berechnung einer Zufallszahl im Bereich 1..20"). Denn so müsste man wirklich davon ausgehen, das der Lehrer(?) irgendeine Zufallszahl will. Und dann kann man sich einen Wolf zählen, bis die richtige Zahl kommt. Ich denke, er meint Zufallszahlen im Bereich 1..16 .

Überlege Dir dann, was Du hast: Du kannst die Anzahl der Versuche zählen, die man benötigt. bis eine Zufallszahl im Bereich 1-16 genau 1 ergibt.
Das könnte man verwenden, um die Anzahl der Versuche zählen, die man benötigt. bis eine Zufallszahl im Bereich 1-16 genau I ergibt, wobei I zwischen 1 und 16 ist.

[kunta]

Hallo,
vielen Dank für die Antwort.
Ich habe nun
Vesuche:=0;
vor die Schleife gesetzt.
Vorher hatte ich den Eindruck, dass alle Versuche zusammen addiert wurden. Jetzt kommt jedesmal eine neue Zahl zwischen 1 und 16.
Und nun?
Ich denke, dass ich alles für die "1" habe und muss zu der 2. Ziffer (Stringgrid1.Cell[1,0]) der 2 kommen.
Nur wie? Und wie kann ich die Schleife verwenden?

[TOC]

Hi!

Wie wäre es zum Beispiel mit so einer Funktion hier:

Delphi-Quellcode:

{

  Number    = Gesuchte Zahl
  RangeFrom = Untere Bereichsgrenze (einschließlich)
  RangeTo   = Obere Bereichsgrenze  (einschließlich)

  Ergebnis:
  Result = Anzahl der Versuche die Benötigt wurden
           oder
           -1 falls die angegebene gesuchte Zahl außerhalb des Bereiches liegt
}
Function GetRandomNumber(Number, RangeFrom, RangeTo: Integer): Integer;
Var
  RandNum, Range: Integer;
Begin
  // Vergleichen ob gesuchte Zahl innerhalb des Bereiches liegt,
  // um Endlosschleife zu vermeiden
  If (Number<RangeFrom) or (Number>RangeTo)
  Then Result:=-1
  Else Begin
    // Ergebnis erstmal auf 0 setzen
    Result:=0;
    // Bereich voausberechnen for Random
    Range:=RangeTo-RangeFrom+1;
    // Wiederhole...
    Repeat
      // Erzeuge eine Zufallszahl innerhalb von RangeFrom, RangeTo (einschließlich)
      RandNum:=Random(Range)+RangeFrom;
      // Anzahl versuche Erhöhen
      Inc(Result);
    // ...solange bis gesuchte Zufallszahl erzeugt wurde
    Until RandNum=Number;
  End;
End;

Also,dieser Funktion muss Du als Eingabeparameter "Number" geben, das ist dann die gesuchte Zahl, und den Bereich. In Deinem Beispiel also 1 für RangeFrom und 16 for RangeTo. Die Funktion erzeugt dann innerhalb einer Schleife solange eine Zufallszahl innerhalb des Bereiches bis der Wert von "Number" gefunden wurde. Und als Ergebnis hast Du dann die Anzahl der Versuche.

Aufrufen kannst Du diese Funktion dann so zum Beispiel:

Delphi-Quellcode:

StringGrid2.Cells[0,0]:=IntToStr(GetRandomNumber(1, 1, 16));

Und dann würde ich Dir eine Schleife empfehlen für die erste 1, also "Number", und in dieser Schleife von 1 bis 16 laufen.

Grüße von TOC!

[DP-Maintenance]

Dieses Thema wurde von "Matze" von "Programmieren allgemein" nach "Sonstige Fragen zu Delphi" verschoben.
Delphi-Frage

[kunta]

Leider klappt es noch nicht.
Wie kann ich denn ein Programm schreiben, sodass für alle 16 Zahlen in der Reihenfolge die Zufallszahl gesucht wird und dann noch im Stringgrid2 ausgegeben wird?
Wie kann man es so einstellen, dass im Stringgrid1 - Feld die Zahlen 1-16 erst dann gezeigt werden wenn man sie anklickt. Also einzeln nacheinander.

[TOC]

Hi!

Zitat:

Zitat von kunta

Leider klappt es noch nicht.

Das Leben ist ja auch noch nit zuende und der Tag noch lang!

Zitat:

Zitat von kunta

Delphi-Quellcode:

  Zufall := random(16) + 1;   // mindestens die Zahlen von 1-20, oder was meint Ihrt? Wie stellt man  bis "unendlich" ein?

Du KANNST gar keine unendliche Zuffalszahl mit Random(N) erzeugen, weil "Random(N: Integer)" immer eine ENDLICH große Integer-Zahl erzeugt. Eine Integer Zahl ist (Bei Delphi3) immer:

Zitat:

Zitat von Die Delphi-Hilfe

Beschreibung:
Random gibt eine Zufallszahl im Bereich 0 <= X < Range zurück.

Delphi-Quellcode:

  Typ       Wertebereich              Format
Integer   -2147483648..2147483647   32 Bit einschließlich Vorzeichen

Also, ne größere Zufallszahl als 2147483646 wirst Du von Random(N) (D3) nie geliefert bekommen können!
Und selbst wenn der Integer-Bereich bei moderneren Delphis vielleicht größer sein mag: ENDLICH ist eine Integer-Zahl (die im Grunde nur aus einer bestimmten Anzahl von Bytes besteht) eigentlich IMMER.

Zitat:

Zitat von kunta

Wie kann ich denn ein Programm schreiben, sodass für alle 16 Zahlen in der Reihenfolge die Zufallszahl gesucht wird und dann noch im Stringgrid2 ausgegeben wird?

Wie kann man es so einstellen, dass im Stringgrid1 - Feld die Zahlen 1-16 erst dann gezeigt werden wenn man sie anklickt. Also einzeln nacheinander.

Also, mir ist Deine Frage leider noch nicht so ganz klar.

Möchtest Du das in StringGrid1 und StringGrid2 nur leere Felder sind, und dann klickst Du zum Beispiel auf Cell[0, 0] von StringGrid1, er schreibt dann ne 1 da rein und die Anzahl der Versuche die er zum "würfeln" gebraucht hat in StringGrid2?

Oder:

Möchtest Du einen einzigen Button auf denn du klickst, und er berechnet dann in der Reihenfolge zuerst die 1 von Cell[0,0], beim zweiten klick die 2 von Cell[1, 0] usw bis 16 und beide StringGrids sind dann nach 16 Clicks voll?

Also, erkläre uns bitte etwas genauer wie das Programm funktionieren soll. Es macht nämlich vom Programm her einen ziemlich großen Unterschied welche Art von Klick (Ob StringGrid.Click oder Button.Click) Du verwenden willst. Tatsächlich kann man in einem StringGrid ebenfalls einen einfachen Click programmieren, so wie bei einem Button, man kann aber auch auf einen Click reagieren und abfragen WELCHE Zelle angeklickt wurde (was etwas mehr Aufwand ist).

Grüße von TOC!

[TOC]

Hi!

Du könntest folgendes mal versuchen:

Delphi-Quellcode:

{
  Diese Methode wird aufgerufen wenn eine Zelle in StringGrid1 angecklickt wird.
}
procedure TForm1.StringGrid1SelectCell(Sender: TObject; Col, Row: Integer;
  var CanSelect: Boolean);
Var
  Number: Integer;
begin
  // Berechne aus Col (Spalte) und Row (Zeile) die gesuchte Zahl
  Number:=Row*4+Col+1;
  // Wandle diese Zahl in einen String und schreibe sie in Stringrid1
  StringGrid1.Cells[Col, Row]:=IntToStr(Number);
  // Würfel nun Zufallszahlen bis die Zahl gefunden wurde
  // und schreibe die Anzahl der Versuche in StringGrid 2
  StringGrid2.Cells[Col, Row]:=IntToStr(GetRandomNumber(Number, 1, 16));
end;

Vergesse aber bitte nicht, zum Beispiel in OnFormCreate, den Randomize-Befehl aufzurufen.

Grüße von TOC!

[kunta]

"Möchtest Du einen einzigen Button auf den du klickst, und er berechnet dann in der Reihenfolge zuerst die 1 von Cell[0,0], beim zweiten klick die 2 von Cell[1, 0] usw bis 16 und beide StringGrids sind dann nach 16 Clicks voll?"


Genau. Diesen Fall möchte ich erreichen.

[guidok]

Du hast doch schon eine Schleife, mit der du solange Zufallszahlen ziehst, bis du die gewünschte (in deinem Fall die 1) erhältst.

Jetzt musst du nur noch diese Schleife in einer zweiten Schleife "verpacken", die alle Zahlen von 1 - 16 zieht:

Pseudocode:

Delphi-Quellcode:

for GesuchteZahl := 1 to 16 do begin
  AnzahlVersuche := 0;
  repeat
    ZahlZiehen;
    AnzahlVersuche := AnzahlVersuche + 1;
  until GezogeneZahl = GesuchteZahl;
  AnzahlVersucheInGridEintragen;
  GesuchteZahlInGridEintragen;
end;

Edit: Tschuldigung, die oben aufgezeigte Lösung füllt das Grid natürlich in einem Rutsch. Du möchtest ja Klicken. In diesem Fall benötigts du eine globale Variable GesuchteZahl, die du am Anfang auf 1 setzt (das ist ja die erste Zahl die du suchst) und mit jedem Klick auf den Button ermittelst du nun die Anzahl der Versuche, diese Zahl zu ziehen, Grid füllen, GesuchteZahl um eins erhöhen. Damit suchst du nun beim nächsten Klick nach der nächsten Zahl, solange, bis die 16 erreicht wurde.



Das Eintragen der Zahlen in das Grid, ist wieder etwas tricky (soll ja nicht so einfach sein).
Im einfachsten Fall, hätte das Grid die 16 Zellen in einer Reihe oder in einer Spalte, dann wäre die Zielspalte für den Eintrag einfach Grid.Cell[GesuchteZahl, 0].

So ist es aber leider nicht, daher musst du abhängig von der GesuchtenZahl in die richtige Zelle schreiben. Dafür gibt es mehrere Möglichkeiten, deren einfachste evtl. ein "Case GesuchteZahl of" ist.

[TOC]

Hi!

Zitat:

Zitat von TOC

"Möchtest Du einen einzigen Button auf den du klickst, und er berechnet dann in der Reihenfolge zuerst die 1 von Cell[0,0], beim zweiten klick die 2 von Cell[1, 0] usw bis 16 und beide StringGrids sind dann nach 16 Clicks voll?"

Zitat:

Zitat von kunta

Genau. Diesen Fall möchte ich erreichen.

Also gut, dann müssen wir das Programm halt nochmal etwas anpassen.
Die Funktion "GetRandomNumber" hasst Du ja weiter oben in diesem Thread, die wieder hole ich hier nicht noch mal.

Also, erstmal brauchen wir eine Variable, diese müssen wir zuerst mal auf eins setzen und dann mit jedem Klick hoch zählen.
Nur, wohin mit der Variable? Ich würde folgendes vorschlagen:

Delphi-Quellcode:

type
  TForm1 = class(TForm)
    StringGrid1: TStringGrid;
    StringGrid2: TStringGrid;
    Button1: TButton;
    Button2: TButton;
    procedure StringGrid1SelectCell(Sender: TObject; Col, Row: Integer;
      var CanSelect: Boolean);
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    // Diese Zähler-Variable ist wichtig!
    Count: Integer;
  public
  end;

So in etwa könnte das Formular in Deinem Programm aussehen, und unter "Private" habe ich die Zählvariable hinein geschrieben.
Es gibt auch andere Möglichkeiten, zum Beispiel hätte man auch eine globale Variable nehmen können, aber ich persönlich finde es so besser.

Dann ist folgendes noch wichtig: Am Programmstart müssen wir erstmal mit Randomize den Zufallszahlengenerator initialisieren und die Zählvariable auf 1 setzen. Dazu würde ich folgenden Vorschlag machen:

Delphi-Quellcode:

//  Diese Methode wird immer aufgerufen wenn das Formular erzeugt wird, also beim Programmstart
procedure TForm1.FormCreate(Sender: TObject);
begin
  // Zufallszahlgenerator initialisieren
  Randomize;
  // Zählvariable auf 1 setzen
  Count:=1;
end;

Ok. Und nun, der Würfel-Knopf:

Delphi-Quellcode:

// Würfel-Knopf
// Diese Prozedur erzeugt die Zufallszahlen von 1 bis 16 in aufsteigender Reihenfolge
// und schreibt die Anzahl der Würfelversuche in Stringgrid2
procedure TForm1.Button1Click(Sender: TObject);
Var
  Col, Row: Integer;
begin
  // Aus Zählvariable die Spalte berechnen
  Col:=(Count-1) mod 4;
  // Aus Zählvariable die Zeile berechnen
  Row:=(Count-1) div 4;
  // Schreibe die Zählvariable in StringGrid1
  StringGrid1.Cells[Col, Row]:=IntToStr(Count);
  // Zähle die Versuche bis die Zahl gewürfelt wurde und schreib die Anzahl in StringGrid2
  StringGrid2.Cells[Col, Row]:=IntToStr(GetRandomNumber(Count, 1, 16));
  // Erhöhe die Zählvariable
  Inc(Count);

  // Falls Zählvariable>16 ist...
  If Count>16 then Begin
    // Meldung an Benutzer ausgeben
    ShowMessage('Stringrid ist voll!');
    // Würfelknopf sperren
    Button1.Enabled:=false;
  End;
end;

Ok. Also, jedesmal, wenn Du auf den Würfel-Knop klickst zählt er um eins weiter, und wenn die Stringgrids voll sind gibt es eine Meldung und der Würfel-Knopf wird gesperrt.

Man könnte auch noch einen zweiten-Knopf machen, nämlich um die StringGrids wieder zu lehren, den Zäher wieder auf 1 zu setzen und den Würfel-Knopf zu entsperren. Dazu noch ein letzter Vorschlag:

Delphi-Quellcode:

// Lösch-Knopf
// Diese Prozedur setzt die Zählvariable zurück und löscht die StringGrids
procedure TForm1.Button2Click(Sender: TObject);
Var
  Col, Row: Integer;
begin
  // Zählvariable wieder auf 1 setzen
  Count:=1;
  // Zähle für die Zeilen von 0 bis 3...
  For Row:=0 to 3 do Begin
    // Zähle für die Spalten von 0 bis 3...
    For Col:=0 to 3 do Begin
      // Lösche die Zelle in StringGrid1 und 2 mit Leerstring
      StringGrid1.Cells[Col, Row]:='';
      StringGrid2.Cells[Col, Row]:='';
    End;
  End;
  // Entsperre wieder den Würfel-Knopf
  Button1.Enabled:=true;
end;

Grüße von TOC!

[guidok]

Das ist jetzt leicht OffTopic.

Sehr nettes Programm TOC, aber hältst du es tatsächlich für sinnvoll, jemanden, der eine Computersprache lernen soll, eine komplette ausgearbeitete Lösung zu geben?

Nicht böse gemeint, aber lernen kann man so nicht viel, wenn man gar nicht mehr denken muss.

[TOC]

Hi!

Zitat:

Zitat von guidok

Das ist jetzt leicht OffTopic.

Ja, ok, deshalb ist meine Antwort darauf ja auch etwas OT:

Zitat:

Zitat von guidok

Sehr nettes Programm TOC, aber hältst du es tatsächlich für sinnvoll, jemanden, der eine Computersprache lernen soll, eine komplette ausgearbeitete Lösung zu geben?

Ja, durchaus! Weil man von einem Programm, wenn man es aufmerksam studiert und sich Gedanken darüber macht, mehr lernen kann als durch unverständliches und unproduktives "erklärendes" Geplapper.

Zitat:

Zitat von guidok

Nicht böse gemeint, aber lernen kann man so nicht viel, wenn man gar nicht mehr denken muss.

Zusammenfummeln muss er sich die Vorschläge die ich ihm gemacht habe ja immer noch selbst, ich habe ja nicht das komplette fertige Programm gepostet. Es sind nur VORSCHLÄGE wie man so etwas programmieren könnte, es soll ihm helfen sein eigenes Programm hinzukriegen. Ich geh mal davon aus, dass er es nicht einfach nur abschreibt sondern darüber nachdenkt und möglicherweise etwas daraus lernt (Wenn vielleicht auch nur als Nebenaspekt die Erkenntnis, dass man möglicherweise eine Antwort bekommt wenn man eine Frage stellt :mrgreen:!).

Grüße von TOC!

[guidok]

Hi TOC,

ich gebe dir teilweise recht.

Zitat:

Zitat von TOC

Ja, durchaus! Weil man von einem Programm, wenn man es aufmerksam studiert und sich Gedanken darüber macht, mehr lernen kann als durch unverständliches und unproduktives "erklärendes" Geplapper.

Das hängt ziemlich stark davon ab, welches Engagement vorhanden ist. Ich unterstelle jetzt mal, dass viele den Code einfach kopieren und gut ist es.

Für fortgeschrittene Programmierer ist es unglaublich hilfreich, sich den Code von anderen anzuschauen und davon zu lernen, aber die Betonung liegt dabei auf fortgeschritten. Grundlagen muss man sich erst mal durch Nachdenken selbst erarbeiten und bei dem hier diskutierten Problem handelt es sich definitiv um Grundlagen.

Zitat:

Zitat von TOC

Ich geh mal davon aus, dass er es nicht einfach nur abschreibt sondern darüber nachdenkt und möglicherweise etwas daraus lernt.

Ich hoffe es.

Freundliche Grüße, :-)

Guido

[TOC]

Hi Guidok!

Sorry, ich werd nochmal OT, aber das hier muss ich klarstellen, weil es war von mir doof formuliert:

Mit der Formulierung "unverständliches und unproduktives "erklärendes" Geplapper" habe ich mich keineswegs auf Dich, Guidok, oder Deinen Beitrag in diesem Thread beziehen wollen, nur dass Du mich bitte nicht falsch verstehst oder es gar persönlich nimmst.

Ich meine damit gewisse Tutorials oder gar teure Bücher, zum Beispiel über DirectX, die man aufmerksam studiert und am Ende vom Buch, kriegt man selbstständig noch nicht einmal einen Strich auf den Bildschirm, weil der Autor des Buches z.B. vergessen hat zu erklären dass man eine Projektions-Matrix erzeugen muss... Oder das Z-Buffering aktivieren... :gruebel: !

Ja, und deshalb bevorzuge ich Quellcode als Informationsquelle.

Liebe Grüße!

[guidok]

Zitat:

Zitat von TOC

nur dass Du mich bitte nicht falsch verstehst oder es gar persönlich nimmst.

Keine Sorge deswegen, ich hatte es nicht so aufgefasst.

Ich bin durchaus auch kein Pädagoge, sondern es ist meine persönliche Einstellung, dass es sinnvoller ist einen Lernenden behutsam auf den Lösungsweg zu bringen und auch zum selbstständigen Denken anzuregen. Das Lernen aus dem Quellcode ist für Fortgeschrittene auf jeden Fall sinnvoll, aber Anfänger müssen erst mal die grundsätzliche Herangehensweise lernen.

So und jetzt ist für meine Seite Schluss mit dem OT.

Einen schönen Tag noch :)

[Delphi-Laie]

Zitat:

Zitat von kunta

In einem Experiment sollen die Zahlen von 1-16 (in genau dieser Reihenfolge) mittels eines Zufallgenerators erzeugt werden.

Wenn die Reihenfolge feststeht (nämlich aufsteigend), benötigt man keinen Zufallsgenerator.

Zitat:

Zitat von kunta

Es gibt insgesamt 16 Durchläufe. Im i-ten Durchlauf wird so lange eine Zufallszahl erzeugt, bis man die Zahl i erhält.

Wenn nur noch eine Zahl fehlt, ist ein Zufallsgenerator ebenfalls redundant.

Und wenn noch zwei Zahlen fehlen, dann wird solang eine Zufallszahl erzeugt, bis man eine der beiden hat, bei dreien dito usw.?

Wenn Du erst wenige Tage programmierst, wirst Du sicher froh sein, ein überhaupt lauffähiges, die Aufgabenstellung erfüllendes Ergebnis zu erhalten, aber trotzdem sei darauf hingewiesen, daß das kein rationeller Algorithmus ist. Im ungünstigsten Falle könnte ein solches Programm in einer Endlosschleife sich verfangen (na gut, bei nur 16 Zahlen ist das "extremst" unwahrscheinlich).

Besser wäre es, aus den Zahlen 1-16 eine per Zufall auszuwählen, dann die Menge (Liste, Array o.ä.) entsprechend zu verkleinern, dann eine Zufallszahl aus den verbliebenen 15 Zahlen auszuwählen usw. . Dann müßtst Du bzw. Dein Programm auch keine Zufallszahlenversuchsirrtümer hinnehmen.

[leddl]

Zitat:

Zitat von Delphi-Laie

Wenn die Reihenfolge feststeht (nämlich aufsteigend), benötigt man keinen Zufallsgenerator.

Es geht hier nicht darum, nur 16 mal zu ziehen. Vielmehr sollen 16 Durchläufe gestartet werden. Im i-ten soll dabei dann solange eine Zufallszahl gezogen werden, bis diese i ist :zwinker:

Zitat:

Zitat von Delphi-Laie

Wenn nur noch eine Zahl fehlt, ist ein Zufallsgenerator ebenfalls redundant.

Es gibt weiterhin 16 mögliche Zahlen für jeden Zufallszug :zwinker:

Im Prinzip geht es hier - sofern ich die Aufgabenstellung richtig verstanden habe - darum, wieviele Versuche jeweils benötigt wurden, um auf die korrekte Zahl für den jeweiligen Durchgang zu kommen.

[kunta]

Hat sich bereits erledigt mit dem Code.
Ich habe ihn bereits fertig und dazu sieht er noch ein wenig anders aus als hier beschrieben.
Es scheint wohl mehrere Lösungswege zu geben.

[DeddyH]

Zitat:

Zitat von kunta

Es scheint wohl mehrere Lösungswege zu geben.

Die gibt es so gut wie immer.