我在上次面试中遇到的一个问题是：
设计函数f，使得：f（f（n））==-n其中n是32位有符号整数；你不能用复数算术。如果你不能为整个数字范围设计这样的函数，那么就尽可能为最大范围设计它。
有什么想法吗？
当前回答
怎么样：
f(n) = sign(n) - (-1)ⁿ * n
在Python中：
def f(n):
if n == 0: return 0
if n >= 0:
if n % 2 == 1:
return n + 1
else:
return -1 * (n - 1)
else:
if n % 2 == 1:
return n - 1
else:
return -1 * (n + 1)
Python自动将整数提升为任意长度的longs。在其他语言中，最大的正整数将溢出，因此它将适用于除该整数之外的所有整数。
为了使其适用于实数，您需要替换（-1）中的nⁿ 如果n>0，则为{上限（n）；如果n<0}，则为下限（n）。
在C#中（适用于任何双精度，溢出情况除外）：
static double F(double n)
{
if (n == 0) return 0;
if (n < 0)
return ((long)Math.Ceiling(n) % 2 == 0) ? (n + 1) : (-1 * (n - 1));
else
return ((long)Math.Floor(n) % 2 == 0) ? (n - 1) : (-1 * (n + 1));
}
其他回答
我试着打高尔夫，这是罗德里克·查普曼的回答。
无分支：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%。
Wolfram语言的解决方案：
f[f[n_]] := -n
应用程序：
In[2]:= f[f[10]]
Out[2]= -10
In[3]:= f[10]
Out[3]= f[10]
因为这个问题没有说明f（n）的值，所以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)
}
我认为这不是一个很好的主意。
该问题表示“32位有符号整数”，但没有指定它们是2个补码还是1个补码。
如果使用1补码，则所有2^32值都出现在长度为4的循环中-不需要零的特殊情况，也不需要条件。
在C中：
int32_t f(int32_t x)
{
return (((x & 0xFFFFU) << 16) | ((x & 0xFFFF0000U) >> 16)) ^ 0xFFFFU;
}
这项工作由
交换高位和低位16位块反转其中一个块
两次传递后，我们得到原始值的位逆。在一中补语表示等同于否定。
示例：
Pass | x
-----+-------------------
0 | 00000001 (+1)
1 | 0001FFFF (+131071)
2 | FFFFFFFE (-1)
3 | FFFE0000 (-131071)
4 | 00000001 (+1)
Pass | x
-----+-------------------
0 | 00000000 (+0)
1 | 0000FFFF (+65535)
2 | FFFFFFFF (-0)
3 | FFFF0000 (-65535)
4 | 00000000 (+0)
这个怎么样（C语言）：
int f(int n)
{
static int t = 1;
return (t = t ? 0 : 1) ? -n : n;
}
刚刚试过，而且
f(f(1000))
回报-1000
f(f(-1000))
返回1000
这是正确的还是我没有抓住重点？
