我可以想象，使用第31位作为虚（I）位将是一种支持一半总范围的方法。

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

无分支：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%。

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

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))
}

Scala中使用隐式转换的一个奇怪且唯一稍微聪明的解决方案：

sealed trait IntWrapper {
  val n: Int
}

case class First(n: Int) extends IntWrapper
case class Second(n: Int) extends IntWrapper
case class Last(n: Int) extends IntWrapper

implicit def int2wrapper(n: Int) = First(n)
implicit def wrapper2int(w: IntWrapper) = w.n

def f(n: IntWrapper) = n match {
  case First(x) => Second(x)
  case Second(x) => Last(-x)
}

我认为这不是一个很好的主意。

创建许多解的一种方法是注意，如果我们将整数划分为两个集合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。

MIN_INT不会失败：

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