Mehere Werte auf gleichheit überprüfen

[xZise]

Ich würde gerne mehere Werte auf gleichheit hin überprüfen!

Ungfähr so:

Delphi-Quellcode:

var Value : array [1..3] of Byte;
{...}
if Value[1] = Value[2] = Value[3] then
  Showmessage('Subba! Alle Werte sind gleich!')

Da mekert wer rum!
Gibt es schon eine Funktion? Oder muss ich die mir selber machen:

Delphi-Quellcode:

Result := (Value[1] = Value[2]) and (Value[2] = Value[3])

(Aso: Bei 3 Werten geht es noch, aber wer weiß ... wie es nachher bei 10 oder 20 Werten ist?)

[droppi]

machs doch mit einer for - to schleife
überprüfe ob alle werte des arrays dem wert value[1] entsprechen.

[emteg]

Zitat:

Delphi-Quellcode:

Result := (Value[1] = Value[2]) and (Value[2] = Value[3])

Wo hast du denn das her? Arbeitest du sonst mit ner anderen sprache? Also delphi ist das sicher nicht :)

Eine for schleife wäre definitiv das mittel der wahl. Aber um mal einen weg zu zeigen, der deiner logik entspräche:

Delphi-Quellcode:

if (Value[1]=Value[2]) and (Value[1]=Value[3]) and (Value[2]=Value[3]) then
  Result:=true;

So und nicht anders. Wenn du sagtst Result:= dann erwartet delphi da eine zuweisung. Und mit Value[1]=Value[2] erhältst du keinen wert. Du vergleichst nur zwei array werte, aber ohne das ergebnis zu speichern.

[Muetze1]

Zitat:

Zitat von emteg

Zitat:

Delphi-Quellcode:

Result := (Value[1] = Value[2]) and (Value[2] = Value[3])

Wo hast du denn das her? Arbeitest du sonst mit ner anderen sprache? Also delphi ist das sicher nicht :)

Bevor man grosse Sprüche klopft mal lieber selber ausprobieren, nich?!

Er hat 2 logischer Vergleiche die einen boolsches Ergebnis liefern und das mit einem logischen UND verknüpft - was soll dabei nicht gehen?

[3_of_8]

Mit value[1]=value[2] erhält man durchaus einen Wert, nämlich einen Boolean.

Result:=(value[1]=value[2])and(value[2]=value[3]);

Ist korrekt.

[Hawkeye219]

Zitat:

Zitat von emteg

Delphi-Quellcode:

if (Value[1]=Value[2]) and (Value[1]=Value[3]) and (Value[2]=Value[3]) then
  Result:=true;

Wenn Value[1]=Value[2] und Value[1]=Value[3] ist, was läßt sich dann wohl über Value[2] und Value[3] sagen? :wink:

Gruß Hawkeye

[BenjaminH]

Das müsste doch gehen, oder?

Delphi-Quellcode:

for Value in Array do
  Result:=Result and Value;

[3_of_8]

Nein. in geht nur bei Sets.

[Hawkeye219]

Die FOR-Schleife ist schon korrekt, schaue mal in der Online-Hilfe nach.
Der Compiler wird sich aber weigern, einen Integer-Wert (Value) mit einem Boolean-Wert (Result)zu verknüpfen...

Gruß Hawkeye

//Edit: bei Delphi 7 geht's natürlich noch nicht...

[sakura]

Zitat:

Zitat von 3_of_8

Nein. in geht nur bei Sets.

Das geht auch bei Arrays (seit D2005), allerdings macht es für obige Aufgabe keinen Sinn, da wir hier Bytes vergleichen wollen. Mein Vorschlag:

Delphi-Quellcode:

var
  Cmp: Byte;
  I: Integer;
begin
  Result := True;
  if Length(Value) <= 1 then
    Exit;
  Cmp := Value[Low(Value)];
  for I := Succ(Low(Value)) to High(Value) do
  begin
    if Value[I] <> Cmp then
    begin
      Result := False;
      Break;
    end;
  end;
end;

@emteg: wie schon gesagt, erst testen, dann reden. Zusätzlich ist Deine Lösung auch noch falsch, da Result undefiniert wäre, wenn nicht alle Werte den gleichen Wert hätten ;)

...:cat:...

[3_of_8]

Immer diese Sprachfeatureerweiterungen. Ich bleib bei meinem Delphi 7.

[BenjaminH]

Nehmen wir mal an, D2k5 ist vorhanden, dann wäre diese Lösung doch auch gut:

Delphi-Quellcode:

type TIntegerArray=Array of Integer;
function AreEqual(Values:TIntegerArray):Boolean;
Var Key:Integer;
  FirstKey:Integer;
Begin
  If Length(Values)<1 then
    exit;
  FirstKey:=Values[Low(Values)];
  for Key in Values do
     Result:=Result and (Key=FirstKey);
End;

Oder passt da was nicht?

@sakura: Den Vergleich verstehe ich nicht:

Delphi-Quellcode:

if Length(Value) <= < then

wie kann man mit einem Operator vergleichen?

[sakura]

Zitat:

Zitat von BenjaminH

Nehmen wir mal an, D2k5 ist vorhanden, dann wäre diese Lösung doch auch gut:[delphi]type TIntegerArray=Array of Integer;

Der funktioniert, nur mir persönlich sind da zuviele Zuweisungen (Result := ...), es wird immer der erste Wert wiederholt verglichen (mit sich selbst). Es geht, ist imo aber etwas irreführend. Ausserdem gehst Du immer das gesamte Array durch, auch wenn bereits nach zwei Werten eine Abweichung besteht, yet 998885 to go ;)

Zitat:

Zitat von BenjaminH

@sakura: Den Vergleich verstehe ich nicht:

Tippfehler korrigiert ;)

...:cat:...

[Hawkeye219]

Hallo Benjamin,

Du solltest zu Beginn der Funktion deren Rückgabewert noch initialisieren, sonst liefert sie mehr oder weniger zufällige Ergebnisse. :wink:

Gruß Hawkeye

[marabu]

Hallo.

Für den speziellen Fall hat xZise ja schon die optimale Lösung. Bei der allgemeinen Lösung für beliebige Array-Größen müsste bei leerem array eigentlich eine Exception geworfen werden.

Delphi-Quellcode:

function AllBytesEqual(const a: array of byte): Boolean;
var
  i: Integer;
begin
  Result := false;
  for i := Succ(Low(a)) to High(a) do
    if a[i] <> a[Pred(i)] then
      Exit;
  Result := Length(a) > 0;
end;

Grüße vom marabu

[sakura]

Zitat:

Zitat von marabu

Bei der allgemeinen Lösung für beliebige Array-Größen müsste bei leerem array eigentlich eine Exception geworfen werden.

Würde ich Definitionssache nennen, wurde aber nicht vorgegeben :mrgreen:

Zitat:

Zitat von marabu

if a[i] <> a[Pred(i)] then

Immer auf a[i] zuzugreifen ist nicht optimal, vorher zwischenspeichern ;)

...:cat:...

[xZise]

Danke für die Antworten :)

@ sakura:
Ist bei 0 Items (im Array) alle gleich?

Zitat:

Zitat von sakura

Delphi-Quellcode:

  Result := True;
  if Length(Value) <= 1 then
    Exit;

@ marabu:
Seit wann kann man ein Array direkt übergeben?
Muss man da nicht erstmal ein Typ davon anlegen, oder ist es anderes weil es

• dynamisch
• oder eine Konstante

ist?

[Ralf Kaiser]

[quote="emteg"]

Zitat:

So und nicht anders. Wenn du sagtst Result:= dann erwartet delphi da eine zuweisung. Und mit Value[1]=Value[2] erhältst du keinen wert. Du vergleichst nur zwei array werte, aber ohne das ergebnis zu speichern.

Hallo,

natürlich liefert "Value[1]=Value[2]" einen Wert und zwar einen Boolean-Wert der true ist wenn die beiden Werte gleich sind und der false ist wenn beide Werte ungleich sind. Es wird also Result ein Wert zugewiesen (sonst würde dieser Ausdruck ja schon vom Compiler bemängelt.

Also:

Delphi-Quellcode:

if Value[1]=Value[2] then Result := true;

kann man auch so schreiben:

Delphi-Quellcode:

Raesult := Value[1] = Value[2];

Ciao,
Ralf

[MStoll]

Zitat:

Zitat von Alfi001

Also:

Delphi-Quellcode:

if Value[1]=Value[2] then Result := true;

kann man auch so schreiben:

Delphi-Quellcode:

Raesult := Value[1] = Value[2];

Ciao,
Ralf

Hallo,

das kann man nicht unbedingt so schreiben, da bei einer Zuweisung der vorherige Wert von result auf JEDEN Fall ersetzt wird. Eine if-then-else-Konstruktion kann man durch eine Zuweisung ersetzen. Hier fehlt allerdings der else-Zweig. Den Unterschied merkt man, wenn result vorher schon true ist. Bei

Delphi-Quellcode:

if Value[1]=Value[2] then Result := true;

bleibt result true.
Bei

Delphi-Quellcode:

Result := Value[1] = Value[2];

wird es false.

Gruß
Michael

[Edit]Wollte dies nur anmerken, da man (mich eingeschlossen) bei solchen "Optimierungen", sprich if-Konstrukte durch Zuweisungen zu ersetzen, oft kleine Fehler macht, die nachher schwer zu entdecken sind.[/Edit]

[negaH]

deine IF THEN Abfrage ist nichts anderes als eine Implikation des vorherigen Wertes von result.

Geht also auch so

Delphi-Quellcode:

Result := Result or (Value[1] = Value[2]);

oder

Delphi-Quellcode:

Result := Result and (Value[1] = Value[2]);

je nachdem was man erreichen möchte.

Es gibt also in diesem Falle keinen Grund eine unnötige Verkomplizierung durch die IF THEN Abfrage zu machen.
Normalerweise hängt die Schwierigkeit im Verständnis des Programmieres bei solchen Konstrukten von derem "geschmack" ab.

1.) rein mechanisch denkende Menschen bervorzugen strukturierte IF THEN etc. Blöcke, quasi stückchenweises herangehen an ein Problem durch stückchenweises Ausschlußverfahren.

2.) formal denkende Menschen bevorzugen eine Gleichung/Formel zur Lösung eines Problems. Sie "kodieren" also ein Problem im Kopf so um das sie das Problem ansich als Formel darstellen können. Dies ist in den meisten Fällen besser da dadurch auch die Möglichkeiten entstehen um zb. die Komplexität eines Algos. zu errechnen, quasi sein Laufzeitverhalten. Oder durch einfache Umstellungen der Formeln diese zu verbesern. All das geht mit rei mechnischer Vorgehensweise nicht so leicht.


Gruß Hagen

[MStoll]

@Hagen:
Mit "and" bzw. "or" ist natürlich auch eine Möglichkeit ;)
Wobei man jetzt wieder darüber diskutieren könnte, was schneller ist, wenn
(Value[1] = Value[2]) false ist.

Schließlich hätte man bei ner Zuweisung ne Schreiboperation, während ein if-Konstrukt in diesem Fall nur lesen würde.

[Elvis]

Zitat:

Zitat von sakura

Zitat:

Zitat von marabu

if a[i] <> a[Pred(i)] then

Immer auf a[i] zuzugreifen ist nicht optimal, vorher zwischenspeichern ;)

Schon eine ganze Weile her als ich das letzte Mal im CPU Fenster deubggt hab, aber sollte ein klassischer for to loop über einen Array nicht darin resultieren, dass einfach ein Pointer auf das Element inkremeiert wird? :gruebel:

Wenn nicht:

Delphi-Quellcode:

function AllEqual(const values : array of Byte) : Boolean;
var
  firstElement,
  lastElement,
  currentElement : PByte;
begin
  if Length(values) > 1 then
  begin
    firstElement := @values[Low(values)];
    lastElement  := @values[High(values)];

    currentElement := firstElement;

    while  Integer(currentElement) < Integer(lastElement) do
    begin
      Inc(currentElement);

      Result := currentElement^ = firstElement^;

      if not Result then
        Exit;
    end;
  end
  else
    Result := true;
end;

Nicht schlagen, wenn's BS ist *dummer .Net Fritze ist :P *

[negaH]

Zitat:

Schon eine ganze Weile her als ich das letzte Mal im CPU Fenster deubggt hab, aber sollte ein klassischer for to loop über einen Array nicht darin resultieren, dass einfach ein Pointer auf das Element inkremeiert wird?

Wie kommst du zu dem Schluß ?

Heutige CPUs sind daraufhin optimiert gerade den Array-indizerten-record-basierten Zugriff auf den Speicher zu ermöglichen. Dies ist bei weitem effizienter, sowohl im Verständnis, Geschwindigkeit und Verbrauch an Speicher für den Code.

Die effizienteste Lösung dürfte darin bestehen ein Element im Array[] zu finden das NICHT identisch mit dem ersten Element des Arrays[] ist.

Auf CPU Ebene gibt es den Befehl "scanne Speicherarray auf einen Wert <> X" -> REP SCASD

Gruß Hagen

[Elvis]

hehe, bin schon ganz lieb und ruhig. Zumindest solange du nun auch einen Schnipsel rausrückst. :mrgreen:
Wer A sagt muss auch ... Code tippen. :P

[xZise]

Zitat:

Zitat von MStoll

Bei

Delphi-Quellcode:

if Value[1]=Value[2] then Result := true;

bleibt result true.
Bei

Delphi-Quellcode:

Result := Value[1] = Value[2];

wird es false.

Das ist aber auch der einzige Grund! Und bisher bin ich gut mit 2. zurecht gekommen.

Und außerdem ist es ziemlich logisch die 2. Konstruktion zu nehmen, weil if nichts anderes ist als zu überprüfen ob das zwischen if und then true ist, und dann bestimmte Dinge zu machen!
D.h. das Value[1] = Value[2] ein Bollean zurückgeben MUSS, weil ansonsten würde der Compiler meckern!