Таблица истинности

a+b=0

a->b=1

(x1 - x2) * (x2 - x3) * (x3 - x4) = 1

#include <stdio.h>
#include <stdbool.h>
 
/* Функция, проверяющая наше уравнение. Если равенство верно —
   возвращается истина, иначе — ложь. */
bool f(bool a, bool b, bool c, bool d) {
    return (a + b + c + d) == 0;
}
 
int main(void) {
    /* Счетчик кол-ва решений. */
    size_t counter = 0;
 
    /* Четыремя циклами мы добьемся проверкой всех возможных
       комбинаций значений переменных. В общем случае кол-во
       циклов должно равнятся кол-ву переменных. */
    for (unsigned a = 0; a != 2; a++)
        for (unsigned b = 0; b != 2; b++)
            for (unsigned c = 0; c != 2; c++)
                for (unsigned d = 0; d != 2; d++)
                    /* Если равенство верно, увеличиваем счетчик. */
                    if (f(a, b, c, d))
                        counter++;
 
    printf("%zu\n", counter);
}

#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
 
/* Не стоит использовать библиотечную функцию pow в целочисленных вычислениях,
   т. к. функция pow(a, b) — это фактически exp(a * log(b)). Так что
   мы напишем нашу собственную целочисленную реализацию.
   Можете не обращать на нее внимания. */
unsigned pw(unsigned a, unsigned n) {
    if (n == 0)
        return 1;
 
    unsigned res = a;
 
    while (--n)
        res *= a;
 
    return res;
}
 
/* Функция возвращает значение выражения a_0 + a_1 + … + a_vars_nm.
 
   Как это работает: переменная n содержит 32 бита. Каждый бит считается
   значением одной логической переменной a (т. е. максимально кол-во переменных
   в выражении — 32).
 
   В цикле мы проходим по каждому биту числа n (т. е. по каждой логической переменной
   и прибавляем значение этого бита (лог. переменной) к переменной result.
 
   Я специально выбрал простейшее выражение, чтобы не усложнять код.
   Вы можете вычленить биты из числа и занести их в какой-нибудь массив,
   а затем вызвать свою функцию проверки значения выражения (я не знаю,
   как вы парсите это выражение).
   */
bool f(uint32_t n, size_t vars_nm) {
    /* Кол-во переменных не может быть больше 32-х,
       иначе они просто не поместятся в uint32_t. */
    assert(vars_nm <= 32);
 
    bool result = 0;
 
    while (vars_nm--) {
        /* n & 1 — это значение текущего младшего бита переменной n (т. е. значение
           одной из логических переменных. */
        result += n & 1;
        n >>= 1;
    }
 
    return result == 1;
}
 
/* Для примера вычисляем кол-во решений уравнения a + b + c = 1. */
int main(void) {
    /* Счетчик справедливых равенств. */
    size_t counter = 0;
    /* Кол-во переменных в равенстве. */
    size_t const vars_nm = 3;
 
    /* Здесь самое интересное: 
                                                 abc
       i = 0 = 00000000 00000000 00000000 00000|000
       i = 1 = 00000000 00000000 00000000 00000|001
       i = 2 = 00000000 00000000 00000000 00000|010
       i = 3 = 00000000 00000000 00000000 00000|011
       i = 4 = 00000000 00000000 00000000 00000|100
       i = 5 = 00000000 00000000 00000000 00000|101
       i = 6 = 00000000 00000000 00000000 00000|110
       i = 7 = 00000000 00000000 00000000 00000|111
       *КОНЕЦ ЦИКЛА*
        
       Происходит перебор всех возможных комбинаций значений
       переменных (не забудьте, что одна переменная — это один бит числа i).
 
       Обратите внимание, что я отделил младшие три бита в таблице. Это и есть
       три наших переменных в выражении (см. переменную vars_nm).
 
       В функции f эти три бита будут использоваться для вычисления
       значения выражения.
 
       Для чего нужно pw(2, vars_nm)? Нам нужно ограничить кол-во повторений
       цикла степенью двойки. Например, 2^3 даст нам 3 значащих бита.
       */
    for (uint32_t i = 0; i < pw(2, vars_nm); i++)
        /* Если равенство верно, увеличиваем счетчик. */
        if (f(i, vars_nm))
            counter++;
 
    printf("%zu\n", counter);
}