记住你的上一个状态不是一个足够好的答案吗？

int f (int n)
{
    //if count 
    static int count = 0;

    if (count == 0)
        { 
            count = 1;
            return n;
        }

    if (n == 0)
        return 0;
    else if (n > 0)
    {
        count = 0;
        return abs(n)*(-1);
    } 
    else
    {
        count = 0;
        return abs(n);
    }
}

int main()
{
    int n = 42;
    std::cout << f(f(n))
}

这个问题并没有说明函数f的输入类型和返回值必须是什么（至少不是你给出的方式）。。。

…只是当n是32位整数时，f（f（n））=-n

那么，怎么样

Int64 f(Int64 n)
{
    return(n > Int32.MaxValue ? 
        -(n - 4L * Int32.MaxValue):
        n + 4L * Int32.MaxValue);
}

如果n是32位整数，则语句f（f（n））==-n将为真。

显然，这种方法可以扩展到更大范围的数字。。。

或者，您可以滥用预处理器：

#define f(n) (f##n)
#define ff(n) -n

int main()
{
  int n = -42;
  cout << "f(f(" << n << ")) = " << f(f(n)) << endl;
}

创建许多解的一种方法是注意，如果我们将整数划分为两个集合S和R

那么我们可以如下创建f：

如果x在R中，则f（x）=g（x）

如果x在S中，则f（x）=-invg（x）

其中invg（g（x））=x，所以invg是g的逆函数。

上面提到的第一个解决方案是分区R=偶数，R=奇数，g（x）=x+1。

我们可以取任意两个无限集合T，P s.T T+U=整数集合，取s=T+（-T），R=U+（-U）。

然后-S=S和-R=R通过它们的定义，我们可以将g取为从S到R的任何1-1对应关系，这必须存在，因为这两个集合都是无限的和可数的。

因此，这将为我们提供许多解决方案，但并非所有解决方案都可以编程，因为它们不会被有限地定义。

例如：

R=可被3整除的数字，S=不可被3除的数字。

然后我们取g（6r）=3r+1，g（6r+3）=3r+2。

有些类似，但我只是想写下我的第一个想法（用C++）

#include <vector>

vector<int>* f(int n)
{
  returnVector = new vector<int>();
  returnVector->push_back(n);
  return returnVector;
}

int f(vector<int>* n) { return -(n->at(0)); }

仅使用重载使f（f（n））实际调用两个不同的函数

这里有一个解决方案，其灵感来自于不能使用复数来解决这个问题的要求或声明。

乘以-1的平方根是一个想法，但似乎失败了，因为-1没有整数的平方根。但是，使用mathematica这样的程序可以得出如下公式

（18494364652+1）模（232-3）=0。

这几乎和平方根为-1一样好。函数的结果必须是有符号整数。因此，我将使用一个修改的模运算mods（x，n），它返回与x模n最接近0的整数y。只有极少数编程语言能够成功地进行模运算，但它很容易被定义。例如，在python中，它是：

def mods(x, n):
    y = x % n
    if y > n/2: y-= n
    return y

使用上面的公式，问题现在可以解决为

def f(x):
    return mods(x*1849436465, 2**32-3)

对于[-231-2231-2]范围内的所有整数，这满足f（f（x））=-x。f（x）的结果也在这个范围内，但当然计算需要64位整数。