C++ 向量減法

Question

我一直在嘗試讓我的矢量計算器減去。 對於存儲相同數量的數字的向量，它做得很好，例如： (+) 503 - (-) 305 。 在這種情況下，它會給我一個很好的結果。

但是當我嘗試減去不同大小的向量時，問題就出現了。 我試圖通過制作不同的過濾器來解決這個問題，以使程序按照我的意願行事。 但是現在，它所做的不是減去它所做的就是添加。

這是我的設置：

const int MAX = 102;

typedef int vector[MAX];

A(0)：將一個向量的所有值都設為 0。例如：

使用前：

[0][3][5][0][5]

其中第一個 0 表示它是一個正數，如果它是 [1] 則表示它的負數，那 [3] 表示向量中存儲了 3 個數字。

使用 A0 后：

[0][1][0][0][0][0][0]...[0]

ES_MAJOR_VECTOR 檢查向量 Z > X。在這種情況下返回 true，否則返回 false。

SUMA_VEC 基本上將 Z 添加到 X，然后將值分配給 W。

void RESTA_VEC(vector Z, vector X, vector W) {

    int ZigualX(0), Xmes1(0), Xactual(0), ZmajorX(0), XmajorZ(0), contador(0);
    vector copia_Z, copia_X;

    A0(copia_Z);
    A0(copia_X);

    for (int k = 0; k < MAX; k++)
    {
        copia_Z[k] = Z[k];
        copia_X[k] = X[k];
    }

    if (Z[0] == X[0])
    {
        if (Z[0] == 0)
        {
            for (int y = MAX; y >= 2; y--)
            {
                if (Z[y] < X[y])
                {//RESTA
                    Z[y] = Z[y] + 10;
                    W[y] = Z[y] - X[y];
                    X[y + 1] = X[y + 1] + 1;
                }

                if (Z[y] > X[y])
                {
                    W[y] = Z[y] - X[y];
                }

                if (Z[y] == X[y])
                {
                    W[y] = 0;
                }
            }
        }

        if (Z[0] == 1)
        {
            SUMA_VEC(Z, X, W);
        }
    }
    
    if (Z[0] != X[0])
    {
        if (ES_MAJOR_VECTOR(Z, X) == true)
        {
            for (int y = MAX; y >= 2; y--)
            {
                if (Z[y] < X[y])
                {
                    Z[y] = Z[y] + 10;
                    W[y] = Z[y] - X[y];
                    X[y + 1] = X[y + 1] + 1;
                }

                if (Z[y] > X[y])
                {
                    W[y] = Z[y] - X[y];
                }

                if (Z[y] == X[y])
                {
                    W[y] = 0;
                }
            }
        }
        else
        {
            for (int y = MAX; y >= 2; y--)
            {
                if (X[y] < Z[y])
                {
                    X[y] = X[y] + 10;
                    W[y] = X[y] - Z[y];
                    Z[y + 1] = Z[y + 1] + 1;
                }

                if (X[y] > Z[y])
                {
                    W[y] = X[y] - Z[y];
                }

                if (X[y] == Z[y])
                {
                    W[y] = 0;
                }
            }
        }
    }

    for (int h = 0; h < MAX; h++)
    {
        Z[h] = copia_Z[h];
        X[h] = copia_X[h];
    }
}

我該如何解決這個問題？ 我認為我需要檢查：如果它們是正數或負數，如果它們都是正數，我必須執行減法，如果它們是負數，我必須將 Z 添加到 X 並將其分配給 W。

如果向量不同（意味着一個是正的，另一個是負的）我必須檢查哪個更大，做減法，然后根據前面使用的兩個向量中的較大向量分配 0 或 1。

例如：

+5050
-305

W[0] = +

-5050
+305

W[0] = -

Answer 1

在得到一位非常友善的用戶的幫助后，我可以得出以下結論：

void RESTA_ABS(vector Z, vector X, vector W) {

    int error(0);

    A0(W);
        
    if (ES_MAJOR_VECTOR(Z,X))
    {
        for (int i = MAX-1; i >= 2; i--)
        {
            if (Z[i] < X[i]) {

                Z[i] = Z[i] + 10;
                W[i] = Z[i] - X[i];
                X[i - 1] = X[i - 1] + 1;
            }           
            else
            {
                W[i] = Z[i] - X[i];
            }
        }
    }
    else
    {
        cout << "ERROR - VECTOR 2 > VECTOR 1" << endl;
    }
}

這個模塊不介意向量是正的還是負的。 它只是做減法。

所以，為了解決這個問題，我使用了另一個模塊：

無效RESTA_VEC（向量Z，向量X，向量W）{

if (X[0] == 0)
{
    X[0] = 1;
}
else
{
    X[0] = 0;
}

RESTA_ABS(Z, X, W);

if (ES_MAJOR_VECTOR(Z, X) == true)
    {
        W[0] = Z[0];
    }
    else
    {
        W[0] = X[0];
    }

}

這個改變了第二個向量的數字符號，如果它是正則使其為負，如果它為負則為正。 （這由第一個向量位置上的 0 或 1 決定）。

最后，它所做的是檢查更大向量的符號並將其分配給 output 向量 W。

剩下的唯一部分是檢查兩個向量中的哪個更大，因為當我測試它時，在某些情況下，它會給我一個錯誤的答案。

例如：

[+][9][1][2][3][4][5][6][7][8][9]
[+][9][1][1][2][3][4][5][6][7][8]

會給：

[+][8][1][1][1][1][1][1][1][1]

但它不會進行操作，因為它認為第二個向量更大。

翻譯：Z是否大於X？

bool ES_MAJOR_VECTOR_SIGNE(vector Z, vector X) {

    int END(0), UP(2);

    return false;

    if (Z[1] > X[1])
    {
        return true;
    }
    else
    {
        while (END != 1)
        {
            if (Z[UP] > X[UP])
            {
                return true;
                END = 1;
            }

            UP++;
        }
    }
}