Елегантно визначте, чи є більше логічного значення «істинним»

У мене є набір з п’яти булевих значень. Якщо кілька з них відповідають дійсності, я хочу виконати певну функцію. Який найелегантніший спосіб ви можете придумати, що дозволить мені перевірити цю умову в одному твердженні if ()? Мовою перекладу є C #, але мене цікавлять рішення і іншими мовами (якщо ми не говоримо про конкретні вбудовані функції).

Цікавий варіант - зберегти логічні значення в байті, зробити правильний зсув і порівняти з вихідним байтом. Щось на кшталт if(myByte && (myByte >> 1))Але для цього потрібно буде перетворити окремі булеві значення в байт (за допомогою bitArray?), І це здається трохи (призначеним каламбуром) незграбним ... [редагувати] Вибачте, це мало бути if(myByte & (myByte - 1)) [/ редагувати]

Примітка: Це, звичайно, дуже близько до класичної проблеми програмування "підрахунок населення", "додавання вбік" або "вага Хеммінга" - але не зовсім однакове. Мені не потрібно знати, скільки бітів встановлено, лише якщо їх більше одного. Я сподіваюся, що для цього є набагато простіший спосіб.

Як щодо

  if ((bool1? 1:0) + (bool2? 1:0) + (bool3? 1:0) + 
      (bool4? 1:0) + (bool5? 1:0) > 1)
      // do something

або узагальненим методом буде ...

   public bool ExceedsThreshold(int threshold, IEnumerable<bool> bools)
    {
       int trueCnt = 0;
       foreach(bool b in bools)
          if (b && (++trueCnt > threshold)) 
              return true;
       return false;          
    } 

або використовуючи LINQ, як пропонують інші відповіді:

    public bool ExceedsThreshold(int threshold, IEnumerable<bool> bools)
    { return bools.Count(b => b) > threshold; }

РЕДАКТУВАТИ (щоб додати пропозицію Джоела Кегурна: (у .Net 2.x та пізніших версіях)

    public void ExceedsThreshold<T>(int threshold, 
                      Action<T> action, T parameter, 
                      IEnumerable<bool> bools)
    { if (ExceedsThreshold(threshold, bools)) action(parameter); }

або в .Net 3.5 та пізніших версіях:

    public void ExceedsThreshold(int threshold, 
            Action action, IEnumerable<bool> bools)
    { if (ExceedsThreshold(threshold, bools)) action(); }

або як продовження до IEnumerable<bool>

  public static class IEnumerableExtensions
  {
      public static bool ExceedsThreshold<T> 
         (this IEnumerable<bool> bools, int threshold)
      { return bools.Count(b => b) > threshold; }
  }

тоді використання буде таким:

  var bools = new [] {true, true, false, false, false, false, true};
  if (bools.ExceedsThreshold(3))
      // code to execute  ...

Я збирався написати версію Linq, але п’ять людей близько того мене побили. Але мені дуже подобається підхід params, щоб уникнути необхідності вручну створювати масив. Тож я думаю, що найкращий гібрид - це, базуючись на відповіді rp із заміною кузова на очевидний Linqness:

public static int Truth(params bool[] booleans)
{
    return booleans.Count(b => b);
}

Чудово зрозумілий для читання та використання:

if (Truth(m, n, o, p, q) > 2)

Настав час обов'язкової відповіді LINQ, яка насправді досить акуратна.

var bools = new[] { true, true, false, false, false };

return bools.Count(b => b == true) > 1;

Я б просто кинув їх на інти і суму.

Якщо ви не в надзвичайно щільному внутрішньому циклі, це має перевагу, що його легко зрозуміти.

Я б написав функцію для отримання будь-якої кількості булевих значень. Це поверне кількість тих істинних значень. Перевірте результат на кількість значень, які ви повинні бути позитивними, щоб щось зробити.

Працюйте більше, щоб зробити це зрозумілим, а не розумним!

private int CountTrues( params bool[] booleans )
{
    int result = 0;
    foreach ( bool b in booleans )
    {
        if ( b ) result++;
    }

    return result;
}

якщо ви маєте на увазі більше або дорівнює одному логічному значення, рівному істині, ви можете зробити це як

if (bool1 || bool2 || bool3 || bool4 || bool5)

Якщо вам потрібно більше одного (2 і вище) логічного значення, рівного true, ви можете спробувати

int counter = 0;
if (bool1) counter++;
if (bool2) counter++;
if (bool3) counter++;
if (bool4) counter++;
if (bool5) counter++;
if (counter >= 2) //More than 1 boolean is true

Якби мільйони були замість лише 5, ви могли б уникнути Count () і зробити це замість цього ...

public static bool MoreThanOne (IEnumerable<bool> booleans)
{
    return booleans.SkipWhile(b => !b).Skip(1).Any(b => b);
}

Якщо ваші прапори упаковані в одне слово, тоді рішення Майкла Берра спрацює. Однак цикл не є необхідним:

int moreThanOneBitSet( unsigned int v)
{
    return (v & (v - 1)) != 0;
}

приклад

 v (binary) | v - 1 | v&(v-1) | result
------------+-------+---------+--------
       0000 |  1111 |    0000 |  false
       0001 |  0000 |    0000 |  false
       0010 |  0001 |    0000 |  false
       0011 |  0010 |    0010 |   true
       .... |  .... |    .... |   ....
       1000 |  0111 |    0000 |  false
       1001 |  1000 |    1000 |   true
       1010 |  1001 |    1000 |   true
       1011 |  1010 |    1010 |   true
       1100 |  1011 |    1000 |   true
       1101 |  1100 |    1100 |   true
       1110 |  1101 |    1100 |   true
       1111 |  1110 |    1110 |   true

Коротший і потворніший, ніж версія Vilx-s:

if (((a||b||c)&&(d||e))||((a||d)&&(b||c||e))||(b&&c)) {}

з маківки, швидкий підхід для цього конкретного прикладу; ви можете перетворити bool на int (0 або 1). потім прокрутіть терм і додайте їх. якщо результат> = 2, то ви можете виконати свою функцію.

Хоча мені подобається LINQ, в ній є деякі діри, як ця проблема.

Взагалі робити підрахунок це нормально, але це може стати проблемою, коли обчислення / отримання предметів, які підраховуєте, триває деякий час.

Метод розширення Any () чудово підходить, якщо ви просто хочете перевірити його наявність, але якщо ви хочете перевірити принаймні, немає вбудованої функції, яка це зробить і буде лінивою.

Врешті-решт, я написав функцію повернення true, якщо в списку є хоча б певна кількість елементів.

public static bool AtLeast<T>(this IEnumerable<T> source, int number)
{
    if (source == null)
        throw new ArgumentNullException("source");

    int count = 0;
    using (IEnumerator<T> data = source.GetEnumerator())
        while (count < number && data.MoveNext())
        {
            count++;
        }
    return count == number;
}

Використовувати:

var query = bools.Where(b => b).AtLeast(2);

Це виграє в тому, що перед поверненням результату не потрібно оцінювати всі елементи.

[Plug] Мій проект, NExtension містить AtLeast, AtMost та перевизначення, які дозволяють змішувати предикат із перевіркою AtLeast / Most. [/ Вилка]

Кастинг на ints та підведення підсумків повинен працювати, але це трохи потворно, і на деяких мовах це може бути неможливо.

Як щодо чогось подібного

int count = (bool1? 1:0) + (bool2? 1:0) + (bool3? 1:0) + (bool4? 1:0) + (bool5? 1:0);

Або якщо ви не дбаєте про простір, ви можете просто попередньо обчислити таблицю істини і використовувати bools як індекси:

if (morethanone[bool1][bool2][bool3][bool4][bool5]) {
 ... do something ...
}

Я б зробив щось подібне, використовуючи аргумент params.

        public void YourFunction()
        {
            if(AtLeast2AreTrue(b1, b2, b3, b4, b5))
            {
                // do stuff
            }
        }

        private bool AtLeast2AreTrue(params bool[] values)
        {
            int trueCount = 0;
            for(int index = 0; index < values.Length || trueCount >= 2; index++)
            {
                if(values[index])
                    trueCount++;
            }

            return trueCount > 2;

        }

if (NumberOfTrue(new List<bool> { bool1, bool2, bool3, bool4 }) >= 2)
{
    // do stuff
}

int NumberOfTrue(IEnumerable<bool> bools)
{
    return bools.Count(b => b);
}

Не зовсім красиво ... але ось ще один спосіб зробити це:

if (
    (a && (b || c || d || e)) ||
    (b && (c || d || e)) ||
    (c && (d || e)) ||
    (d && e)
)

У мене зараз набагато кращий і дуже короткий!

bool[] bools = { b1, b2, b3, b4, b5 };
if (bools.Where(x => x).Count() > 1)
{
   //do stuff
}

Я хотів дати варіатичну відповідь на шаблон C ++ 11.

template< typename T>
T countBool(T v)
{
    return v;
}

template< typename T, typename... Args>
int countBool(T first, Args... args)
{
    int boolCount = 0;
    if ( first )
        boolCount++;
    boolCount += countBool( args... );
    return boolCount;
}

просто називаючи це наступним чином, створюється досить елегантний метод підрахунку кількості випусків.

if ( countBool( bool1, bool2, bool3 ) > 1 )
{
  ....
}

У більшості мов true є еквівалентом ненульового значення, тоді як false - нуль. Я не маю точного синтаксису для вас, але в псевдокоді, як щодо:

if ((bool1 * 1) + (bool2 * 1) + (bool3 * 1) > 2)
{
    //statements here
}

Якщо у вас є лише п’ять різних значень, ви можете легко виконати тест, упакувавши біти в шорт або int і перевіривши, чи є це будь-яка з нульових або однобітових відповідей. Єдиними недійсними номерами, які ви могли б отримати, були б ..

0x 0000 0000 
0x 0000 0001
0x 0000 0010
0x 0000 0100
0x 0000 1000
0x 0001 0000

Це дає вам шість значень для пошуку, помістіть їх у таблицю пошуку, і якщо їх там немає, у вас є відповідь.

Це дає вам просту відповідь.

   загальнодоступний статичний boolean moreThan1BitSet (int b)
   {
      остаточний короткий multiBitLookup [] = { 
            1, 1, 1, 0, 1, 0, 0, 0,
            1, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0,
            1, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0
      };
      якщо (multiBitLookup [b] == 1)
         повернути false;
      повернути істинно;
   }

Це не значно перевищує 8 біт, але у вас є лише п’ять.

if ((b1.CompareTo (false) + b2.CompareTo (false) + b3.CompareTo (false) + ...)> 1)

// Більше одного з них є істинними

...

ще

...

Ви згадали

Цікавий варіант - зберегти логічні значення в байті, зробити правильний зсув і порівняти з вихідним байтом. Щось на зразокif (myByte && (myByte >> 1))

Я не думаю, що вираз дасть вам бажаний результат (принаймні, використовуючи семантику C, оскільки вираз не є дійсним C #):

Якщо (myByte == 0x08), тоді вираз поверне true, хоча існує лише один біт.

Якщо ви мали на увазі " if (myByte & (myByte >> 1))", тоді якщо (myByte == 0x0a)вираз поверне false, навіть якщо встановлено 2 біти.

Але ось кілька методів підрахунку кількості бітів у слові:

Bit Twiddling Hacks - підрахунок біт

Варіацією, яку ви можете розглянути, є використання методу підрахунку Кернігана, але надайте допомогу рано, оскільки вам потрібно лише знати, чи встановлено кілька бітів:

int moreThanOneBitSet( unsigned int v)
{
    unsigned int c; // c accumulates the total bits set in v

    for (c = 0; v && (c <= 1); c++)
    {
      v &= v - 1; // clear the least significant bit set
    }

    return (c > 1);
}

Звичайно, використання таблиці пошуку також не поганий варіант.

Нещодавно у мене була та сама проблема, де у мене було три логічні значення, які мені потрібно було перевірити, чи одночасно відповідало лише 1 з них. Для цього я використав оператор xor наступним чином:

bool a = true;
bool b = true;
bool c = false;

if (a || b || c)
{
    if (a ^ b ^ c){
        //Throw Error
    }
}

Цей код видасть помилку, оскільки і a, і b є істинними.

Для довідки: http://www.dotnetperls.com/xor

Я тільки що знайшов оператор xor в C #, якщо хтось знає про якісь падіння цієї стратегії, будь ласка, повідомте мене.