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

[Darlo]

Zitat:

Zitat von hoika (Beitrag 1331004)

Ah so: elegant und trotzdem leserlich sollte es sein.

Dann

Zitat:

Zitat von p80286 (Beitrag 1331003)

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:

Zitat von SProske (Beitrag 1331007)

Zitat:

Zitat von TiGü (Beitrag 1330995)

Delphi-Quellcode:

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:

Zitat von TiGü (Beitrag 1331029)

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

oder ;)

Delphi-Quellcode:

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

[Delphi-Laie]

Zitat:

Zitat von BenjaminH (Beitrag 1331030)

Zitat:

Zitat von TiGü (Beitrag 1331029)

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

oder ;)

Delphi-Quellcode:

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:

Zitat von Delphi-Laie (Beitrag 1331036)

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:

Zitat von Delphi-Laie (Beitrag 1331036)

Zitat:

Zitat von BenjaminH (Beitrag 1331030)

...
oder ;)

Delphi-Quellcode:

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:

Zitat von Uwe Raabe (Beitrag 1331047)

Zitat:

Zitat von Delphi-Laie (Beitrag 1331036)

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.