事实上，这些问题更多的是关于面试官与规范、设计、错误处理、边界案例以及为解决方案选择合适的环境等进行斗争，而不是关于实际解决方案。然而：：）

这里的函数是围绕封闭的4循环思想编写的。如果函数f只允许落在有符号的32位整数上，那么上面的各种解决方案都将起作用，除了其他人指出的三个输入范围数。minint永远不会满足函数方程，因此如果这是一个输入，我们将引发一个异常。

在这里，我允许Python函数操作并返回元组或整数。任务规范承认这一点，它只指定函数的两个应用程序应该返回一个与原始对象相等的对象，如果它是int32。（我会询问有关规范的更多细节）

这使得我的轨道可以很好且对称，并且可以覆盖所有输入整数（minint除外）。我最初设想的循环是访问半整数值，但我不想陷入舍入错误。因此是元组表示。这是一种将复杂旋转作为元组隐藏的方式，而不使用复杂的算术机制。

注意，在调用之间不需要保留任何状态，但调用者确实需要允许返回值为元组或int。

def f(x) :
  if isinstance(x, tuple) :
      # return a number.
      if x[0] != 0 :
        raise ValueError  # make sure the tuple is well formed.
      else :
        return ( -x[1] )

  elif isinstance(x, int ) :
    if x == int(-2**31 ):
      # This value won't satisfy the functional relation in
      # signed 2s complement 32 bit integers.
      raise ValueError
    else :
      # send this integer to a tuple (representing ix)
      return( (0,x) )
  else :
    # not an int or a tuple
    raise TypeError

因此，将f应用于37两次得到-37，反之亦然：

>>> x = 37
>>> x = f(x)
>>> x
(0, 37)
>>> x = f(x)
>>> x
-37
>>> x = f(x)
>>> x
(0, -37)
>>> x = f(x)
>>> x
37

将f两次应用于零得到零：

>>> x=0
>>> x = f(x)
>>> x
(0, 0)
>>> x = f(x)
>>> x
0

我们处理一个问题没有解决方案的情况（在int32中）：

>>> x = int( -2**31 )
>>> x = f(x)

Traceback (most recent call last):
  File "<pyshell#110>", line 1, in <module>
    x = f(x)
  File "<pyshell#33>", line 13, in f
    raise ValueError
ValueError

如果你认为函数通过模拟乘以i的90度旋转打破了“无复杂算术”规则，我们可以通过扭曲旋转来改变这一点。这里元组表示半整数，而不是复数。如果你在数字线上追踪轨道，你会得到满足给定函数关系的非相交循环。

f2: n -> (2 abs(n) +1, 2 sign( n) ) if n is int32, and not minint.
f2: (x, y) -> sign(y) * (x-1) /2  (provided y is \pm 2 and x is not more than 2maxint+1

练习：通过修改f来实现这个f2。还有其他解决方案，例如，中间着落点是有理数而不是半整数。有一个分数模块可能很有用。你需要一个符号函数。

这个练习让我真正体会到了动态类型语言的乐趣。我在C中看不到这样的解决方案。

f(n) { return -1 * abs(n) }

如何处理溢出问题？还是我错过了重点？

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

f(n) = n

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

这个怎么样（C语言）：

int f(int n)
{
    static int t = 1;
    return (t = t ? 0 : 1) ? -n : n;
}

刚刚试过，而且

f(f(1000)) 

回报-1000

f(f(-1000)) 

返回1000

这是正确的还是我没有抓住重点？

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

这是一个C/C++解决方案，它不使用任何按位运算符，也不需要任何数学库，尽管这有点作弊。。。

double f(double n)
{
    if (n == (double)(int)n)
        return n + 0.5;
    else
        return -(n - 0.5);
}

这适用于所有32位整数，只有一个异常0x80000000（因为它的相反值不能存储在32位整数系统中）。f（f（n））==-n将始终为真，除非在这种情况下。

不过，我相信有一种更简单、更快的方法来实现它。这只是我第一个想到的。