下面是一个简短的Python答案：

def f(n):
  m = -n if n % 2 == 0 else n
  return m + sign(n)

一般情况

稍微调整一下上面的内容就可以处理我们希望k个自调用否定输入的情况——例如，如果k＝3，这意味着g（g（g）n））＝-n：

def g(n):
  if n % k: return n + sign(n)
  return -n + (k - 1) * sign(n)

这是通过将0保留在适当位置并创建长度为2*k的循环来实现的，因此，在任何循环中，n和-n之间的距离为k。具体来说，每个周期如下：

N * k + 1, N * k + 2, ... , N * k + (k - 1), - N * k - 1, ... , - N * k - (k - 1)

或者，为了更容易理解，这里是k＝3的示例循环：

1, 2, 3, -1, -2, -3
4, 5, 6, -4, -5, -6

这组循环最大化了在任何以零为中心的机器类型（如有符号int32或有符号int64类型）内工作的输入范围。

兼容范围分析

映射x->f（x）实际上必须形成长度为2*k的循环，其中x=0是特殊情况下的1-长度循环，因为-0=0。因此，一般k的问题是可解的，当且仅当输入-1（补偿0）的范围是2*k的倍数，并且正负范围是相反的。

对于有符号整数表示，我们总是有一个最小的负数，在该范围内没有正的对应项，因此该问题在整个范围内变得不可解决。例如，有符号字符的范围为[-128127]，因此在给定范围内f（f（-128））=128是不可能的。

我相信这符合所有要求。没有什么规定参数必须是32位有符号整数，只有你传入的值“n”是。

long long f(long long n)
{
    int high_int = n >> 32;
    int low_int  = n & 0xFFFFFFFF;

    if (high_int == 0) {
        return 0x100000000LL + low_int;
    } else {
        return -low_int;
    }
}

这个怎么样？

int nasty(int input)
{
    return input + INT_MAX/2;
}

int f( int n ){
    return n==0?0:(n&1?n:-n)+(n<0?-1:1);
}

这个想法已经在其他答案中使用过，但我把它融入了Python的一行：

def f(n):
    return str(n) if type(n) == int else -int(n)

C++中的另一个作弊解决方案是运算符重载。

struct func {
    int n;
    func operator()(int k) { n = -k; return *this; }
    int operator()(const func &inst) { return inst.n; }
} f;