Выполнять действие только в том случае, если условие выполняется во всех итерациях цикла

Есть ли способ инициировать действие только при выполнении условия в всех итерациях цикла for?

Пример:

if ((i % 1 == 0) && (i % 2 == 0) && (...) && (i % 20 == 0))
{
    Do action x
}

Это то, что я пробовал, но он не работал должным образом:

for (int b=1; b<21; b++)
{
    if (i % b == 0)
    {
        // Do something
    }
}

Ответ 1

Существует классическое решение:

var flag = true;
for(int b = 2; b < 21; b++)
{
     if (i % b != 0)
     {
         flag = false;
         break;
     }
}
if(flag)
   SomeAction():

Сначала предположим, что выполнены все условия (петли): var flag = true. Если хотя бы одно условие не выполняется: if (i % b != 0), мы останавливаем процесс циклизации: break;, потому что нет необходимости продолжать проверку и установить flag = false, теперь через переменную flag мы знаем результат нашей проверки и может использовать его позже, чтобы определить, следует ли нам называть SomeAction() или нет.

Ответ 2

Вы также можете использовать простой запрос LINQ, подобный этому:

if (Enumerable.Range(1, 20).All(b => i % b == 0))
    DoAction();

Ответ 3

Как насчет просто:

if (i % 232792560 == 0) {
    // do action
}

Если вы хотите проверить, что ваш номер делится на множество номеров, это эквивалентно проверке того, делится ли ваш номер на наименьшее общее число кратных всех этих чисел. В этом случае 2 ⁴ * 3 ² * 5 * 7 * 11 * 13 * 17 * 19.

Ответ 4

Итак, вы хотите связать несколько очень похожих булевых выражений, не записывая их явно.

if ((i % 1 == 0) && (i % 2 == 0) && (...) && (i % 20 == 0))
{
    do action x
}

Первое, что вы могли бы сделать, - извлечь комбинированное выражение, используемое в операторе if, в новую функцию. Это делает ваш код более удобочитаемым.

public static void Main()
{
    // ...

    if (DivisibleByAllUpTo20(i))
    {
        //do action x
    }

    // ...
}

private static bool DivisibleByAllUpTo20(int i)
{
    return (i % 1 == 0) && (i % 2 == 0) && (...) && (i % 20 == 0);
}

DivisibleByAllUpTo20() может быть реализован с помощью цикла for, как вы пробовали.

private static bool DivisibleByAllUpTo20(int i)
{
    for (int b = 1; b < 21; b++)
    {
        if (i % b != 0)
            return false;
    }

    return true;
}

Кстати: пространство имен LINQ предоставляет множество вспомогательных методов, которые позволяют писать такой код гораздо более сжато и чище:

using System.Linq;

// ...

if (Enumerable.Range(1, 20).All(n => n % i == 0))
{
    // do action x
}

Ответ 5

Легко:

bool isDividable = true;
for(int b=1; b<21; b++)
{
     if (i % b != 0)
     {
         isDividable = false;
         break;
     }
}

if(isDividable) do something

Ответ 6

bool flag = true;
for(int b=1; b < 21 && (flag &= (i % b == 0)) ; b++)
    ;
if(flag)
   do_action();//do your task

Ответ 7

bool action = true;
for(int b=1;b<21;b++)
{
     if (i % b != 0)
           {
               action = false;
               break;
           } 
}

После этого:

if (action)
{
// do your action 
}

Надеюсь, что это помогло.:)

Ответ 8

Вы можете написать это так:

bool doAction = true;
for(int b=1;b<21;b++)
{
  if (!(i % b == 0))
    {
      doAction = false;
    } 
}
if (doAction)
{
  do action x;
}

Это устанавливает bool в false, когда одно условие является ложным, поэтому оно выполняется только do action x;, когда все условия истинны.

Вы также можете сделать это в меньших строках с Linq:

var divisors = Enumerable.Range(1, 20);
if(divisors.All(div => i % div == 0))
{
  //do someting
}

Объяснение: Enumerable.Range возвращает массив со значениями от 1 до 20 и .All проверяет выражение Lambda для каждого объекта.

Ответ 9

Здесь имеется довольно много похожих ответов, в которых используется флаг. Более простым решением является использование переменной цикла (b в вашем вопросе) в качестве условия для проверки:

int b;
int max = 20;

for (b = 1; b <= max && i % b == 0; ++b) ;

if (b > max) {
    // do something
}