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

这里的函数是围绕封闭的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中看不到这样的解决方案。

Tcl:

proc f {input} {
    if { [string is integer $input] } {
      return [list expr [list 0 - $input]]
    } else {
      return [eval $input]
    }
}

% f [f 1]
-1

按照其他一些答案的思路。。。如果它是一个整数，则返回一个返回该数字负数的命令。如果不是数字，请对其求值并返回结果。

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

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的情况，这两种方法都不太有效，但除非允许返回更宽的类型，否则对此您几乎无能为力。

目标-C

这适用于除“-1”以外的所有数字。

如果要从使用int转换为使用NSInt，那么可以将-1值设置为NULL，然后第二次将它们转换为+1，但我觉得NSInt欺骗了询问者的意图。

f（n）：

-(int)f:(int)n {
    if (abs(n)==1) {
        n = -1;
    } else {
        if (abs(n)%2) {//o
            if (n>0) {//+
                n--;
                n*=+1;
            } else if (n<0) {//-
                n++;
                n*=+1;
            }
        } else {//e
            if (n>0) {//+
                n++;
                n*=-1;
            } else if (n<0) {//-
                n--;
                n*=-1;
            }
        }
    }
    return n;
}

当然，这一切都可以缩短为一行，但其他人可能无法阅读。。。

无论如何，我将BOOLEAN逻辑存储为奇数或偶数的状态。

const unsigned long Magic = 0x8000000;

unsigned long f(unsigned long n)
{    
    if(n > Magic )
    {
        return Magic - n;
    }

    return n + Magic;
} 

0~2^31

int f(int n)
{
  static long counter=0;
  counter++;
  if(counter%2==0)
    return -n;
  else
    return n;
}