我承认我会作弊，但还是符合要求。这是编程魔术，而不是数学。它适用于整个范围，-2^31除外。

int f(int n)
{
    static bool eFlag = false; // Only executed once
    eFlag = !eFlag;
    return eFlag?-n:n;
}

没有人说它必须是无国籍的。

int32 f(int32 x) {
    static bool idempotent = false;
    if (!idempotent) {
        idempotent = true;
        return -x;
    } else {
        return x;
    }
}

作弊，但不如很多例子。更糟糕的是，查看堆栈以查看调用者的地址是否为-f，但这将更具可移植性（虽然不是线程安全的……线程安全版本将使用TLS）。更邪恶的是：

int32 f (int32 x) {
    static int32 answer = -x;
    return answer;
}

当然，对于MIN_INT32的情况，这两种方法都不太有效，但除非允许返回更宽的类型，否则对此您几乎无能为力。

下面是一个简短的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是不可能的。

number f( number n)
{
  static count(0);
  if(count > 0) return -n;
  return n;
}

f(n) = n

f(f(n)) = f(n) = -n

斯卡拉：

def f(x: Any): Any = x match {
  case i: Int => new { override def hashCode = -i }
  case i @ _  => i.hashCode
}

在Java中也是如此：

public static Object f(final Object x) {
  if(x instanceof Integer) {
    return new Object() {
      @Override 
      public int hashCode() {
        return -(Integer)x;
      }
    };
  }
  return x.hashCode();
}

我试着打高尔夫，这是罗德里克·查普曼的回答。

无分支：74个字符

int f(int i){return(-((i&1)<<1)|1)*i-(-((i>>>31)<<1)|1)*(((i|-i)>>31)&1);}

带有分支，Java风格：58个字符

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

带分支，C样式：52个字符

int f(int i){return i?(((i&1)?-i:i)+(i>0?-1:1)):0;}

经过快速但有效的基准测试后，分支版本在我的机器上的速度提高了33%。（正数和负数的随机数据集，足够的重复，并防止编译器在预热时优化代码。）考虑到非分支版本中的操作数量以及可能的良好分支预测，这并不奇怪，因为函数被调用了两次：f（f（i））。当我将基准更改为度量：f（I）时，分支版本只快28%。我认为这证明了分支预测在第一种情况下确实有一些好处。更多证明：当使用f（f（f）（f（i）））进行测试时，分支版本的速度会快42%。