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

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

    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，这意味着在大多数情况下这是第一次调用。如果最后一位与第二个最后一位不同，那么我假设我们在第二次调用，然后简单地重新反转最后一位。显然，对于使用最后两位的非常大的数字来说，这不起作用。但是，它再次适用于非常广泛的数字。

怎么样

int f(int n)
{
    return -abs(n);
}

本质上，函数必须将可用范围划分为大小为4的循环，其中-n位于n循环的另一端。但是，0必须是大小为1的循环的一部分，否则0->x->0->x！=-x.因为0是单独的，所以在我们的范围内必须有3个其他值（其大小是4的倍数）不在具有4个元素的正确循环中。

我选择这些额外的奇怪值为MIN_INT、MAX_INT和MIN_INT+1。此外，MIN_INT+1将正确映射到MAX_INT，但会被卡在那里而不能映射回来。我认为这是最好的妥协，因为它有一个很好的特性，即只有极端值不能正常工作。此外，这意味着它将适用于所有BigInt。

int f(int n):
    if n == 0 or n == MIN_INT or n == MAX_INT: return n
    return ((Math.abs(n) mod 2) * 2 - 1) * n + Math.sign(n)

这个Perl解决方案适用于整数、浮点数和字符串。

sub f {
    my $n = shift;
    return ref($n) ? -$$n : \$n;
}

尝试一些测试数据。

print $_, ' ', f(f($_)), "\n" for -2, 0, 1, 1.1, -3.3, 'foo' '-bar';

输出：

-2 2
0 0
1 -1
1.1 -1.1
-3.3 3.3
foo -foo
-bar +bar

使用循环置换方法来实现这一点。

-b a b-a

a b-a-b

在微不足道的情况下f（0）返回0

对不起，我的电话回答很粗糙，28日后我将发布完整版本（现在正在检查…）简单地说，假设f（n）是一个循环排列，问题是如何构造它。

定义fk=f（f（f）f（…f（n））））（k fs）情况k=20.微不足道的情况f（0）返回01.分组，在情况k=2时，分组：{0} {1,2} {3,4} ... ｛n，n+1 |（n+1）%2=0｝注意：我只使用Z+，因为结构不需要使用负数。2.构造排列：如果n%2=0，那么a=n-1 b=n如果n%2=1，则a=n b=n+1

这将产生相同的排列，因为n和f（n）在同一组中。

注意排列为P返回P（n）

对于k＝2t，只做上面相同的事情，只做MOD k。对于k＝2t-1，虽然该方法有效，但毫无意义，啊？（f（n）=-n正常）