Geldrückgabeautomat programmieren, aber wie?

[steffi20021]

Hallo :wink:

wir sollen als Hausaufgabe über die Ferien einen Geldrückgabeautomaten programmieren.
Also der zu zahlende Betrag wird eingegeben, dann der eingezahlte Betrag und dann soll angegeben werden, welche Scheine/Münzen vom Automaten ausgegeben werden sollen und wie viele.

Erstmal paar allgemeine Fragen zu dem, was wir noch nicht im Unterricht hatten:
1) Meine Lehrerin hat drauf geschrieben, dass man die edit2.change Prozedur nehmen soll.
Wird dann das Ergebniss errechnet, sobald ich den Wert im Edit2 ändere, oder erst, wenn ich edit2 verlasse?
2) Wir sollen den Befehl rest:=Round(Rueckgeld*100); verwenden. Was bedeutet das "round"?


Jetzt noch zum Algorithmus:
Ich hab jetzt schonma ein Struktogramm angefangen.
Also grob, erst die Differenz zwischen zu zahlendem Betrag und eingezahltem Betrag. Das dann in Cent umrechnen (mit dem Befehl zu dem ich vorhin schon gefragt hab).
Dann würde ich eine case...of-Anweisung machen. Also wenn man 20001cent hat erstma durch 20000(für 200€scheine), das wäre ja dann die Anzahl der scheine. Das ganze mit div und dann nochma mit mod, für den rest. Aber der Rest müsste dann wieder in die case...of-Anweisung. Also müsste ich das theoretisch als Schleife machen, aber das hatten wir im Unterricht nochnicht.

Ich hoffe ich hab es jetzt nicht zu verwirrend erklärt!

Jetzt wollt ich fragen, ob ich irgendwie den leichten Weg übersehen hab oder allgemein nen groben Fehler drin hab (denn ich bin die Beste in Info und kann mir nich vorstellen, dass die Anderen auf das kommen), oder gibt es überhaupt einen Weg um Schleifen zu umgehen? Wenn ja, wäre ein kleiner Gedankenanstoß nützlich :)
und ein Link zu einer Seite wo Schleifen erklärt werden, vll auch noch (obwohl ich mir da auch selbst was suchen könnte).

Naja ich hoffe ihr könnt mir helfen!

Steffi


PS: In der Schule haben wir Borland Delphi 6 und zuhause hab ich die 8. Muss ich irgendwas beachten, oder gibt es da keine großen Unterschiede?(außer im Design?)

[Kroko1999]

zu (1) TEdit.OnChange wird bei jeder Änderung des Inhalts ausglöst
zu (2) Round rundet bankisch Real- auf Integer-Werte

und Hallo im Forum :witch:

[Kroko1999]

Delphi-Quellcode:

  for I := 1 to 14 do
  begin
    case I of
     1: G := 20000; //200,00€
     etc.
     14: G := 1 ; //0,01€
    end;
    Anzahl := Geld div G;
   Geld := Geld-Anzahl*G;
   //Anzahl auswerten
  end;

[Stanlay Hanks]

Zitat:

Zitat von steffi20021

(...)
und ein Link zu einer Seite wo Schleifen erklärt werden, vll auch noch (obwohl ich mir da auch selbst was suchen könnte).

Übersicht über Themen betreffend die Delphi Language
Tutorial zu Schleifen

Man liest sich, Stanlay :hi:

PS: Herzlich willkommen! :)

[hanselmansel]

HiHo,

erstmal: Hallo im Forum! :hi:

Eigentlich kannst du das Problem auch ohne Schleifen lösen. Der Ansatz ist zwar mehr zu schreiben (und damit nicht so raffiniert :| ), aber für Delphi-Neulinge (also den Rest deines Kurses) einfacher zu verstehen. :stupid:
Du kannst den Restbetrag immer DIV die einzelnen Stückelungen rechnen und anschließend die Anzahl der ausgegebenen Scheine mal deren Wert vom Rest abziehen. Dadurch ergibt sich so eine eintöige Leiter, die immer die selbe Struktur hat, aber Schleifen brauchst du dafür nicht.

Als Code könnte man sich dann in etwa Folgendes vorstellen:

Delphi-Quellcode:

Rest := Gegeben - Preis; //in Euronen

spe_Anzahl200ter.Value := Rest DIV 200;
Rest := Rest - spe_Anzahl200ter.Value * 200;

spe_Anzahl100ter.Value := Rest DIV 100;
...

Um mit Schleifen usw. vertraut zu werden lohnt sich auf jeden Fall ein Blich in die Delphi-Grundlagen.

MfG,

hanselmansel

P.S.: Stanlay hat ja schon die entsprechenden tutorials auf dsdt.info verlinkt.

[Stanlay Hanks]

Hi nochmal. Ich würde die Lösung mit der Schleife bevorzugen, denn wie ich mir das vorstelle, könnte der Infolehrer daran denken, das ganze auszubauen: z.B. könnten einzelne Scheine (z.B. der 100er) ausgehen und das Programm muss sich anders behelfen. Dazu müsste man die einzelnen Stückelungen dann nur in ein Array übertragen und schon wäre das Ganze (die Lösung mit der Schleife) in dieser Hinsicht flexibel, während der hardgecodete ...äh... Code ( :mrgreen: ) dann an seine Grenzen stößt.

Man liest sich, Stanlay :hi:

[s14]

Hallo, ich würde das spontan so lösen :mrgreen:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
const                             // 500€  200€    100€   50€   20€   10€   5€   2€   1€   Cents...
  Money: Array[0..13] of Cardinal = (50000, 20000, 10000, 5000, 2000, 1000, 500, 200, 100, 50, 10, 5, 2, 1);
var
  Change: Cardinal;
  i : Integer;
begin
  Change := Round(StrToInt(EditChange.Text)); // aus dem Eingabefeld in Cents
  Memo1.Lines.Add('Rückgeld: ' + IntToStr(Change));

  while Change > 0 do
  for i := low(Money) to High(Money) do
    if Change >= Money[i] then begin
      case i of
        0..6: Memo1.Lines.Add(Format('Zahle %d € Schein', [Money[i] div 100]));
        7..8: Memo1.Lines.Add(Format('Zahle %d € Münze', [Money[i] div 100]));
        9..13: Memo1.Lines.Add(Format('Zahle %d Cent Münze', [Money[i]]));
        else  Memo1.Lines.Add('??');
      end;
      Dec(Change, Money[i]);
      Break;
    end;
end;

Im Memo wird die Liste der ausgezahlten Geldmittel dargestellt.

Edit: Hatte 2€ vergessen
und Thanks Hanks :mrgreen:

Edit: 2 Cent Münze eingefügt, mit so kleinen Beträgen kenne ich mich nicht aus:-)

[dfried]

Die 2 Cent Münze hast du auch vergessen :)

[steffi20021]

Erstmal DANKE für eure Tipps und Infos!

@s14: Ich blick bei deinem quellcode überhaupt nich durch, wenn du Zeit und Lust hast, kannst mir ja ma erklären :angel:

Ich hab jetzt mal die Dinge die ich so einigermaßen verstanden hab zusammengeworfen und probiert das Programm zu schreiben...
-->viele Fehlermeldungen, hab es aber hinbekommen :bounce2:

NUR der Quellcode is extrem lang!
Weil:

Code:

case rest of
                    50000..100000:begin anz:=rest div 50000;
                                       rest:=rest mod 50000;
                                       label4.caption:=''+inttostr(anz)+' x 500€';
                                       label4.color:=clred;
                                 end;
                    20000..49999:begin anz:=rest div 20000;
                                       rest:=rest mod 20000;
                                       label5.caption:=''+inttostr(anz)+' x 200€';
                                       label5.color:=clred;
                                 end;

                .....

und ich muss am Anfang der Prozedur die label alle so zu sagen wieder auf 0 setzen (17 Stück) :roll:

Ich glaub mir muss echt ma jemand den Quellcode von s14 erklären :mrgreen:

ich werd wohl morgen auch nochma probieren das ganze bissl zu vereinfachen, ma sehn ob ich nen weg finde. Nur ich weiß halt nochnich so viel und da is das bissl schwerer (verständlich, oder?)

Oh und noch ein Problem. Ich hab öfters mal "Lust" zu programmieren, aber mir fehlen die Ideen. Gibt es da Seiten, wo so Vorschläge vorgestellt sind? Oder was habt ihr so gern als "Anfänger" gemacht?

Nochma Danke, dass ihr mir geholfen habt und mich so freundlich aufgenommen habt! :cheers:

Steffi

[simonko]

Solche Aufgaben kann man prima mit der Automatentechnik lösen. Google mal mealy -moor automat.

[hanselmansel]

Wenn du Ideen für "nebenher" suchst, dann kann ich persönlich den Delphi-Kurs von Hans Lohninger empfehlen. Damit habe ich eigentlich die Anfänge gelernt, und der Kurs hat - wie ich finde - eine angenehme Lernkurve. Vor allem die detailliere Beschreibung der "Lehrerlösungen" sind gut zum Verständnis des Codes.
Ansonsten stellen sich (je nachdem, wie sehr du dich in deiner Freizeit mit Rechenmaschinen beschäftigst) im Alltag eigentlich immer wieder Aufgaben/Probleme, bei denen man sich sagt: Schreib ich doch mal schnell ein Programm in Delphi. Vor allem bei mir ist es so, dass ich (wenn ich genügend Freizeit habe) meine Quick'n Dirty-Programme um viele Funktionen erweitere, an die ich am Anfang gar nicht gedacht habe.
Da ich dabei oft an meine Grenzen stoße, bin ich immer wieder froh, einen Ansatz in den Archiven der DP zu finden.

MfG,
hanselmansel :dp:

[s14]

@Steffi

Sourcecode sagt oft mehr als tausend Worte. Daher habe ich ein kleines Progrämmchen angehängt, dass die oben erwähnte Funktion verwendet.


Gruß
s14

[Treffnix]

Hallo!

Zitat:

Zitat von steffi20021

PS: In der Schule haben wir Borland Delphi 6 und zuhause hab ich die 8. Muss ich irgendwas beachten, oder gibt es da keine großen Unterschiede?(außer im Design?)

Weiss nicht, ob das bisher keiner gelesen hat. Aber um mal drauf zu sprechen zu kommen. Der Unterschied ist gewaltig. Ohne jetzt mal wieder über die allgemeinen Qualitäten von D8 lästern zu wollen ( als Bierdeckel sind die CDs klasse, auch wenn jemand sich mal über das Loch in der Mitte beschwert hat )....

Delphi 8 kann nur .NET Anwendungen erstellen, kein Win32. Eine inkompatiblere Delphiversion gibt es eigentlich nicht.
Bei Delphi 8 war aber immer ein Delphi 7 dabei, wenn ich mich recht erinnere. ( Oder waren nur die Updates inkl. D7? :gruebel: ) Benutz lieber das! Das müsste mit dem Delphi 6 aus der Schule weitesgehend kompatibel sein.

[steffi20021]

So hab mich entschlossen noch mehr über Delphi zu lernen und werd ein bissl Zeit vor meinem Laptop verbringen.

Ich hab jetzt schon ein bissl im Internet geguckt, weil ich einiges nich verstehe, aber hab hauptsächlich Quellcodes gefunden, die mich zwar auch ein bissl weiter gebracht haben aber nich viel.
Mein Problem ist es, dass ich von den meisten Dingen nochnie was gehört habe und somit die Funktionsweise nich verstehe...Also wäre es nett, wenn ihr mir die folgenden Dinge mal kurz erklärt, oder mir ein paar Links gebt *!BITTE!*

Das sind jetzt alles Auszüge aus dem Programm von s14. Hier gleich mal DANKE an s14!

Array [x..y] of ????

Delphi-Quellcode:

Money: Array[0..14] of Cardinal = (50000, 20000, 10000, 5000, 2000, 1000, 500, 200, 100, 50, 20, 10, 5, 2, 1);

Amount: Array[0..14] of Cardinal;

Wenn ich es richtig verstehe is bei Money die 0 für 50000, die 1 für 20000,...
Aber wie is das dann bei Amount?

Delphi-Quellcode:

// Hier wird die Anzahl der einzelnen Zahlungsmittel ermittelt
  while Change > 0 do
  for i := Low(Money) to High(Money) do
    if Change >= Money[i] then
    begin
      Inc(Amount[i]);
      Dec(Change, Money[i]);
      Break;
    end;

Hier wär es nett, wenn ihr mir das Inc, Dec und Break erklärt, vll bringt mich das schon weiter.
Oh und das i steht das für [x..y]?

Delphi-Quellcode:

// Anzeige der einzelnen Labels aktualisieren
  for i := Low(Amount) to High(Amount) do
    case i of
      0:  SetLabel(Label_500, Format('%d x 500 €', [Amount[i]]), Amount[i]);
      1:  SetLabel(Label_200, Format('%d x 200 €', [Amount[i]]), Amount[i]);
      2:  SetLabel(Label_100, Format('%d x 100 €', [Amount[i]]), Amount[i]);
      3:  SetLabel(Label_50, Format('%d x 50 €', [Amount[i]]), Amount[i]);
      4:  SetLabel(Label_20, Format('%d x 20 €', [Amount[i]]), Amount[i]);
      5:  SetLabel(Label_10, Format('%d x 10 €', [Amount[i]]), Amount[i]);
      6:  SetLabel(Label_5, Format('%d x 5 €', [Amount[i]]), Amount[i]);
      7:  SetLabel(Label_e2, Format('%d x 2 €', [Amount[i]]), Amount[i]);
      8:  SetLabel(Label_e1, Format('%d x 1 €', [Amount[i]]), Amount[i]);
      9:  SetLabel(Label_c50, Format('%d x 50 Cent', [Amount[i]]), Amount[i]);
      10: SetLabel(Label_c20, Format('%d x 20 Cent', [Amount[i]]), Amount[i]);
      11: SetLabel(Label_c10, Format('%d x 10 Cent', [Amount[i]]), Amount[i]);
      12: SetLabel(Label_c5, Format('%d x 5 Cent', [Amount[i]]), Amount[i]);
      13: SetLabel(Label_c2, Format('%d x 2 Cent', [Amount[i]]), Amount[i]);
      14: SetLabel(Label_c1, Format('%d x 1 Cent', [Amount[i]]), Amount[i]);
    end;

Hier blick ich absolut nich durch...! Also wenn jemand langeweile und lust hat, kann er ja probieren es mir zu erklären :oops:

Delphi-Quellcode:

// Die Einstellungen der Labels nach Bedarf setzen
  ALabel.Caption := ACaption;
  if Amount > 0 then
  begin
    ALabel.Font.Color := clRed;
    ALabel.Enabled := True;
  end else
  begin
    ALabel.Font.Color := clWindowText;
    ALabel.Enabled := False;
  end;

Steht hier ALabel für alle Label und muss man das vorher definieren, oder is das immer so?
Oh und was is ACaption?


Ok *** das is jetzt fast das ganze Programm von s14. :wall:
Aber wenigstens hab ich mal was, um richtige Fargen zu stellen... :?

Dann erstma Bye!
Steffi

[Treffnix]

Hallo, die Delphi Hilfe ist bei sowas wirklich hilfreich.

Inc inkrementiert den Wert um 1. also Wert = Wert + 1
Dec macht das gleiche umgekehrt ( dekrementiert )= Wert = Wert -1
Break beendet eine Schleife for ihrem eigentlichen ablauf

Delphi-Quellcode:

for i:= 1 to 5 do begin
  If i=3 then
    break;  //Schleife läuft nur bis 3 statt bis 5
End;

Zu den Arrays. Du hast dort 2 davon. In dem Array Money sollen wohl die Wertigkeiten der Scheine stehen. Dies ist statisch. Das heisst, es steht immer das gleiche drin. mit Money[i] kannst du auf den Wert an Stelle i zugreifen. Money[0] wäre 50000 Money[1] 20000 usw.

Das Array Amount wird hier dynamisch verwendet. Ich nehme an, es soll für die Anzahl der "Scheine" aus dem Array Money stehen. Im Grunde Sind es 15 Variablen in einer, die du über den Index (0 bis 14 ) referenzieren kannst. Hier steht zu Beginn in allen Werten "Nichts" drin. Also 0. Erst durch die Inkrementierung bzw. Dekrementierung ändert sich der Wert.

Delphi-Quellcode:

wert = Amount[5] //wert ist 0
inc( Amount[5] ) //erhöhen um 1
wert = Amount[5] //Wert ist 1

[s14]

Treffnix hat ja schon einiges richtig erklärt.

Zitat:

Steht hier ALabel für alle Label und muss man das vorher definieren, oder is das immer so?
Oh und was is ACaption?

Ich habe lediglich die Procedure:

Delphi-Quellcode:

procedure SetLabel(ALabel: TLabel; ACaption: String; Amount: Cardinal);

ausgelagert, da sonst bei jeder Case-Anweisung die Einstellungen für das entsprechende Label vorgenommen werden müssten.
Der Sinn ist, dass öfter verwendete Programmzeilen in eine eigene Procedure ausgelagert werden sollten. Der Code wird einfach übersichtlicher. (Finde ich:)

ALabel steht einfach nur für die Label-Komponente die von der Unterroutine angesprochen werden soll,
ACaption entspricht dem Text der dem Label übergeben wird.

Delphi-Quellcode:

  for i := Low(Amount) to High(Amount) do
    case i of
      0:  SetLabel(Label_500, Format('%d x 500 €', [Amount[i]]), Amount[i]);
      1:  SetLabel(Label_200, Format('%d x 200 €', [Amount[i]]), Amount[i]);
      .
      .

Bei i = 0 wird die Label-Komponente "Label_500" angesprochen, bei i = 1 "Label_200" usw.
Deklariert werden muss da nix, da die Label ja bereits auf dem Formular existieren.