我在上次面试中遇到的一个问题是：
设计函数f，使得：f（f（n））==-n其中n是32位有符号整数；你不能用复数算术。如果你不能为整个数字范围设计这样的函数，那么就尽可能为最大范围设计它。
有什么想法吗？
当前回答
我认为最大的可能范围是暗示模块化算术解决方案。在一些模基M中，有一个数，当平方等于M-1（等于-1）。例如，如果M=13，5*5=25，25 mod 13=12（=-1）总之，这里有一些M=2**32-3的python代码。
def f(x):
m=2**32-3;
halfm=m//2;
i_mod_m=1849436465
if abs( x ) >halfm:
raise "too big"
if x<0:
x+=m
x=(i_mod_m*x) % m
if (x>halfm):
x-=m
return x;
注意，有3个值不适用于2**31-1、-（2**31-1）和-（2*#31）
其他回答
F#
let f n =
match n with
| n when n % 2 = 0 -> -n + System.Math.Sign n
| _ -> n - System.Math.Sign -n
其中n使得System.Int32.MinValue<n<System.Int32.MaxValue。
我还没有看其他答案，我假设已经彻底讨论了按位技术。
我想我会在C++中想出一些邪恶的东西，希望不会上当受骗：
struct ImplicitlyConvertibleToInt
{
operator int () const { return 0; }
};
int f(const ImplicitlyConvertibleToInt &) { return 0; }
ImplicitlyConvertibleToInt f(int & n)
{
n = 0; // The problem specification didn't say n was const
return ImplicitlyConvertibleToInt();
}
整个ImplicitlyConvertableToInt类型和重载是必需的，因为临时变量不能绑定到非常量引用。
当然，现在来看它，f（n）是否在-n之前执行是不确定的。
对于这种程度的邪恶，也许一个更好的解决方案是：
struct ComparesTrueToInt
{
ComparesTrueToInt(int) { } // implicit construction from int
};
bool operator == (ComparesTrueToInt, int) const { return true; }
ComparesTrueToInt f(ComparesTrueToInt ct) { return ComparesTrueToInt(); }
由于C++中的重载：
double f(int var)
{
return double(var);
}
int f(double var)
{
return -int(var);
}
int main(){
int n(42);
std::cout<<f(f(n));
}
f(n) { return -1 * abs(n) }
如何处理溢出问题？还是我错过了重点？
该问题表示“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)
