容易的：

function f($n) {
   if ($n%2 == 0) return ($n+1)*-1;
   else return ($n-1);
}

这将在非常广泛的数字范围内发挥作用：

    static int f(int n)
    {
        int lastBit = int.MaxValue;
        lastBit++;
        int secondLastBit = lastBit >> 1;
        int tuple = lastBit | secondLastBit;
        if ((n & tuple) == tuple)
            return n + lastBit;
        if ((n & tuple) == 0)
            return n + lastBit;
        return -(n + lastBit);
    }

我最初的方法是使用最后一位作为检查位，以了解我们在第一次或第二次调用中的位置。基本上，我会在第一次调用后将此位设置为1，以向第二次调用发出第一次调用已经通过的信号。但是，这种方法被负数所击败，负数的最后一位在第一次调用期间已经到达1。

同样的理论适用于大多数负数的倒数第二位。但是，通常发生的情况是，大多数情况下，最后一位和第二位是相同的。它们要么都是负数的1，要么都是正数的0。

所以我的最后一个方法是检查它们是否都是1或都是0，这意味着在大多数情况下这是第一次调用。如果最后一位与第二个最后一位不同，那么我假设我们在第二次调用，然后简单地重新反转最后一位。显然，对于使用最后两位的非常大的数字来说，这不起作用。但是，它再次适用于非常广泛的数字。

从来没有人说过f（x）必须是同一类型。

def f(x):
    if type(x) == list:
        return -x[0]
    return [x]


f(2) => [2]
f(f(2)) => -2

对于所有32位值（注意，-0是-2147483648）

int rotate(int x)
{
    static const int split = INT_MAX / 2 + 1;
    static const int negativeSplit = INT_MIN / 2 + 1;

    if (x == INT_MAX)
        return INT_MIN;
    if (x == INT_MIN)
        return x + 1;

    if (x >= split)
        return x + 1 - INT_MIN;
    if (x >= 0)
        return INT_MAX - x;
    if (x >= negativeSplit)
        return INT_MIN - x + 1;
    return split -(negativeSplit - x);
}

基本上需要将每个-x=>x=>-x循环与y=>-y=>y循环配对。所以我把裂口的两边配对。

例如，对于4位整数：

0 => 7 => -8 => -7 => 0
1 => 6 => -1 => -6 => 1
2 => 5 => -2 => -5 => 2
3 => 4 => -3 => -4 => 3

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

这里有一个证明，如果不使用额外信息（除了32位的int），那么对于所有数字，这样的函数都不可能存在：

我们必须使f（0）=0。（证明：假设f（0）=x，则f（x）=f（f（0））=-0=0。现在，-x=f（f（x））=f（0）=x，这意味着x=0。）

此外，对于任何x和y，假设f（x）=y。那么我们希望f（y）=-x。并且f（f（y））=-y=>f（-x）=-y。总结一下：如果f（x）=y，那么f（-x）=-y，f（y）=-x，f（-y）=x。

因此，我们需要将除0之外的所有整数分成4个集合，但我们有奇数个这样的整数；不仅如此，如果我们去掉没有正对应的整数，我们仍然有2（mod4）个数。

如果我们去掉剩下的2个最大数（通过abs值），我们可以得到函数：

int sign(int n)
{
    if(n>0)
        return 1;
    else 
        return -1;
}

int f(int n)
{
    if(n==0) return 0;
    switch(abs(n)%2)
    {
        case 1:
             return sign(n)*(abs(n)+1);
        case 0:
             return -sign(n)*(abs(n)-1);
    }
}   

当然，另一种选择是不遵守0，并获得我们删除的2个数字作为奖励。（但这只是一个愚蠢的假设。）