Niedrigsten Werte in Array finden

[MastersOfDesasters]

Hallo,

wir haben in Informatik ein Projekt, was ein Abitur-Rechner/Planer werden
soll. Nun haben wir eine Form, welche aus 11(Fächer)x4(Semester in der Oberstufe) SpinEdits besteht.
Unser Ziel ist es, die 4 Semester mit der schlechtesten Note (die Noten gehen von 0-15 Punkten), rot zu färben (die SpinEdit).

Nur haben wir überhaupt keine Ahnung, wie man diese Werte findet. Die Werte sollen ja nicht verschoben werden (dh immer noch in den SpinEdits stehen).
Eine zusätzliche Regel ist, das pro Fach maximal 2 der 4 Semester gestrichen werden dürfen.

Wir bitten um eure Hilfe! :oops:

[DeddyH]

Hallo und Willkommen in der DP :dp:,

nicht sehr schön, sollte aber funktionieren: erstellt Euch ein Array oder eine Liste der SpinEdits und sortiert diese nach ihrem Inhalt. Die ersten (oder letzten, je nach Sortierung) 4 könnt Ihr dann direkt ansprechen.

[MastersOfDesasters]

Soweit waren wir schon. Die Frage ist ja, woher weiß ich dann hinterher,
in welcher SpinEdit die Werte standen?

[DeddyH]

Die stehen doch im Array?

[MastersOfDesasters]

Wie mach ich das?
Ich weiß nicht wie man das sortiert, und dann anspricht -.-

[DeddyH]

Delphi-Quellcode:

type
  TSpinEditArray = array[0..10] of TSpinEdit;

  TDeinForm = class(TForm)
  ...
  private
    FSpinEdits: TSpinEditArray;
    ...
  end;

Den einzelnen Array-Elementen weist Du nun z.B. im FormCreate die entsprechenden SpinEdits zu. Auf Knopfdruck oder wann auch immer sortierst Du nun das Array. Angedeuteter Bubblesort:

Delphi-Quellcode:

for i := Low(FSpinEdits) to High(FSpinEdits) - 1 do
  if FSpinEdits[i].Value > FSpinEdits[i + 1].Value then

[MastersOfDesasters]

Vieleicht reden wir aneinander Vorbei.
In der Praxis sieht es so aus (beispielsweise):

Mathematik: 12 / 10 / 9 / 12
Geschichte: 9 / 10 / 7 / 5
Englisch: 11 / 7 / 13 / 11
Physik: 11 / 5 / 6 / 9

Nun soll das Programm die 4 geringsten Werte finden,
und diese rot einfärben. Dabei dürfen in jeder "Zeile" bzw. einem
Fach NUR bis zu 2 Bewertungen gestrichen werden.

Das Ergebnis sollte dann so in der Richtung aussehen:

Mathematik: 12 / 10 / 9 / 12
Geschichte: 9 / 10 / 7 / 5
Englisch: 11 / 7 / 13 / 11
Physik: 11 / 5 / 6 / 9

[Namenloser]

Sortieren ist fast schon Overkill.

Pseudocode:

Code:

MinWert := Wert des 1. Element
Gehe alle Elemente durch:
  Wenn Wert des aktuellen Elements < MinWert:
    MinWert := Wert des aktuellen Elements

So findest du das Minimum. Jetzt solltest du dir zusätzlich zum minimalen Wert natürlich noch den Index des Elements merken, um das zugehörige Edit zu rauszufinden.

Anschließend entfernst du das gefundene Element und führst den Algorithmus erneut aus, um das „zweitminimalste“ Element zu finden.

Edit: Oder du implementierst einen Selection-Sort, der nach dem 4. Durchlauf abgebrochen wird. Ist eigentlich fast dasselbe...

[Blup]

Ich habe das eher so verstanden für jedes Fach das schlechteste Semester zu finden.
Wenn nur 1 aus n gefragt ist, kann man sich das sortieren auch sparen:

Delphi-Quellcode:

procedure MarkiereSchlechtesteNote(const AEditArr: array of TSpinEdit);
var
  i: Integer;
  Item: TSpinEdit;
begin
  Item := nil;
  for i := Low(AEditArr) to High(AEditArr) do
  begin
    if (Item = nil) or (Item.Value > AEditArr[i].Value) then
      Item := AEditArr[i];
    AEditArr[i].Color := clWindow;
  end;
  if Assigned(Item) then
    Item.Color := clRed;
end;

{Fach1}
MarkiereSchlechtesteNote([SpinEditFach1Semester1,
                          SpinEditFach1Semester2,
                          SpinEditFach1Semester3,
                          SpinEditFach1Semester4]);
{Fach2}
MarkiereSchlechtesteNote([SpinEditFach2Semester1,
                          SpinEditFach2Semester2,
                          SpinEditFach2Semester3,
                          SpinEditFach2Semester4]);
{usw.}

[MastersOfDesasters]

Naja es ist so in Thüringen,
das wir am Ende das Abis 4 Semester "streichen" müssen.
Logischerweise streicht man die schlechtesten Bewertungen.
Da wir hier 4 Semester pro Fach haben (2 Jahre Oberstufe), und
man nicht ein Fach komplett streichen darf, gibt es die Regel, das man
pro Fach nur maximal 2 Semester streichen kann.
Es kann natürlichauch nur eins gestrichen werden.

Die effektivste "Streichung" habe ich unten mal an einem Beispiel
demonstriert.

Zitat:

Zitat von MastersOfDesasters (Beitrag 1205841)

Mathematik: 12 / 10 / 9 / 12
Geschichte: 9 / 10 / 7 / 5
Englisch: 11 / 7 / 13 / 11
Physik: 11 / 5 / 6 / 9

Das Ergebnis sollte dann so in der Richtung aussehen:

Mathematik: 12 / 10 / 9 / 12
Geschichte: 9 / 10 / 7 / 5
Englisch: 11 / 7 / 13 / 11
Physik: 11 / 5 / 6 / 9

Das ist auch das, was das Programm machen soll.

Fazit:

*schlechtesten Fächer sollen gestrichen werden
*11 Fächer mit je 4 Semestern (Halbjahresnoten)
*nur maximal 2 Semester pro Fach "streichbar"
*Ziel: maximale Gesamtpunktzahl

:shock::shock::shock::shock::shock:

[p80286]

[OT]komplett gestrichen[/OT]

Gruß
K-H

[gammatester]

Die ganze Prozedur ist allerdings noch nicht eindeutig für einen Algorithmus spezifiziert! Warum wird zB nicht die 7 in Geschichte sondern die in Englisch gestrichen? Weiter: Wie soll der Fall behandelt werden, wenn in den 11 Fächern zB 5-mal der Minimalwert in verschiedenen Fächern vorkommt?

[Blup]

Scheint egal zu sein, wenn es nur darum geht die Gesamtpunktzahl zu maximieren.

1. Nimm von jedem Fach die beiden schlechtesten Semester.
2. Bilde eine Gesamtmenge aus den Ergebnissen von 1.
3. Wähle die vier schlechtesten aus dieser Gesamtmenge.

Delphi-Quellcode:

type
  TSpinArr = array of TSpinEdit;

procedure Tausche(var A, B: TSpinEdit);
var
  T: TSpinEdit;
begin
  T := A;
  A := B;
  B := T;
end;

function ErmittleSchlechteste(const AEditArr: TSpinArr; ACount: Integer): TSpinArr;
var
  i1, i2, n: Integer;
  Item: TSpinEdit;
begin
  SetLength(Result, ACount);
  n := 0;
  for i1 := Low(AEditArr) to High(AEditArr) do
  begin
    Item := AEditArr[i1];
    if n < ACount then
    begin
      Result[n] := Item;
      Inc(n);
    end
    else
    begin
      for i2 := 0 to ACount - 1 do
      begin
        if Item.Value < Result[i2].Value then
          Tausche(Item, Result[i2]);
      end;
    end;
  end;
  SetLength(Result, n);
end;

function Gesamtmenge(const A1, A2: TSpinArr): TSpinArr;
var
  i, n1, n2: Integer;
begin
  n1 := Length(A1);
  n2 := Length(A2);
  SetLength(Result, n1 + n2);
  for i := 0 to n1 - 1 do
    Result[i] := A1[i];
  for i := 0 to n2 - 1 do
    Result[n1 + i] := A2[i];
end;

var
  FFach: array of record
    Name: string;
    Semester: TSpinArr;
  end;
  X1, X2: TSpinArr;
  i: Integer;
begin
  SetLength(FFach, 11);

  FFach[0].Name := 'Mathematik';
  SetLength(FFach[0].Semester, 4);
  FFach[0].Semester[0] := SpinEditFach1Semester1;
  FFach[0].Semester[1] := SpinEditFach1Semester2;
  FFach[0].Semester[2] := SpinEditFach1Semester3;
  FFach[0].Semester[3] := SpinEditFach1Semester4;
  {usw.}
  SetLength(X1, 0);
  for i := Low(FFach) to High(FFach) do
  begin
    X2 := ErmittleSchlechteste(FFach[i].Semester, 2);
    X1 := Gesamtmenge(X1, X2);
  end;
  X1 := ErmittleSchlechteste(X1, 4);
end;

[Furtbichler]

Ich würde die eine Liste aller SpinEdits erstellen und sortieren und dann einfach die SpinEdits, von unten beginnend, so lange den Regeln entsprechend (maximal 2 pro Fach) einfärben, bis 4 eingefärbt sind.

Delphi-Quellcode:

Gestrichen := 0;
for i := low(SpinEditListe) to high(SpinEditListe) do
  if KannStreichen(SpinEditListe[i]) then begin
    FaerbeDasSpinEditEin(SpinEditListe[i]);
    inc(Gestrichen);
    if Gestrichen = 4 then break;
  end;

Die Funktion 'KannStreichen' prüft, ob in einem Fach nicht schon zwei Edits gestrichen wurden.

[p80286]

Warum haltet Ihr Euch mit diesen SpinEdits auf?
Die Daten

Delphi-Quellcode:

tMyrec=record
          Fach  : string[20];
          Lfnr  : integer;
          Punkte: integer;
       end;

gehören in eine Liste oder Array und gut ist.
Da kann man sortieren und strichen wie man lustig ist, und hinterher gibt man in Superduperklickibuntlistenspindoctor aus.

Auch wenn es "nur" für die Schule ist, die Trennung von Daten und Oberfläche kann man nicht früh genug lernen.

Gruß
K-H