Question

我想编写一个包含4个数字的程序，例如（a，b，c和d），并检查是否使用算术运算符我可以使前3个数字的结果变为第4个数字，例如输入是否为（3 ，4，5，23）这将签出true，因为 3 + 4 * 5 = 23，所以我想创建一个包含运算符的数组，并使用循环检查每个可能的组合，希望我明确说明。

编辑：

它实际上是编解码问题，给出4个数字。通过使用其他三个数字之间的算术运算符（+，-，×）检查他是否可以获取第四个数字。知道操作员只能使用一次。以这种格式->（a□b□c = d）。我的问题是，是否有一种方法可以使其自动化，还是我必须手动编码每种可能性，所以对我造成的任何混乱感到抱歉。

Answer 1

您不能将运算符存储在数组中，但可以为其创建包装函数，并将那些存储在数组中。

int add(int a, int b) {
    return a + b;
}

int sub(int a, int b) {
    return a - b;
}

int mul(int a, int b) {
    return a * b;
}

int div(int a, int b) {
    return a / b;
}

typedef int (*funptr)(int, int);

funptr arr[] = { add, sub, mul, div };

您可以这样称呼他们

(arr[1])(2, 1)   // call sub(2, 1)

在这种情况下，不需要在arr[1]周围加上括号，但我还是想清楚地说明一下。

Answer 2

不。您必须编写一个程序来解决这个问题。您可以在数组中存储类似函数指针的算术运算符，但是我认为这不会帮助您解决问题。您仍然必须编写代码来解决问题。

Answer 3

在@CoffeeTableEspresso的答案上，您还可以将这些函数指针放入地图中。

int add(int a, int b) {
    return a + b;
}

int sub(int a, int b) {
    return a - b;
}

int mul(int a, int b) {
    return a * b;
}

int div(int a, int b) {
    return a / b;
}

typedef int (*funptr)(int, int);

std::map<char,funptr> operators = { 
    {'+', add}, 
    {'-', sub}, 
    {'*', mul}, 
    {'/', div}};

那你就可以做

operators['+'](4,7);

可能更具可读性，您可以更轻松地遍历这些内容。

Answer 4

我想我会提交一个有竞争力的答案。这适用于正数。为了涵盖所有可能性，可能需要更多的工作。它没有回答CoffeeTableEspresso关于优先级的问题。但这可能会帮助您解决关于if语句的最后一个问题。

#include <iostream>
namespace {
    auto add = [](int a, int b) {return a + b; };
    auto sub = [](int a, int b) {return a - b; };
    auto mult = [](int a, int b) {return a * b; };
    auto divd = [](int a, int b) {return b ? a / b : -1; };
    std::vector<int(*)(int, int)> ops = { add,sub,mult,divd };
}
int check(int* params)
{
    for (size_t i = 0; i < 4; ++i)
        for (size_t j = 0; j < 4; ++j)
        {
            auto result = ops[i](params[0], ops[j](params[1], params[2]));
            if (params[3] == result)
                return result;
            else
                std::cout << result << std::endl;
        }
    return -1;

}
int main()
{
    int params[] = { 3, 4, 5, 23 };
    std::cout << check(params);
}

Answer 5

运算符* /的优先级比+ -高，因此operator[i](A, operator[j](B, C))解决方案实际上不起作用。

您可以编写一个小的字符串计算器，并在字符运算符之间循环：

#include <iostream>
#include <sstream>
#include <vector>
#include <cmath>

double calculate(std::string str)
{
    // calculator there
    return -1;
};

int main()
{
    std::vector<char> op = {'+', '-', '*', '/'};
    std::vector<int>  a  = { 96, 3, 10, 42 };

    for (auto op1: op)
        for (auto op2: op)
        {
            std::stringstream ss;
            ss << a[0] << op1 << a[1] << op2 << a[2];
            double result = calculate( ss.str());

            if (std::abs(a[3] - result) < 1E-6)
                std::cout << ss.str() << " = " << a[3];
            else
                std::cout << ss.str() << " = " << result << " != " << a[3];
        }
}

您可以在C ++

5 个答案: