f#中的简单解决方案（不使用“技巧”）

let rec f n =
    if n = 0 then 0
    elif n > 0 then
        if (f (n - 1) <> n) then n + 1
        else -(n - 1)
    else
        if (f (-(n - 1)) = n) then n - 1
        else -(n + 1) 

另一种方法是将状态保持在一位，并在负数的情况下翻转它，注意二进制表示。。。限制为2^29

整数ffn（整数n）{

    n = n ^ (1 << 30); //flip the bit
    if (n>0)// if negative then there's a two's complement
    {
        if (n & (1<<30))
        {
            return n;
        }
        else
        {
            return -n;
        }
    }
    else
    {
        if (n & (1<<30))
        {
            return -n;
        }
        else
        {
            return n;
        }
    }


}

int func(int a)  
{   
    static int p = 0;  
    int ret = a;  

    if ( p ) ret *= -1;  
    p ^= 1;  

    return ret;  
}  

根据微软/谷歌的面试官通常在面试中提出的问题，我认为提问者指的是一种创新、轻量级、简单的解决方案，它将使用按位操作，而不是那些复杂的高级答案。

灵感来自@eipipuz的回答，我编写了这个C++函数（但没有运行它）：

int32_t f(int32_t n){
    int32_t temp = n & 00111111111111111111111111111111;
    x = n >> 30;
    x++;
    x = x << 30;
    return x | temp;
}

它将n的最左边的两位存储在x中，将x加1，然后再次将其替换为n的最左侧的两位。

如果我们继续以另一个f（n）作为参数n运行f（n，则最左边的两个位将如下旋转：

00 --> 01 --> 10 --> 11 --> 00 ...

请注意，最右边的30位不变。8位整数示例：

示例1：

>f（00001111）=01001111>f（01001111）=10001111[这是原始值的负值，00001111]

示例2：

>f（11101010）=00101010>f（00101010）=01101010[这是原始值11101010的负值]

根据您的平台，某些语言允许您在函数中保持状态。VB.Net，例如：

Function f(ByVal n As Integer) As Integer
    Static flag As Integer = -1
    flag *= -1

    Return n * flag
End Function

IIRC、C++也允许这样做。我怀疑他们正在寻找不同的解决方案。

另一个想法是，由于它们没有定义函数第一次调用的结果，因此可以使用奇数/均匀度来控制是否反转符号：

int f(int n)
{
   int sign = n>=0?1:-1;
   if (abs(n)%2 == 0)
      return ((abs(n)+1)*sign * -1;
   else
      return (abs(n)-1)*sign;
}

所有偶数的幅度加一，所有奇数的幅度减一。两次调用的结果大小相同，但在一次调用中，我们甚至交换了符号。在某些情况下，这不会起作用（-1，max或min int），但它的效果比迄今为止任何其他建议都要好得多。

C++解决方案；

long long f(int n){return static_cast <long long> (n);}
int f(long long n){return -static_cast <int> (n);}

int n = 777;
assert(f(f(n)) == -n);