Sammelbilder [lineares Feld]

[me2u]

Hi Delphi-Praxis Community,

folgende Problemstellung habe ich:

Eine Schokoladenfirma möchte den Umsatz ihrer Schokolade ankurbeln. Die Werbeabteilung kommt auf die (nicht gerade originelle) Idee, mit Sammelbildern neue Käufer zu gewinnen. Jeder Schokoladentafel soll ein Sammelbild beigepackt werden. Mehrere verschiedene Bilder bilden eine Serie, und die Käufer sollen (mindestens) so viele Tafeln kaufen, bis sie die Serie komplett haben. Dann interessiert, wie viele Schokoladentafeln im Mittel gekauft werden müssen, bis eine Serie vollständig ist. Voraussetzung ist dabei, dass die verschiedenen Bilder in gleicher Anzahl beigelegt und die Tafeln in die Versandkartons gut gemischt und verpackt werden.

Verwenden Sie einen Array, der so viele Elemente hat wie es Bilder gibt. Vereinbaren Sie außerdem Variable für die Anzahl der noch in der Serie fehlenden Bilder und der schon gesammelten Bilder. Die Anzahl der Bilder in der Serie könnte als Konstante vereinbart werden.

Oookay

Also nehmen wir mal an, es gibt 10 Bilder zu sammeln, dann wären die Variablen folgendermaßen:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);

var fehlend, schongekauft : integer;
    Bilder : array [1..10] of integer;

Ich habe jetzt mehrere Ideen, die mir im Kopf herumgeistern, aber irgendwie bringe ich sie nicht zusammen in einen richtigen Code. Könnt ihr mir vielleicht helfen ? Meine Idee ist eben, dass z.B. wenn man das 3. Bild zieht, die Variable um 1 addiert wird, also
  Bilder[3] := Bilder [3] + 1 In der Schleife wird das dann überprüft und dann wird alles weitere berechnet:

Delphi-Quellcode:

   
IF Bilder [5] = 0 THEN
  fehlend := fehlend - 1;

Also wie gesagt, ich weiß nicht genau, wie ich da rangehen soll. Vielleicht könnt ihr mir ja mal ein paar Tips geben. Das wäre echt suuper !

Hier ist schonmal ein klitzekleiner Anfang :

Delphi-Quellcode:

begin
  randomize;
  schon := 0;
  fehlend := 10;

Mit freundlichen Grüßen
me2u

[chaosben]

Hi me2u!

Laß uns das Problem mal systematisch angehen.

Als erstes brauchen wir die Variablen mit denen wir arbeiten wollen. Die gebe ich der Einfachheit mal vor:

Delphi-Quellcode:

const
  BILDER_GESAMT=10; //logisch oder?
var
  Bilder : array[0..BILDER_GESAMT-1] of Cardinal; //dadurch das wir hier die Konstante nutzen, brauchen wir bei einer Änderung der Bilderzahl nicht immer die Dimension des Arrays anpassen
  Schokoladen : Cardinal; //die Anzahl der Schokoladen, die wir kaufen
  BilderKomplett : Boolean; //wird true sein, wenn wir alle Bilder gesammelt haben
  BildIndex : Cardinal; //eine Zählvariable um durch das Array zu laufen

So, jetzt gehts richtig los.
Am Anfang haben wir 0 Schokoladen gekauft (worüber sich der Geldbeutel freut ). Also müssen wir Schokoladen auf 0 setzen (deine Aufgabe ist es ab jetzt, dir den Code zu dem auszudenken, was ich sage )
Auch haben wir am Anfang noch kein einziges Bild gesammelt. Also sollten wir alle Felder im Array auf 0 setzen.
Als nächstes kommt die Einkaufsschleife ... eine Schleife, in der wir solange Schokoladen kaufen bis wir alle Bilder gefunden haben. Wir hören erst auf mit dem Schokolade kaufen, wenn wir alle BilderKomplett haben.
Der Inhalt der Schleife beschreibt einen Einkauf. Was passiert dabei?
Die Anzahl der Schokoladen erhöht sich um 1. (Was sonst?) Wir bekommen auch ein neues Bild in unsere Sammlung. (Hinweis: Random(BILDER_GESAMT) liefert bei obiger Deklaration immer einen gültigen Index aus dem Array) Also muss der Wert des entsprechenden Feldes im Array um eins erhöht werden.
Und da wir nun hoffen, endlich alle Bilder gefunden zu haben, kontrollieren wir, ob wir von jedem Bild mindestens eins haben.
Wenn das so ist können wir sagen das wir alle BilderKomplett haben. Damit sollte auch unsere Einkaufsschleife beendet sein.
In der Variable "Schokoladen" wissen wir nun, wieviele Schokoladen wir kaufen mussten, um alle Bilder zu bekommen.

Das Ganze kann man jetzt in eine Funktion packen und diese N-mal aufrufen und damit den Mittelwert (lt. Aufgabenstellung) errechnen.

So, ich hoffe, das hat dir ein wenig geholfen. Falls du Lust hast, können wir am Ende deiner Untersuchungen unsere Quellcodes mal vergleichen.

[Jelly]

Zitat von me2u:

Eine Schokoladenfirma möchte den Umsatz ihrer Schokolade ankurbeln. Die Werbeabteilung kommt auf die (nicht gerade originelle) Idee, mit Sammelbildern neue Käufer zu gewinnen. Jeder Schokoladentafel soll ein Sammelbild beigepackt werden. Mehrere verschiedene Bilder bilden eine Serie, und die Käufer sollen (mindestens) so viele Tafeln kaufen, bis sie die Serie komplett haben. Dann interessiert, wie viele Schokoladentafeln im Mittel gekauft werden müssen, bis eine Serie vollständig ist. Voraussetzung ist dabei, dass die verschiedenen Bilder in gleicher Anzahl beigelegt und die Tafeln in die Versandkartons gut gemischt und verpackt werden.

Verwenden Sie einen Array, der so viele Elemente hat wie es Bilder gibt. Vereinbaren Sie außerdem Variable für die Anzahl der noch in der Serie fehlenden Bilder und der schon gesammelten Bilder. Die Anzahl der Bilder in der Serie könnte als Konstante vereinbart werden.

Und wo die die Frage ? Sollst Du da eine Statistik berechner oder geht es nur drum ein array anzulegen.

[angos]

Hi,

ich tippe mal, dass es um diese Zahl geht.

Zitat:

Dann interessiert, wie viele Schokoladentafeln im Mittel gekauft werden müssen, bis eine Serie vollständig ist.

[mkinzler]

Jelly meinte wohl nicht die Fragestellung des Lehrers(?) sondern was die Frage von me2u ist.

[me2u]

Hiho,

vielen vielen Dank für die Anleitung @chaosben. Momentan bin ich noch in der Schule. Allerdings werde ich gegen Abend gleich mal das austesten, was du vorgeschlagen hast. Ich melde mich wieder, sobald ich nicht mehr weiter weiß. Bis später

[edit]
Ou man, was hab ich da nur zusammengemurkst

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);

const bilder_gesamt = 10;       //Anzahl aller Bilder

var Bilder : array [0..(bilder_gesamt-1)] of boolean;
    Tafeln : integer;           //Anzahl der Tafeln Schokolade, die gekauft werden
    fehlend : integer;          //Anzahl der Bilder, die man noch nicht gesammelt hat
    i : integer;                //Zählvariable

begin
  //Zufallsgenerator initialisieren
  randomize;

  //Startwerte setzen
  Tafeln := 0;
  fehlend := 10;
  for i := 1 to bilder_gesamt do
    Bilder[i] := false;

  //Verarbeitung: "Einkauf" Schleife
  for i := 1 to 100 do
  begin
    Tafeln := Tafeln + 1;
    IF Bilder[random(bilder_gesamt)] = false THEN
    begin
      Bilder[random(bilder_gesamt)] := true;
      fehlend := fehlend - 1;
    end
    ELSE exit;
  end;

  //Ausgabe
  lblAusgabe.Caption := 'Man muss ' + IntToStr(Tafeln) + ' Tafeln kaufen.';

end;

end.

Hilfe Momentan gibt er noch eine Fehlermeldung des Debuggers aus. Ich weiß zwar, was man machen muss, kann es aber irgendwie nicht in Code umsetzen.
Man setzt immer array[random(10)] auf true und guckst jedes Mal ob alle 10 Elemente true sind, also ob man alle Bilder gesammelt hat. Wenn das der Fall ist kann man abbrechen. Aber was ich da mache, ist Schwachsinn oder ?
[/edit]

mfg
me2u

[me2u]

Sorry für den Doppelpost !

[xZise]

Ein paar Dinge
1. Doppelposts sind erst ab 24 h erlaubt (lieber editieren. Die Antworter werden es dir danken)
2. Benutzte statt einer for-schleife eine while-schleife. Weil es kann ja sein, dass man mit 100 Tafeln immer noch nicht alle gefunden hat
3. Du machst einen größeren Fehler bei der Zuweisung:

Delphi-Quellcode:

if x[Random(..)] = false then
  x[Random(..)] := true;

Und zwar erstellst du einmal beim überprüfen und einmal beim setzen eine Zufallszahl, welche unterschiedlich sein können.
Also =>

Delphi-Quellcode:

a := Random(..)
if x[a] = false then
  x[a] := true;

4. Wenn du das Bild schon besitzt beendet er die Prozedur Was nicht im Sinne der Aufgabe ist.

Mein Tipp wäre also:
Durchlaufe die Schleife solange bis du keine fehlenden Bilder mehr hast. (fehlende Bilder ist eine Variable)
In jeden druchlauf überprüfst du ob du das Bild schon hast.
Wenn es ein neues Bild ist, setze ein weniger fehlendes Bild und setze das Bild auf wahr.

[chaosben]

So, da du dir schon soviel Mühe gegeben hast, poste ich mal meinen Code. Vielleicht inspiriert er dich noch ein bißchen.

Delphi-Quellcode:

procedure TForm1.btn_Button1Click(Sender: TObject);
const
  BILDER_GESAMT=10;
var
  Bilder : array[0..BILDER_GESAMT-1] of Cardinal;
  Schokoladen : Cardinal;
  BilderKomplett : Boolean;
  BildIndex : Cardinal;
begin
  Schokoladen:=0;

  for BildIndex:=Low(Bilder) to High(Bilder) do
    Bilder[BildIndex]:=0; 

  Randomize;

  BilderKomplett:=false;

  while not BilderKomplett do
  begin
    Inc(Schokoladen);

    Inc(Bilder[Random(BILDER_GESAMT)]);

    BilderKomplett:=true;
    for BildIndex:=Low(Bilder) to High(Bilder) do
      BilderKomplett:=BilderKomplett and (Bilder[BildIndex]>0);

  end;


  btn_Button1.Caption:=IntToStr(Schokoladen);
end;

Deine Idee mit dem Array of Boolean ist auch schön ... imho schöner als meine Zählerei.

[xZise]

Zitat von chaosben:

Delphi-Quellcode:

procedure TForm1.btn_Button1Click(Sender: TObject);
const
  BILDER_GESAMT=10;
var
  Bilder : array[0..BILDER_GESAMT-1] of Cardinal;
  Schokoladen : Cardinal;
  BilderKomplett : Boolean;
  BildIndex : Cardinal;
begin
  Schokoladen:=0;

  for BildIndex:=Low(Bilder) to High(Bilder) do
    Bilder[BildIndex]:=0; 

  Randomize;

  BilderKomplett:=false;

  while not BilderKomplett do
  begin
    Inc(Schokoladen);

    Inc(Bilder[Random(BILDER_GESAMT)]);

    BilderKomplett:=true;
    for BildIndex:=Low(Bilder) to High(Bilder) do
      BilderKomplett:=BilderKomplett and (Bilder[BildIndex]>0);

  end;


  btn_Button1.Caption:=IntToStr(Schokoladen);
end;

Du kannst dir die 2. Forschleife ersparen:

Delphi-Quellcode:

{VAR}
Fehlend, rnd : Cardinal;
{ANSTELLE DER WHILE-SCHLEIFE}
Fehlend := Length(Bilder);
while Fehlend > 0 do
begin
  Inc(Schokoladen);
  rnd := Random(BILDER_GESAMT);
  Inc(Bilder[rnd]);
  if Bilder[rnd] = 1 then
    Dec(Fehlend);
end;

Du brauchst hier natürlich "BilderKomplett" nicht mehr.