Elegante Lösung gesucht, 3 Boolean-Werte, nur einer darf gesetzt sein

[Darlo]

Zitat von hoika:

Ah so: elegant und trotzdem leserlich sollte es sein.

Dann

Zitat von p80286:

Delphi-Quellcode:

w:=0;
if B1 then inc(w,1);
if B2 then inc(w,1);
if B3 then inc(w,1);
bok:=W=1;

Gruß
K-H

als assembler code und

Delphi-Quellcode:

{Assembler-Code macht folgendes:
w:=0;
if B1 then inc(w,1);
if B2 then inc(w,1);
if B3 then inc(w,1);
bok:=W=1;}

drüber

[TiGü]

Zitat von SProske:

Zitat von TiGü:

bOK := B1 xor B2 xor B3;

Ergibt für 3mal True wieder True

Das kann man ja mit einer einfachen if-Abfrage vorher prüfen.

[BenjaminH]

Zitat von TiGü:

Das kann man ja mit einer einfachen if-Abfrage vorher prüfen.

oder
bOK := (B1 xor B2 xor B3) and not (B1 and B2 and B3);

[Delphi-Laie]

Zitat von BenjaminH:

Zitat von TiGü:

Das kann man ja mit einer einfachen if-Abfrage vorher prüfen.

oder
bOK := (B1 xor B2 xor B3) and not (B1 and B2 and B3);

Das ist elegant! So etwas suchte ich auch, fand es aber auf die Schnelle nicht. Zwar werden die drei Variablen zweimal miteinander verknüft (soweit war ich noch(?) nicht), jedoch verbleibt die Lösung des Problems auf dem Niveau boolescher bzw. logischer Operationen (die Addition ist pragmatisch und korrekt, hat aber den zwangsläufigen Nimbus einer Bastelei). Außerdem ist augenblicklich klar, daß diese Funktion für beliebig viele Operanden erweiter- bzw. anwendbar ist (beliebig großes boolesches Array).

Meine Anerkennung!

[Uwe Raabe]

Zitat von Delphi-Laie:

Außerdem ist augenblicklich klar, daß diese Funktion für beliebig viele Operanden erweiter- bzw. anwendbar ist (beliebig großes boolesches Array).

Wie würde man das denn jetzt auf vier boolsche Variablen erweitern?

[Sir Rufo]

Eventuell so?

Delphi-Quellcode:

function IsOneOfThree( const B1, B2, B3: Boolean ): Boolean;
begin
  Result := ( B1 xor B2 xor B3 ) and not ( B1 and B2 and B3 );
end;

function IsOneOfFour( const B1, B2, B3, B4: Boolean ): Boolean;
begin
  Result := IsOneOfThree( IsOneOfThree( B1, B2, B3 ), B4, False );
end;

[HeZa]

Zitat von Delphi-Laie:

Zitat von BenjaminH:

...
oder
bOK := (B1 xor B2 xor B3) and not (B1 and B2 and B3);

Das ist elegant! So etwas suchte ich auch, fand es aber auf die Schnelle nicht. Zwar werden die drei Variablen zweimal miteinander verknüft (soweit war ich noch(?) nicht), jedoch verbleibt die Lösung des Problems auf dem Niveau boolescher bzw. logischer Operationen (die Addition ist pragmatisch und korrekt, hat aber den zwangsläufigen Nimbus einer Bastelei). Außerdem ist augenblicklich klar, daß diese Funktion für beliebig viele Operanden erweiter- bzw. anwendbar ist (beliebig großes boolesches Array).

Meine Anerkennung!

Dem schließe ich mich an.

[SProske]

Für die beliebige Anzahl an Bool-Werten (Array) würde mir jetzt eher so etwas vorschweben:

Delphi-Quellcode:

function IsOnlyOneTrue(const BoolArr: TArray<Boolean>): Boolean;
var
  I: Integer;
begin
  Result := False;
  for I := Low(BoolArr) to High(BoolArr) do
    if BoolArr[I] then
      if Result then
        Exit(False)
      else
        Result := True;
end;

[hoika]

Hallo,

nachdem ich den Code gezeigt habe, wurde mir gesagt
"Falsch!", der erste True-Wert wird genommen, egal wie viele True sind


Heiko

[Delphi-Laie]

Zitat von Uwe Raabe:

Zitat von Delphi-Laie:

Außerdem ist augenblicklich klar, daß diese Funktion für beliebig viele Operanden erweiter- bzw. anwendbar ist (beliebig großes boolesches Array).

Wie würde man das denn jetzt auf vier boolsche Variablen erweitern?

Ganz schwierig:

bOK := (B1 xor B2 xor B3 xor B4) and not (B1 and B2 and B3 and B4)

vermutlich aber falsch, wie mir jetzt dämmert, weil das Zwischenergebnis der xor-Operationen ständig alterniert (ich bin jetzt auf die Schnelle zu bequem zum Denken oder Probieren). Es kommt also darauf an, daß die Anzahl der Operanden (un)gerade bleibt. Bei 5 Operanden

bOK := (B1 xor B2 xor B3 xor B4 xor B5) and not (B1 and B2 and B3 and B4 and B5)

sollte es aber wieder stimmen.

Edit: Asche auf mein Haupt, es klappt weder mit 4en noch mit 5en. Ist wohl doch nicht verallgemeinerbar. Schade.