Как реализовать матрицу решений в c#

Я бы использовал 2D-массив (Dictionary<TKey, TValue> в нашем случае)bool? - записку ? для Nullable<bool> что позволяет 3 состояния: true, false и null. Ваш null может представлять собой "no effect"...

массива:

var myArray = new Dictionary<char, Dictionary<int, bool?>>();

тогда вы могли бы делать такие вещи, как:

bool result = false;
foreach (var inputPair in input)
{
    // Assuming inputPair is KeyValuePair<char, int>
    result |= myArray[inputPair.Key][inputPair.Value];
}

return result;

вот как я бы это сделал, с моей любовью к LINQ.

во-первых, ваши матрицы являются IEnumerable<IEnumerable<bool?>> и true означает 1, false 0 и null неопределено.

затем вы передаете IEnumerable<bool> который вы хотите проверить. Вот функция:

public IEnumerable<bool?> DecisionMatrix(this IEnumerable<bool> source, IEnumerable<IEnumerable<bool?>> options)
{
    IList<bool> sourceList = source.ToList();
    return options.Where(n => n.Count() == sourceList.Count)
        .Select(n => n.Select((x, i) => new {Value = x, Index = i}))
        .Where(x => 
            x.All(n => !(sourceList[n.Index] ^ n.Value ?? sourceList[n.Index])))
        .FirstOrDefault();
}

(это метод расширения, поместите его в static class :))

вы можете иметь класс решения, представленный двумя байтовыми полями. Первый байт будет указывать, какие условия являются истинными или ложными. Второй байт будет указывать, какие условия являются релевантными. Кроме того, можно определить функцию, которая определяет, соответствует ли входной байт объекту.

из этого вы можете создать класс matrix, который обертывает список решений, а затем использует LINQ для поиска в списке решения, соответствующего вашему вводу.

вы можете иметь вас Решение класса, как это

class Decision
{
    byte Conditions;
    byte RelevantConditions;

    bool IsMatch(byte input)
    {
        byte unmatchedBits = input ^ Conditions; //matching conditions are set to 0
        unmatchedBits &= RelevantConditions; //Irrelevant conditions set to 0
        return (unmatchedBits == 0); //if any bit is 1, then the input does not match the relevant conditions
    }
}

Итак, объект для Decision01 можно определить как

Decision decision01 = new Decision()
{
    Conditions         = 0x55; //01010101 in binary
    RelevantConditions = 0xdd; //11011101 in binary
}

тогда ваш класс матрицы решений может быть сделан следующим образом

class DecisionMatrix
{
    List<Decision> decisions;

    Decision Find(byte input)
    {
        return decisions.Find(d => d.IsMatch(input));
    }
}

Это также может помочь сделать входной класс, который обертывает байт. При создании экземпляра входного объекта с полями A-H создается байт, соответствующий этим полям.

вы можете реализовать матрицу решений в виде словаря, как показано ниже, и запросить матрицу для поиска соответствия. Я использовал строку.join для преобразования массива в строку. Также использовали '-' в матрице как регулярное выражение [0/1].

Dictionary<string, char[]> myMatrix = new Dictionary<string, char[]>();
myMatrix.Add("Decision01", new char[] { '0', '1', '-', '1', '0', '1', '-', '1' });
myMatrix.Add("Decision02", new char[] { '1', '0', '-', '0', '0', '-', '1', '-' });
myMatrix.Add("Decision03", new char[] { '1', '1', '1', '0', '0', '1', '1', '1' });

char[] input = new char[] { '1', '0', '1', '0', '0', '1', '1', '1' };
var decision = (from match in myMatrix
            where Regex.IsMatch(string.Join(string.Empty, input), 
                string.Join(string.Empty, match.Value).ToString().Replace("-", "[0|1]"), 
                RegexOptions.IgnoreCase)
            select match.Key).FirstOrDefault();

Console.WriteLine(decision);

вы можете сделать это в пару строк и создать двоичный калькулятор. Поэтому в приведенном ниже примере результаты = 182, чем решение D (или то, что каждый). Ниже, линии вверх с вашими решениями и результатами все будут различными итогами.

вот веб-сайт, который идет через двоичный файл [http://electronicsclub.info/counting.htm] спасибо google.

например 10110110 в двоичном коде равно 182 в десятичном: Цифровое значение: 128 64 32 16 8 4 2 1
Двоичное число: 1 0 1 1 0 1 1 0
Десятичное значение: 128 + 0 + 32 + 16 + 0 + 4 + 2 + 0 = 182