Я хочу найти бинарные операции, которые преобразуют вход в выход - PullRequest
Новая
       14

Я хочу найти бинарные операции, которые преобразуют вход в выход

1 голос
/ 05 августа 2011

Учитывая вход и выход: 

Input     Output
10011100  10010100
10000100  00000000
11111100  10000100
10000011  00000011
10100010  10100010

Есть ли какие-либо операции, которые можно выполнить над строками / столбцами для получения результата? Например, моя лучшая попытка была

((Y И НЕ Y-1) XOR (Y И НЕ Y + 1)) ИЛИ ((X И НЕ X-1) XOR (X И НЕ X + 1))

Если строки / столбца не существует, предполагается, что они ложные. Демонстрация моей попытки:

Для Y: 

(Y AND NOT Y-1) XOR (Y AND NOT Y+1) =
10011100            00011000         10000100
00000000            00000000         00000000
01111000            01111100         00000100
00000011            00000001         00000010
00100000            10100010         10000010

Для X: 

(X AND NOT X-1) XOR (X AND NOT X+1) =
10010000            10000100         00010100
10000100            10000100         00000000
10000000            00000100         10000100
10000010            10000001         00000011
10100010            10100010         00000000

ИЛИ эти 2 результата: 

((Y AND NOT Y-1) XOR (Y AND NOT Y+1)) OR ((X AND NOT X-1) XOR (X AND NOT X+1))
10010100
00000000
10000100
00000011
10000010

Как вы можете видеть, он почти идентичен выводу, но COL 3, ROW 5 - это 0, а не 1. Можно ли как-нибудь сделать другую операцию, чтобы учесть этот бит?

Заранее спасибо.

1 Ответ

1 голос
/ 05 августа 2011

Я использую следующие обозначения для положения битов.

 B
CAD
 E

Это дает мне 2 ^ 5 возможностей (32), которые я записываю.Я нашел 3 случая из всех возможностей, где A равно 1, но выходной результат должен быть 0. Я мог записать таблицу Карно, но, поскольку у меня есть только 3, я выполняю прямую функцию:

IsZero = (! A | ((B & A & E &! C &! D) | (C & A & D &! E &! B) | (A & B & C & D & E)))

Если вам нужен IsOne, это просто! IsZero.

C # код, чтобы проверить это следующим образом: 

class Program
{
    static void PrintFunction(int[,] myArray, int yMax, int xMax)
    {
        for (int y = 0; y < yMax; y++)
        {
            for (int x = 0; x < xMax; x++)
            {
                Console.Write(myArray[y, x]);
            }
            Console.WriteLine();
        }
    }

    static bool A(int x, int y) { if (Input[y, x] == 1) return true; else return false; }
    static bool B(int x, int y) { try { if (Input[y - 1, x] == 1) return true; else return false; } catch { return false; } }
    static bool C(int x, int y) { try { if (Input[y, x - 1] == 1) return true; else return false; } catch { return false; } }
    static bool D(int x, int y) { try { if (Input[y, x + 1] == 1) return true; else return false; } catch { return false; } }
    static bool E(int x, int y) { try { if (Input[y + 1, x] == 1) return true; else return false; } catch { return false; } }

    static int[,] Input = { { 1,0,0,1,1,1,0,0 }, {1,0,0,0,0,1,0,0}, { 1,1,1,1,1,1,0,0  }, {1,0,0,0,0,0,1,1} , {1,0,1,0,0,0,1,0} };
    static int[,] OutputVH = new int[5, 8];
    static int[,] Solution = { { 1,0,0,1,0,1,0,0}, { 0,0,0,0,0,0,0,0}, { 1,0,0,0,0,1,0,0}, { 0,0,0,0,0,0,1,1} , {1,0,1,0,0,0,1,0} };
    static int xMax = 8;
    static int yMax = 5;

    static void Main(string[] args)
    {
        Console.WriteLine("Both Filterings");
        for (int y = 0; y < yMax; y++)
        {
            for (int x = 0; x < xMax; x++)
            {
                bool isZero = (!A(x, y) | ((B(x, y) & A(x, y) & E(x, y) & !C(x,y) & !D(x,y)) | (C(x, y) & A(x, y) & D(x, y) & !E(x,y) & !B(x,y)) | (A(x, y) & B(x, y) & C(x, y) & D(x, y) & E(x, y))));
                OutputVH[y, x] = (isZero ? 0 : 1); 
            }
        }
        PrintFunction(OutputVH, yMax, xMax);
        bool SolutionFound = true;
        for (int y = 0; y < yMax; y++)
            for (int x = 0; x < xMax; x++)
                if (OutputVH[y, x] != Solution[y, x]) SolutionFound = false;
        if (SolutionFound) Console.WriteLine("Found solution!");
    }
}

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

...