Можно ли упростить этот алгоритм?

Я добавил это как комментарий к ответу nickf, но думал, что предложу его как ответ на своем собственном. Хорошие ответы все, кажется, изменение его, включая мой. Но так как мы не в зависимости от компилятора для оптимизации (если бы OP были, мы даже не сделали бы этого), тогда кипятящий это по сравнению с 3 ANDs к следующим средствам, что будут значения, где только 2 из этих 3 частей должны будут быть оценены. И если бы это делается в сценарии, это имело бы значение в противоположность скомпилированному коду.

(a != 1) && ((b > (a + p + 1)) || (b == (a + p))))

На основе комментария, я собираюсь добавить этот wrt этот являющийся лучше, чем И версия:

я предполагаю, что это зависит от того, больше ли Ваш истинный набор данных результатов, чем 50 процентов входных наборов. Чем чаще вход верен, тем лучше мое изменение будет. Так, с этим уравнением это похоже, И стиль будет лучше (по крайней мере, для моего набора входных данных 0-500).

Хорошо

((b - (a + p) == 0) || (b - (a + p) > 1))

Would be better writen as:
(b - (a + p) >= 0)  

Applying this to the whole string you get:

((a+p) <= b) && (a > 1) && (b >= p)) && (b - (a + p) >= 0) 


(a + p) <= b is the same thing as b - (a + p) >= 0

, Таким образом, можно избавиться от того отъезда:

((a+p) <= b) && (a > 1) && (b >= p)) 

// In one line:
return (a != 1) && ((b-a-p == 0) || (b-a-p > 1))

// Expanded for the compiler:
if(a == 1)
    return false;

int bap = b - a - p;

return (bap == 0) || (bap > 1);

при регистрации процессора Вы используете, я могу оптимизировать для блока. =]

Это столь просто, как я мог получить его.

def calc(a, b, p):
    if (a != 1):
        temp = a - b + p
        if temp == 0 or temp < -1:
            return True
    return False

Это могло также быть записано как:

def calc(a, b, p):
    temp = a - b + p
    return a != 1 and (temp == 0 or temp < -1)

Или как:

def calc(a, b, p):
    temp = a - b + p
    return a != 1 and temp <= 0 and temp != -1

Протестированный с a, b, p от 0 до 10 000:

a != 1 && a != (b-p-1) && a <= (b-p);

я думаю, что это может быть упрощено еще больше.

bap = b - (a + p)
bap >= 0 && bap != 1 && a != 1

РЕДАКТИРОВАНИЕ: Теперь я имею-2 для честной попытки выручения и также для того, что, кажется, мне действительный ответ. Для Вас, кто может использовать Python, вот две функции, один с вопросом и один с моим ответом:

def question(a, b, p):
    return (((a+p) <= b) and (a == 0 or a > 1) and (b >= p)) or ((b - (a + p) == 0) or (b - (a + p) > 1))

def answer(a, b, p):
    bap = b - (a + p)
    return bap >= 0 and bap != 1 and a != 1

s = a + p
b >= s && a != 1 && b - s - 1 > 0

Проверено, возвращает то же логическое значение, что и вопрос.

Программа, которую я использовал для проверки: (весело писал ее)

#include <iostream>
using namespace std;

typedef unsigned int uint;

bool condition(uint a, uint b, uint p)
{
        uint s = a + p;
        return uint(    b >= s && a != 1 && b - s - 1 > 0    )
        == uint(    (((a+p) <= b) && (a == 0 || a > 1) && (b >= p))
                 && ((b - (a + p) == 0) || (b - (a + p) > 1))    );
}

void main()
{
    uint i = 0;
    uint j = 0;
    uint k = 0;

    const uint max = 50;

    for (uint i = 0; i <= max; ++i)
        for (uint j = 0; j <= max; ++j)
            for (uint k = 0; k <= max; ++k)
                if (condition(i, j, k) == false)
                {
                    cout << "Fails on a = " << i << ", b = " << j;
                    cout << ", p = " << k << endl;

                    int wait = 0;
                    cin >> wait;
                }
}

Так как ints не подписаны, (== 0 || a> 1) может быть заменен (a! =1).

С первой передачей, можно уменьшить его до этого:

uint sum = a + p;
return ((sum <= b) && (a != 1) && (b >= p)) && (b - sum != 1);

кроме того, это было бы намного более читаемо, если бы Вы смогли дать больше понятных имен переменным. Например, если бы a и p были давлениями, то a+p мог быть substitued как PressureSum.

Поскольку все они являются положительными целыми числами, большая часть повторений может быть удалена:

Таким образом, в качестве первого шага

(((a+p) <= b) && (a == 0 || a > 1) && (b >= p)) && ((b - (a + p) == 0) || (b - (a + p) > 1))

становится

((a+p) <= b) && (a != 1) && (b >= p)) && ((b - (a + p) != 1) 

Для для ясности, это просто замена паттерна (foo == 0 || foo > 1) на foo != 1

Этот паттерн появляется дважды выше, один раз с foo = a и один раз с foo = (b - (a+p))

Я не сделал бы всей математики в том выражении. Такой, поскольку b - (+ p) оценен дважды. Если возможно, разделяет их на переменные вместо этого.

кроме того, пишущий полировку notiation дерево мог бы помочь Вам оптимизировать его, все, что Вы видите дважды, может быть снова использован.

(a!=1) && ((b==a+p) || (b>1+a+p))

Это может быть не самое простое, но должно быть одним из самых читаемых.

b >= p && b != p+1

РЕДАКТИРОВАНИЕ: хорошо, который не работал, но этот делает:

a != 1 && b >= a+p && b-a-p != 1

Рефакторинг для простоты, введя больше локальных переменных, которые указывают значение каждого выражения. Это трудно для нас, не имея представления о том, что означают a, b и p.

Если формула работает, и произойдите из своих бизнес-правил нет никакой реальной потребности упростить ее. Компилятор, вероятно, знает лучше, чем мы как к оптимизации формулы.

единственная вещь, которую необходимо сделать, использовать лучшие имена переменных, которые отражают бизнес-логику.

Остерегаются применения любого предлагаемого решения перед поблочным тестированием их.

jjngy здесь имеет его правильный. Вот доказательство, что его упрощенная формула эквивалентна исходному использованию Помощник Доказательства Coq .

Require Import Arith.
Require Import Omega.

Lemma eq : forall (a b p:nat),
(((a+p) <= b) /\ ((a = 0) \/ (a > 1)) /\ (b >= p)) /\ 
    ((b - (a + p) = 0) \/ (b - (a + p) > 1)) <-> 
((a + p <= b) /\ ~ (a= 1) /\ ~ (b - a - p = 1)).
Proof. intros; omega. Qed.

мои извинения за ошибку в исходной деривации. Это - то, что происходит, когда Вы не беспокоитесь к модульному тесту после рефакторинга!

исправленная деривация следует, в форме тестовой программы.

Короткий ответ:

((a > 1) && (skeet == 0)) || ((a > 1) && (jon > 0) && (skeet < -1));

где

jon = (b - p)
skeet = (a - jon);

class Program
{
    static void Main(string[] args)
    {
        bool ok = true;
        for (int a = 1; a < 100; a++)
        {
            Console.Write(a.ToString());
            Console.Write("...");

            for (int b = 1; b < 100; b++)
            {
                for (int p = 1; p < 100; p++)
                {
                    bool[] results = testFunctions(a, b, p);
                    if (!allSame(results))
                    {
                        Console.WriteLine(string.Format(
                            "Fails for {0},{1},{2}", a, b, p));
                        for (int i = 1; i <= results.Length; i++)
                        {
                            Console.WriteLine(i.ToString() + ": " + 
                                results[i-1].ToString());
                        }

                        ok = false;
                        break;
                    }
                }
                if (!ok) { break; }
            }
            if (!ok) { break; }
        }
        if (ok) { Console.WriteLine("Success"); }
        else { Console.WriteLine("Failed!"); }
        Console.ReadKey();
    }

    public static bool allSame(bool[] vals)
    {
        bool firstValue = vals[0];
        for (int i = 1; i < vals.Length; i++)
        {
            if (vals[i] != firstValue)
            {
                return false;
            }
        }
        return true;
    }

    public static bool[] testFunctions(int a, int b, int p)
    {
        bool [] results = new bool[16];

        //given: all values are positive integers
        if (a<=0 || b<=0 || p<=0)
        {
            throw new Exception("All inputs must be positive integers!");
        }

        //[1] original expression
        results[0] = (((a+p) <= b) && (a == 0 || a > 1) && (b >= p)) && 
            ((b - (a + p) == 0) || (b - (a + p) > 1));

        //[2] a==0 cannot be true since a is a positive integer
        results[1] = (((a+p) <= b) && (a > 1) && (b >= p)) && 
            ((b - (a + p) == 0) || (b - (a + p) > 1));

        //[3] rewrite (b >= p) && ((a+p) <= b) 
        results[2] = (b >= p) && (b >= (a+p)) && (a > 1) && 
            ((b - (a + p) == 0) || (b - (a + p) > 1));

        //[4] since a is positive, (b>=p) guarantees (b>=(p+a)) so we 
        //can drop the latter term
        results[3] = (b >= p) && (a > 1) && 
            ((b - (a + p) == 0) || (b - (a + p) > 1));

        //[5] separate the two cases b>=p and b=p
        results[4] = ((b==p) && (a > 1) && ((b - (a + p) == 0) || 
            (b - (a + p) > 1))) || ((b > p) && (a > 1) && 
            ((b - (a + p) == 0) || (b - (a + p) > 1)));

        //[6] rewrite the first case to eliminate p (since b=p 
        //in that case)
        results[5] = ((b==p) && (a > 1) && ((-a == 0) || 
            (-a > 1))) || ((b > p) && (a > 1) && 
            (((b - a - p) == 0) || ((b - a - p) > 1)));

        //[7] since a>0, neither (-a=0) nor (-a>1) can be true, 
        //so the case when b=p is always false
        results[6] = (b > p) && (a > 1) && (((b - a - p) == 0) || 
            ((b - a - p) > 1));

        //[8] rewrite (b>p) as ((b-p)>0) and reorder the subtractions
        results[7] = ((b - p) > 0) && (a > 1) && (((b - p - a) == 0) || 
            ((b - p - a) > 1));

        //[9] define (b - p) as N temporarily
        int N = (b - p);
        results[8] = (N > 0) && (a > 1) && (((N - a) == 0) || ((N - a) > 1));

        //[10] rewrite the disjunction to isolate a
        results[9] = (N > 0) && (a > 1) && ((a == N) || (a < (N - 1)));

        //[11] expand the disjunction
        results[10] = ((N > 0) && (a > 1) && (a == N)) ||
            ((N > 0) && (a > 1) && (a < (N - 1)));

        //[12] since (a = N) in the first subexpression we can simplify to
        results[11] = ((a == N) && (a > 1)) || 
            ((N > 0) && (a > 1) && (a < (N - 1)));

        //[13] extract common term (a > 1) and replace N with (b - p)
        results[12] = (a > 1) && ((a == (b - p)) || 
            (((b - p) > 0) && (a < (b - p - 1))));

        //[14] extract common term (a > 1) and replace N with (b - p)
        results[13] = (a > 1) && (((a - b + p) == 0) || 
            (((b - p) > 0) && ((a - b + p) < -1)));

        //[15] replace redundant subterms with intermediate 
        //variables (to make Jon Skeet happy)
        int jon = (b - p);
        int skeet = (a - jon);   //(a - b + p) = (a - (b - p))
        results[14] = (a > 1) && ((skeet == 0) || 
            ((jon > 0) && (skeet < -1)));

        //[16] rewrite in disjunctive normal form
        results[15] = ((a > 1) && (skeet == 0)) || 
            ((a > 1) && (jon > 0) && (skeet < -1));

        return results;
    }
}