我在上次面试中遇到的一个问题是：
设计函数f，使得：f（f（n））==-n其中n是32位有符号整数；你不能用复数算术。如果你不能为整个数字范围设计这样的函数，那么就尽可能为最大范围设计它。
有什么想法吗？
当前回答
虽然问题说n必须是32位int，但它没有说参数或返回类型必须是32比特int0
private final long MAGIC_BIT=1<<38;
long f(long n) {
return n & MAGIC_BIT != 0 ? -(n & !MAGIC_BIT) : n | MAGIC_BIT;
}
编辑：
这实际上是一个很好的面试问题。最好的答案是难以或不可能回答的，因为它迫使人们仔细思考，你可以观察并寻找：
他们会放弃吗？他们说这很愚蠢吗？他们是否尝试独特的方法？他们在处理问题时是否与您沟通？他们是否要求进一步细化要求？
etc.
永远不要只回答行为问题，除非你有一个非常好的答案。始终保持愉快，并尝试让提问者参与进来。不要沮丧，不要过早放弃！如果你真的一无所获，尝试一些完全非法的、可能奏效的方法，你将获得几乎全部的学分。
其他回答
怎么样：
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));
}
使用全局。。。但事实如此？
bool done = false
f(int n)
{
int out = n;
if(!done)
{
out = n * -1;
done = true;
}
return out;
}
有些类似，但我只是想写下我的第一个想法（用C++）
#include <vector>
vector<int>* f(int n)
{
returnVector = new vector<int>();
returnVector->push_back(n);
return returnVector;
}
int f(vector<int>* n) { return -(n->at(0)); }
仅使用重载使f（f（n））实际调用两个不同的函数
这里有一个我从未见过的变体。因为这是ruby，所以32位整数的东西就不见了（当然可以添加检查）。
def f(n)
case n
when Integer
proc { n * -1 }
when Proc
n.call
else
raise "Invalid input #{n.class} #{n.inspect}"
end
end
(-10..10).each { |num|
puts "#{num}: #{f(f(num))}"
}
对于所有32位值（注意，-0是-2147483648）
int rotate(int x)
{
static const int split = INT_MAX / 2 + 1;
static const int negativeSplit = INT_MIN / 2 + 1;
if (x == INT_MAX)
return INT_MIN;
if (x == INT_MIN)
return x + 1;
if (x >= split)
return x + 1 - INT_MIN;
if (x >= 0)
return INT_MAX - x;
if (x >= negativeSplit)
return INT_MIN - x + 1;
return split -(negativeSplit - x);
}
基本上需要将每个-x=>x=>-x循环与y=>-y=>y循环配对。所以我把裂口的两边配对。
例如，对于4位整数：
0 => 7 => -8 => -7 => 0
1 => 6 => -1 => -6 => 1
2 => 5 => -2 => -5 => 2
3 => 4 => -3 => -4 => 3
