设计 function f(f(n)) == -n

Question

我上次面试时遇到的一个问题：

设计一个 function f ，这样：

 f(f(n)) == -n

其中n是 32 位有符号 integer ； 你不能使用复数算术。

如果您无法为整个数字范围设计这样的 function，请尽可能将其设计为最大范围。

有任何想法吗？

Answer 1

你没有说他们期望什么样的语言......这是一个静态解决方案（Haskell）。 它基本上弄乱了 2 个最重要的位：

f :: Int -> Int
f x | (testBit x 30 /= testBit x 31) = negate $ complementBit x 30
    | otherwise = complementBit x 30

在动态语言（Python）中要容易得多。 只需检查参数是否为数字 X 并返回一个返回 -X 的 lambda：

def f(x):
   if isinstance(x,int):
      return (lambda: -x)
   else:
      return x()

Answer 2

怎么样：

f(n) = sign(n) - (-1)n * 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 自动将整数提升为任意长度的 long。 在其他语言中，最大的正整数会溢出，因此它适用于除那个整数之外的所有整数。

---

要使其适用于实数，您需要将 (-1) ^{n 中}的n替换为{ ceiling(n) if n>0; floor(n) if n<0 } { ceiling(n) if n>0; floor(n) if n<0 } 。

在 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));
}

Answer 3

如果不使用额外信息（int 的 32 位除外），那么对于所有数字，这是为什么不能存在这样的函数的证明：

我们必须有 f(0) = 0。（证明：假设 f(0) = x。那么 f(x) = f(f(0)) = -0 = 0。现在，-x = f(f(x )) = f(0) = x，这意味着 x = 0。）

此外，对于任何x和y ，假设f(x) = y 。 我们想要f(y) = -x那么。 而f(f(y)) = -y => f(-x) = -y 。 总结一下：如果f(x) = y ，则f(-x) = -y和f(y) = -x和f(-y) = x 。

所以，我们需要将除 0 以外的所有整数分成 4 个一组，但我们有奇数个这样的整数； 不仅如此，如果我们删除没有正数对应的整数，我们仍然有 2(mod4) 个数字。

如果我们删除剩下的 2 个最大数字（通过 abs 值），我们可以得到函数：

int sign(int n)
{
    if(n>0)
        return 1;
    else 
        return -1;
}

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

当然，另一种选择是不遵守 0，并获得我们删除的 2 个数字作为奖励。 （但这只是一个愚蠢的如果。）

Answer 4

由于在 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));
}

Answer 5

或者，您可以滥用预处理器：

#define f(n) (f##n)
#define ff(n) -n

int main()
{
  int n = -42;
  cout << "f(f(" << n << ")) = " << f(f(n)) << endl;
}

Answer 6

对于所有负数都是如此。

f(n) = abs(n)

因为对于二进制补码整数，负数比正数多一个，所以f(n) = abs(n)比f(n) = n > 0 ? -n : n多一种情况有效f(n) = n > 0 ? -n : n f(n) = n > 0 ? -n : n与f(n) = -abs(n)相同的解决方案。 得到你一个... :D

更新

不，它对另一种情况无效，因为我刚刚通过 litb 的评论认识到... abs(Int.Min)只会溢出...

我也考虑过使用 mod 2 信息，但得出的结论是，它不起作用......早点。 如果做得好，它将适用于除Int.Min之外的所有数字，因为这会溢出。

更新

我玩了一段时间，寻找一个不错的操作技巧，但我找不到一个很好的单线，而 mod 2 解决方案适合一个。

f(n) = 2n(abs(n) % 2) - n + sgn(n)

在 C# 中，这变成了以下内容：

public static Int32 f(Int32 n)
{
    return 2 * n * (Math.Abs(n) % 2) - n + Math.Sign(n);
}

要使其适用于所有值，您必须将Math.Abs()替换为(n > 0) ? +n : -n (n > 0) ? +n : -n并将计算包含在unchecked块中。 然后你甚至可以像未经检查的否定一样将Int.Min映射到自身。

更新

受另一个答案的启发，我将解释该函数的工作原理以及如何构造这样的函数。

让我们从头开始。 函数f重复应用于给定值n产生一系列值。

n => f(n) => f(f(n)) => f(f(f(n))) => f(f(f(f(n)))) => ...

该问题要求f(f(n)) = -n ，即f两次连续应用否定了该论点。 f两个进一步应用 - 总共四个 - 再次否定论证，再次产生n 。

n => f(n) => -n => f(f(f(n))) => n => f(n) => ...

现在有一个明显的长度为 4 的循环。 代入x = f(n)并注意到获得的方程f(f(f(n))) = f(f(x)) = -x成立，得出以下结果。

n => x => -n => -x => n => ...

所以我们得到一个长度为四的循环，有两个数字，两个数字取反。 如果您将循环想象为一个矩形，则否定值位于对角。

构建这样一个循环的许多解决方案之一是从 n 开始的以下解决方案。

n                 => negate and subtract one
-n - 1 = -(n + 1)  => add one
-n                 => negate and add one
 n + 1             => subtract one
 n

一个具体的例子是这样的循环是+1 => -2 => -1 => +2 => +1 。 我们快完成了。 注意到构造的循环包含一个奇数正数，它的偶数后继数，并且两个数字都取反，我们可以很容易地将整数划分为许多这样的循环（ 2^32是四的倍数）并找到满足条件的函数。

但是我们有一个零的问题。 循环必须包含0 => x => 0因为 0 被否定。 并且因为循环状态已经0 => x它遵循0 => x => 0 => x 。 这只是一个长度为 2 的循环，并且x在两次应用后变成了它自己，而不是变成了-x 。 幸运的是，有一种情况可以解决问题。 如果X等于 0，我们得到一个长度为 1 的循环，只包含零，我们解决了这个问题，结论是 0 是f一个不动点。

完毕？ 几乎。 我们有2^32数字，零是一个不动点，留下2^32 - 1数字，我们必须将该数字划分为四个数字的循环。 糟糕的是2^32 - 1不是四的倍数 - 将剩余三个数字不在任何长度为四的循环中。

我将使用范围从-4到+3的较小的一组 3 位有符号迭代器来解释解决方案的其余部分。 我们完成了零。 我们有一个完整的循环+1 => -2 => -1 => +2 => +1 。 现在让我们构建从+3开始的循环。

+3 => -4 => -3 => +4 => +3

出现的问题是+4不能表示为 3 位整数。 我们将通过取反-3到+3来获得+4 - 这仍然是一个有效的 3 位整数 - 但是然后将 1 添加到+3 （二进制011 ）产生100二进制。 解释为无符号整数是+4但我们必须将其解释为有符号整数-4 。 所以实际上-4对于这个例子或Int.MinValue在一般情况下是整数算术否定的第二个固定点 - 0和Int.MinValue被映射到它们自己。 所以循环其实是这样的。

+3 =>    -4 => -3 => -4 => -3

这是一个长度为 2 的循环，另外+3通过-4进入循环。 结果-4在两次函数应用后正确映射到自身， +3在两次函数应用后被正确映射到-3 ，而-3在两次函数应用后被错误地映射到自身。

所以我们构造了一个函数，它适用于除一个以外的所有整数。 我们能做得更好吗？ 不，我们不可以。 为什么？ 我们必须构造长度为 4 的循环，并且能够覆盖最多四个值的整个整数范围。 剩下的值是两个固定点0和Int.MinValue必须映射到它们自己和两个任意整数x和-x必须通过两个函数应用程序相互映射。

要将x映射到-x ，反之亦然，它们必须形成一个四环，并且它们必须位于该环的对角。 因此0和Int.MinValue也必须在对角处。 这将正确映射x和-x但在两个函数应用程序之后交换两个固定点0和Int.MinValue并给我们留下两个失败的输入。 所以不可能构造一个适用于所有值的函数，但我们有一个适用于所有值的函数，除了一个值，这是我们能实现的最好的。

Answer 7

使用复数，您可以有效地将取负数的任务分为两个步骤：

• 将 n 乘以 i，得到 n*i，即 n 逆时针旋转 90°
• 再乘以 i，你得到 -n

最棒的是你不需要任何特殊的处理代码。 只需乘以 i 就可以了。

但是不允许使用复数。 因此，您必须使用部分数据范围以某种方式创建自己的假想轴。 由于您需要与初始值一样多的虚（中间）值，因此您只剩下一半的数据范围。

我尝试在下图中对此进行可视化，假设是有符号的 8 位数据。 您必须为 32 位整数缩放它。 初始 n 的允许范围是 -64 到 +63。 下面是函数对正 n 的作用：

• 如果 n 在 0..63（初始​​范围）内，则函数调用添加 64，将 n 映射到范围 64..127（中间范围）
• 如果 n 在 64..127（中间范围）中，则函数从 64 中减去 n，将 n 映射到范围 0..-63

对于负 n，函数使用中间范围 -65..-128。

Answer 8

除 int.MaxValue 和 int.MinValue 外有效

    public static int f(int x)
    {

        if (x == 0) return 0;

        if ((x % 2) != 0)
            return x * -1 + (-1 *x) / (Math.Abs(x));
        else
            return x - x / (Math.Abs(x));
    }

Answer 9

这个问题没有说明函数f的输入类型和返回值必须是什么（至少不是你呈现的方式）......

...只是当 n 是 32 位整数时f(f(n)) = -n

那么，像这样的东西怎么样

Int64 f(Int64 n)
{
    return(n > Int32.MaxValue ? 
        -(n - 4L * Int32.MaxValue):
        n + 4L * Int32.MaxValue);
}

如果 n 是一个 32 位整数，那么语句f(f(n)) == -n将为真。

显然，这种方法可以扩展到适用于更广泛的数字......

Answer 10

对于 javascript（或其他动态类型语言），您可以让函数接受一个 int 或一个对象并返回另一个。 IE

function f(n) {
    if (n.passed) {
        return -n.val;
    } else {
        return {val:n, passed:1};
    }
}

给予

js> f(f(10))  
-10
js> f(f(-10))
10

或者，您可以在强类型语言中使用重载，尽管这可能会违反规则，即

int f(long n) {
    return n;
}

long f(int n) {
    return -n;
}

Answer 11

根据您的平台，某些语言允许您在函数中保持状态。 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），但它比迄今为止建议的任何其他方法都有效。

Answer 12

利用 JavaScript 异常。

function f(n) {
    try {
        return n();
    }
    catch(e) { 
        return function() { return -n; };
    }
}

f(f(0)) => 0

f(f(1)) => -1

Answer 13

对于所有 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 循环与 ay => -y => y 循环配对。 所以我将split两侧配对。

例如对于 4 位整数：

0 => 7 => -8 => -7 => 0
1 => 6 => -1 => -6 => 1
2 => 5 => -2 => -5 => 2
3 => 4 => -3 => -4 => 3

Answer 14

C++ 版本，可能会稍微改变规则，但适用于所有数字类型（浮点数、整数、双精度数）甚至重载一元减号的类类型：

template <class T>
struct f_result
{
  T value;
};

template <class T>
f_result <T> f (T n)
{
  f_result <T> result = {n};
  return result;
}

template <class T>
T f (f_result <T> n)
{
  return -n.value;
}

void main (void)
{
  int n = 45;
  cout << "f(f(" << n << ")) = " << f(f(n)) << endl;
  float p = 3.14f;
  cout << "f(f(" << p << ")) = " << f(f(p)) << endl;
}

Answer 15

x86 asm（AT&T 风格）：

; input %edi
; output %eax
; clobbered regs: %ecx, %edx
f:
    testl   %edi, %edi
    je  .zero

    movl    %edi, %eax
    movl    $1, %ecx
    movl    %edi, %edx
    andl    $1, %eax
    addl    %eax, %eax
    subl    %eax, %ecx
    xorl    %eax, %eax
    testl   %edi, %edi
    setg    %al
    shrl    $31, %edx
    subl    %edx, %eax
    imull   %ecx, %eax
    subl    %eax, %edi
    movl    %edi, %eax
    imull   %ecx, %eax
.zero:
    xorl    %eax, %eax
    ret

检查代码，通过所有可能的 32 位整数，错误为 -2147483647（下溢）。

Answer 16

这个 Perl 解决方案适用于整数、浮点数和字符串。

sub f {
    my $n = shift;
    return ref($n) ? -$$n : \$n;
}

尝试一些测试数据。

print $_, ' ', f(f($_)), "\n" for -2, 0, 1, 1.1, -3.3, 'foo' '-bar';

输出：

-2 2
0 0
1 -1
1.1 -1.1
-3.3 3.3
foo -foo
-bar +bar

Answer 17

使用全局变量......但如此？

bool done = false
f(int n)
{
  int out = n;
  if(!done)
  {  
      out = n * -1;
      done = true;
   }
   return out;
}

Answer 18

没有人说过 f(x) 必须是同一类型。

def f(x):
    if type(x) == list:
        return -x[0]
    return [x]


f(2) => [2]
f(f(2)) => -2

Answer 19

这是一个解决方案，其灵感来自于不能使用复数来解决此问题的要求或声明。

乘以 -1 的平方根是一个想法，这似乎只是因为 -1 没有整数的平方根。 但是玩弄像 mathematica 这样的程序给出了例如等式

(1849436465 ² +1) 模 (2 ³² -3) = 0。

这几乎和 -1 的平方根一样好。 函数的结果需要是一个有符号整数。 因此，我将使用修改后的模运算 mods(x,n)，它返回与 x modulo n 最接近 0 的整数 y 全等。只有极少数编程语言具有模运算，但它可以很容易地定义. 例如在python中它是：

def mods(x, n):
    y = x % n
    if y > n/2: y-= n
    return y

使用上面的方程，问题现在可以解决为

def f(x):
    return mods(x*1849436465, 2**32-3)

对于[-2 31 -2, 2 31 -2]范围内的所有整数，这满足f(f(x)) = -x 。 f(x)结果也在这个范围内，但当然计算需要 64 位整数。

Answer 20

我实际上并不是想为问题本身提供解决方案，但确实有一些评论，因为问题表明这个问题是（工作？）面试的一部分：

• 我首先会问“为什么需要这样一个功能？这是一个更大的问题吗？” 而不是试图当场解决实际提出的问题。 这显示了我的想法以及我如何解决这样的问题。 谁知道？ 这甚至可能是面试中被问到这个问题的真正原因。 如果答案是“没关系，假设需要它，然后告诉我你将如何设计这个功能。” 然后我会继续这样做。
• 然后，我将编写我将使用的 C# 测试用例代码（显而易见：从int.MinValue到int.MaxValue循环，并且对于该范围内的每个n调用f(f(n))并检查结果是-n ） ，告诉我然后我会使用测试驱动开发来获得这样的功能。
• 只有当面试官继续要求我解决提出的问题时，我才会真正开始在面试过程中尝试编写伪代码以尝试获得某种答案。 但是，如果面试官对公司的情况有任何指示，我真的不认为我会跳槽接受这份工作......

哦，这个答案假设面试是针对 C# 编程相关职位的。 如果面试是针对与数学相关的职位，那当然是一个愚蠢的答案。 ;-)

Answer 21

我希望你改变 2 个最重要的位。

00.... => 01.... => 10.....

01.... => 10.... => 11.....

10.... => 11.... => 00.....

11.... => 00.... => 01.....

正如你所看到的，它只是一个加法，省略了携带位。

我是怎么得到答案的？ 我的第一个想法只是需要对称。 4 圈回到我开始的地方。 起初我以为，那是 2 位格雷码。 然后我认为实际上标准二进制就足够了。

Answer 22

C# 范围为 2^32 - 1 个数字，除 (Int32.MinValue) 之外的所有 int32 数字

    Func<int, int> f = n =>
        n < 0
           ? (n & (1 << 30)) == (1 << 30) ? (n ^ (1 << 30)) : - (n | (1 << 30))
           : (n & (1 << 30)) == (1 << 30) ? -(n ^ (1 << 30)) : (n | (1 << 30));

    Console.WriteLine(f(f(Int32.MinValue + 1))); // -2147483648 + 1
    for (int i = -3; i <= 3  ; i++)
        Console.WriteLine(f(f(i)));
    Console.WriteLine(f(f(Int32.MaxValue))); // 2147483647

印刷：

2147483647
3
2
1
0
-1
-2
-3
-2147483647

Answer 23

本质上，该函数必须将可用范围划分为大小为 4 的循环，-n 位于 n 循环的另一端。 但是， 0 必须是大小为 1 的循环的一部分，否则0->x->0->x != -x 。 由于 0 是单独的，因此我们的范围内必须有 3 个其他值（其大小是 4 的倍数），而不是具有 4 个元素的正确循环。

我选择了这些额外的奇怪值作为MIN_INT 、 MAX_INT和MIN_INT+1 。 此外， MIN_INT+1将正确映射到MAX_INT ，但卡在那里而不映射回来。 我认为这是最好的折衷方案，因为它有一个很好的特性，即只有极值不能正常工作。 此外，这意味着它适用于所有BigInt。

int f(int n):
    if n == 0 or n == MIN_INT or n == MAX_INT: return n
    return ((Math.abs(n) mod 2) * 2 - 1) * n + Math.sign(n)

Answer 24

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

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 的情况，这些都不是很好，但是除非允许您返回更宽的类型，否则您对此无能为力。

Answer 25

我可以想象使用第 31 位作为虚数 ( i ) 位将是一种支持一半总范围的方法。

Answer 26

适用于 n= [0 .. 2^31-1]

int f(int n) {
  if (n & (1 << 31)) // highest bit set?
    return -(n & ~(1 << 31)); // return negative of original n
  else
    return n | (1 << 31); // return n with highest bit set
}

Answer 27

问题说明了“32 位有符号整数”，但没有指定它们是twos-complement还是ones-complement 。

如果您使用一个补码，那么所有 2^32 个值都出现在长度为 4 的循环中 - 您不需要零的特殊情况，也不需要条件。

在 C 中：

int32_t f(int32_t x)
{
  return (((x & 0xFFFFU) << 16) | ((x & 0xFFFF0000U) >> 16)) ^ 0xFFFFU;
}

这工作由

1. 交换高低 16 位块
2. 反转块之一

经过两次后，我们得到了原始值的按位逆。 其中补码表示等价于否定。

例子：

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)

Answer 28

:D

boolean inner = true;

int f(int input) {
   if(inner) {
      inner = false;
      return input;
   } else {
      inner = true;
      return -input;
   }
}

Answer 29

return x ^ ((x%2) ? 1 : -INT_MAX);

Answer 30

作为一名数学家，我想分享我对这个有趣问题的看法。 我认为我有最有效的解决方案。

如果我没记错的话，只需翻转第一位即可否定有符号的 32 位整数。 例如，如果 n = 1001 1101 1110 1011 1110 0000 1110 1010，则 -n = 0001 1101 1110 1011 1110 0000 1110 1010。

那么我们如何定义一个函数 f，它接受一个有符号的 32 位整数并返回另一个有符号的 32 位整数，它的属性是取 f 两次与翻转第一位相同？

让我在不提及整数等算术概念的情况下重新表述这个问题。

我们如何定义一个函数 f，它接受一个长度为 32 的 0 和 1 的序列，并返回一个长度相同的 0 和 1 的序列，并且取 f 两次与翻转第一位的性质相同？

观察：如果你能回答32位大小写的上述问题，那么你也可以回答64位大小写、100位大小写等。你只需将f应用于前32位即可。

现在，如果您可以回答 2 位案例的问题，瞧！

是的，结果证明改变前 2 位就足够了。

这是伪代码

1. take n, which is a signed 32-bit integer.
2. swap the first bit and the second bit.
3. flip the first bit.
4. return the result.

备注：第2步和第3步合起来可以总结为(a,b) --> (-b, a)。 看起来很熟悉？ 这应该让您想起平面的 90 度旋转和乘以 -1 的平方根。

如果我只是单独展示伪代码而没有冗长的前奏，那看起来就像是一只兔子，我想解释一下我是如何得到解决方案的。

Answer 31

这很容易！

每个数字都以 4 个周期映射到另一个数字，其中所需的条件成立。

例子：

规则是：

• 0 → 0

• ±2³¹ → ±2³¹

• 奇数→偶数，偶数→-奇数：

  对于所有 k, 0 < k < 2³⁰: (2k-1) → (2k) → (-2k+1) → (-2k) → (2k-1)

唯一不匹配的值是 ±(2³¹-1)，因为只有两个。 必须有两个无法匹配，因为在二进制补码系统中只有四的倍数，其中 0 和 ±2³¹ 已被保留。

在一个补码系统中，存在+0和-0。 我们有 go：

对于所有 k, 0 < k < 2³⁰: (+2k) → (+2k+1) → (-2k) → (-2k-1) → (+2k)

Answer 32

在 PHP

function f($n) {
    if(is_int($n)) {
        return (string)$n;
    }
    else {
        return (int)$n * (-1);
    }
}

我相信您可以理解其他语言的这种方法的精神。 我明确地将其转换回 int 以使不使用弱类型语言的人更清楚。 对于某些语言，您必须重载 function。

这个解决方案的巧妙之处在于，无论您以字符串还是 integer 开头，它都有效，并且在返回 f(n) 时不会明显改变任何内容。

在我看来，面试官会问，“这个候选人是否知道如何标记数据以供以后操作”，以及“这个候选人是否知道如何标记数据，同时最少地改变它？” 您可以使用双精度、字符串或任何其他您喜欢转换的数据类型来执行此操作。

Answer 33

简单的 Python 解决方案之所以成为可能，是因为对 output 的 f(x) 没有任何限制，只有 f(f(x))：

def f(x):
    return (isinstance(x, tuple) and -x[0]) or (x,)

Answer 34

我有另一个解决方案在一半的时间内有效：

def f(x):
    if random.randrange(0, 2):
        return -x
    return x

Answer 35

这个怎么样？

int nasty(int input)
{
    return input + INT_MAX/2;
}

Answer 36

虽然问题说 n 必须是 32 位 int，但它没有说参数或返回类型必须是 32 位 int。 这应该在 java 中编译——在 c 中你可以去掉 != 0

private final long MAGIC_BIT=1<<38;
long f(long n) {
    return n & MAGIC_BIT != 0 ? -(n & !MAGIC_BIT) : n | MAGIC_BIT;
}

编辑：

这实际上是一个非常好的面试问题。 最好的是那些难以或不可能回答的问题，因为它迫使人们仔细思考，您可以观察并寻找：

• 他们只是放弃吗？
• 他们说这很愚蠢吗？
• 他们是否尝试独特的方法？
• 他们在解决问题时是否与您沟通？
• 他们是否要求进一步细化要求？

等等

除非你有一个非常好的答案，否则永远不要只回答行为问题。 始终保持愉快并尝试让提问者参与进来。 不要沮丧，也不要早早放弃，如果你真的没有得到任何结果，尝试一些完全非法的方法。 你会得到几乎全部的功劳。

Answer 37

使用问题中提供的信息，您可以

1. 从 2 补码转换为符号位表示
2. 如果设置了最后一位，则翻转符号位和最后一位； 否则，只翻转最后一位
3. 转换回 2 补码。

所以你基本上是 go 奇数 -> 偶数 -> 奇数或偶数 -> 奇数 -> 偶数，并且仅更改偶数的符号。 唯一不起作用的数字是 -2^31

代码：

function f(x) {
  var neg = x < 0;
  x = Math.abs(x) ^ 1;
  if (x & 1) {
    neg = !neg;
  }
  return neg ? -x : x;
}

Answer 38

这也是一个解决方案（但我们稍微改变了规则）：

def f(n):
    if isinstance(n,int):
        return str(n)
    else:
        return -int(n)

Answer 39

我认为这些问题的答案最好用图表来直观地解释。 当我们忽略零时，我们可以将整数划分为 4 个数字的小集合：

 1  → 2    3  → 4    5  → 6
 ↑    ↓    ↑    ↓    ↑    ↓   ...
-2 ← -1   -4 ← -3   -6 ← -5

这很容易翻译成代码。 请注意，偶数改变符号，奇数增加或减少 1。在 C# 中，它看起来像这样：

public static int f(int x)
{
    if(x == 0)
        return 0;

    if(x > 0)
        return (x % 2 == 0) ? -x+1 : x+1;

    // we know x is negative at this point
    return (x % 2 == 0) ? -x-1 : x-1;
}

当然，您可以通过使用巧妙的技巧来缩短此方法，但我认为这段代码最能说明问题。

然后关于范围。 32 位整数的范围从 -2^31 到 2^31-1。 数字 2^31-1、-2^31-1 和 -2^31 不在 f(x) 的范围内，因为缺少数字 2^31。

Answer 40

1. 将 n 转换为符号和大小表示；
2. 添加范围的 1/4；
3. 转换回来。

    #define STYPE int
    STYPE sign_bit = (unsigned STYPE) 1 << ( sizeof ( STYPE ) * 8  - 1 );
    STYPE f ( STYPE f )
    {
        unsigned STYPE smf = f > 0 ? f : -f | sign_bit;
        smf += sign_bit >> 1;
        return smf & sign_bit ? -( smf & ~sign_bit ) : smf;
    }

Answer 41

int f( int n ){
    return n==0?0:(n&1?n:-n)+(n<0?-1:1);
}

Answer 42

我的给出了正确的答案......50％的时间，所有的时间。

int f (int num) {
    if (rand () / (double) RAND_MAX > 0.5)
         return ~num + 1;
    return num;
}

Answer 43

在 coffeescript 中打高尔夫球：

f = (n)-> -n[0] or [n]

Answer 44

这是一个简短的 Python 答案：

def f(n):
  m = -n if n % 2 == 0 else n
  return m + sign(n)

一般情况

对上述内容稍作调整可以处理我们希望k个自调用否定输入的情况——例如，如果k = 3 ，这将意味着g(g(g(n))) = -n ：

def g(n):
  if n % k: return n + sign(n)
  return -n + (k - 1) * sign(n)

这通过将 0 留在原处并创建长度为 2 * k 的循环来工作，以便在任何循环内，n 和 -n 的距离为 k。 具体来说，每个周期看起来像：

N * k + 1, N * k + 2, ... , N * k + (k - 1), - N * k - 1, ... , - N * k - (k - 1)

或者，为了更容易理解，这里是k = 3的示例循环：

1, 2, 3, -1, -2, -3
4, 5, 6, -4, -5, -6

这组循环最大化了可以在以零为中心的任何机器类型中工作的输入范围，例如有符号 int32 或有符号 int64 类型。

兼容范围分析

map x -> f(x)实际上必须形成长度为2 * k的循环，其中x = 0是一个特殊情况下的长度为 1 的循环，因为 -0 = 0。因此，一般k的问题是可解决的当且仅当输入-1（补偿0）的范围是2*k的倍数，正负范围是相反的。

对于有符号的 integer 表示，我们总是有一个最小的负数，在该范围内没有正对应物，因此问题在整个范围内变得无法解决。 例如，有signed char的范围为 [-128, 127]，因此f(f(-128)) = 128在给定范围内是不可能的。

Answer 45

Lua：

function f(n)
    if type(n) == "number" then
        return (-number) .. ""
    else
        return number + 0
    end
end

Answer 46

f(n) { return -1 * abs(n) }

我该如何处理这个溢出问题？ 还是我错过了重点？

Answer 47

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)
}

我不认为这是完全正确的想法。

Answer 48

Clojure解决方案：

(defmacro f [n]
  (if (list? n) `(- ~n) n))

也适用于任何大小、双倍和比率的正整数和负整数！

Answer 49

有些是相似的，但只是想我会写下我的第一个想法（在 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)) 实际调用两个不同的函数

Answer 50

JavaScript 单线：

function f(n) { return ((f.f = !f.f) * 2 - 1) * n; }

Answer 51

另一种方法是将 state 保留在一个位中，并在负数的情况下小心地翻转它...限制为 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;
        }
    }


}

Answer 52

number f( number n)
{
  static count(0);
  if(count > 0) return -n;
  return n;
}

f(n) = n

f(f(n)) = f(n) = -n

Answer 53

int f(int n) {
    return ((n>0)? -1 : 1) * abs(n);
}

Answer 54

这个怎么样：

do
    local function makeFunc()
        local var
        return function(x)
            if x == true then
                return -var
            else
                var = x
                return true
            end
        end

    end
    f = makeFunc()
end
print(f(f(20000)))

Answer 55

f(n) { return IsWholeNumber(n)? 1/n : -1/n }

Answer 56

好吧，我既不是数学，也不是编程专家，但这不是很容易吗？

int f(int i) {
    static bool b;
    if (b) {
        b = !b;
        return i;
    } else {
        b = !b;
        return -i;
    }
}

用大大小小的正负值，INT_MIN，INT_MAX 进行测试，它似乎工作......如果这是一个问题，可以使线程安全，但它不是任务的一部分。

或者，也许我错过了什么？

Answer 57

C++

struct Value
{
  int value;
  Value(int v) : value(v) {}
  operator int () { return -value; }
};


Value f(Value input)
{
  return input;
}

Answer 58

与函数重载解决方案类似，在 python 中：

def f(number):
 if type(number) != type([]):
  return [].append(number)
 else:
  return -1*number[0]

替代方案： static datamembers

Answer 59

Python 2.6：

f = lambda n: (n % 2 * n or -n) + (n > 0) - (n < 0)

我意识到这对讨论没有任何帮助，但我无法抗拒。

Answer 60

int f(int n)
{
   static int x = 0;
   result = -x;
   x = n;
   return result;
}

这是一个带否定的单项 FIFO。 当然，它不适用于最大负数。

Answer 61

在 Python

f=lambda n:n[0]if type(n)is list else[-n]

Answer 62

好问题！

这花了我大约 35 秒的时间来思考和写下：

int f(int n){
    static int originalN=0;
    if (n!=0)
        originalN=n;
    return n-originalN;
}

Answer 63

Scala：

def f(x: Any): Any = x match {
  case i: Int => new { override def hashCode = -i }
  case i @ _  => i.hashCode
}

Java 中的相同内容：

public static Object f(final Object x) {
  if(x instanceof Integer) {
    return new Object() {
      @Override 
      public int hashCode() {
        return -(Integer)x;
      }
    };
  }
  return x.hashCode();
}

Answer 64

另一种利用短路的 Javascript 解决方案。

​function f(n) {return n.inv || {inv:-n}}

f(f(1)) => -1
f(f(-1)) => 1

Answer 65

以为我会在不先查看其他人的答案的情况下尝试这个：

#include <stdio.h>
#include <limits.h>
#include <stdlib.h>

int f(int n) {
    if(n > 0) {  
        if(n % 2)
            return -(++n);
        else {
            return (--n);

        }
    }
    else {
        if(n % 2)
            return -(--n);
        else {
            return (++n);

        }
    }
}

int main(int argc, char* argv[]) {
    int n;
    for(n = INT_MIN; n < INT_MAX; n++) {
        int N = f(f(n));

        if(N != -n) {
            fprintf(stderr, "FAIL! %i != %i\n", N, -n);
        }
    }
    n = INT_MAX;
    int N = f(f(n));
    if(N != -n) {
        fprintf(stderr, "FAIL! n = %i\n", n);
    }
    return 0;
}

Output：[无]

Answer 66

不会在 MIN_INT 上失败：

int f(n) { return n < 0 ? -abs(n + 1) : -(abs(n) + 1); }

Answer 67

如上所述的问题并不要求 function 必须只接受 32 位整数，只有给定的 n 是 32 位整数。

Ruby：

def f( n )
  return 0 unless n != 0 
  ( n == n.to_i ) ? 1.0 / n : -(n**-1).to_i
end

Answer 68

这将适用于非常广泛的数字：

    static int f(int n)
    {
        int lastBit = int.MaxValue;
        lastBit++;
        int secondLastBit = lastBit >> 1;
        int tuple = lastBit | secondLastBit;
        if ((n & tuple) == tuple)
            return n + lastBit;
        if ((n & tuple) == 0)
            return n + lastBit;
        return -(n + lastBit);
    }

我最初的方法是使用最后一位作为检查位，以了解我们在第一次或第二次通话中的位置。 基本上，我会在第一次调用后将此位设置为 1，以表示第一次调用已经通过。 但是，这种方法被负数打败了，负数在第一次调用期间最后一位已经到达 1。

对于大多数负数，相同的理论适用于倒数第二位。 但是，通常发生的情况是，大多数情况下，最后一位和倒数第二位是相同的。 对于负数，它们要么都是 1，要么对于正数，它们都是 0。

所以我最后的方法是检查它们是否都是 1 或都是 0，这意味着对于大多数情况这是第一次调用。 如果最后一位与倒数第二位不同，那么我假设我们在第二次通话中，只需重新反转最后一位。 显然，这不适用于使用最后两位的非常大的数字。 但是，再一次，它适用于非常广泛的数字。

Answer 69

似乎很容易。

<script type="text/javascript">
function f(n){
    if (typeof n === "string") {
        return parseInt(n, 10)
    }
    return (-n).toString(10);
}

alert(f(f(1)));
</script>

Answer 70

也许作弊？ （Python）

def f(n):    
    if isinstance(n, list):
        return -n[0]
    else:
        return [n,0]    
n = 4
print f(f(n))

--output--
-4

Answer 71

简单的：

function f($n) {
   if ($n%2 == 0) return ($n+1)*-1;
   else return ($n-1);
}

Answer 72

在 C 中，

int 
f(int n) {
     static int r = 0;
     if (r == 1) {r--; return -1 * n; };
     r++;
     return n;
}

知道这是什么语言会有所帮助。 我错过了什么吗？ 许多“解决方案”似乎过于复杂，而且坦率地说，不起作用（正如我读到的问题）。

Answer 73

这是rossfabricant答案的 C 实现。 请注意，由于我始终坚持使用 32 位整数，因此 f( f( 2147483647 ) ) == 2147483647，而不是-2147483647。

int32_t f( int32_t n )
{
    if( n == 0 ) return 0;
    switch( n & 0x80000001 ) {
        case 0x00000000:
            return -1 * ( n - 1 );
        case 0x00000001:
            return n + 1;
        case 0x80000000:
            return -1 * ( n + 1 );
        default:
            return n - 1;
    }
}

如果您将问题定义为允许 f() 接受并返回 int64_t，则涵盖 2147483647。 当然，switch 语句中使用的文字必须更改。

Answer 74

这个怎么样（C语言）：

int f(int n)
{
    static int t = 1;
    return (t = t ? 0 : 1) ? -n : n;
}

刚试了一下，然后

f(f(1000)) 

返回 -1000

f(f(-1000)) 

返回 1000

这是正确的还是我错过了重点？

Answer 75

真的，这些问题更多的是看到面试官与规范、设计、错误处理、边界情况和为解决方案选择合适的环境等搏斗，而不是关于实际的解决方案。 然而： ：）

这里的function是围绕封闭4周期的思想写的。 如果 function f 只允许落在有符号的 32 位整数上，那么除了其他人指出的三个输入范围数字外，上述各种解决方案都将起作用。 minint 永远不会满足函数方程，因此如果这是输入，我们将引发异常。

在这里，我允许我的 Python function操作并返回元组或整数。 任务规范承认这一点，它只指定 function 的两个应用程序应该返回一个等于原始 object 的 object 如果它是 int32。 （我会询问有关规范的更多详细信息。）

这使我的轨道很好且对称，并覆盖了所有输入整数（minint 除外）。 我最初设想循环访问一半 integer 值，但我不想与舍入错误纠缠在一起。 因此元组表示。 这是一种在不使用复杂算术机器的情况下将复杂的旋转作为元组偷偷溜进的方法。

请注意，在调用之间不需要保留 state，但调用者确实需要允许返回值是元组或 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

如果您认为 function 通过模仿乘以 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。 还有其他解决方案，例如，中间着陆点是有理数而不是半整数。 有一个分数模块可能会被证明是有用的。 您需要一个标志 function。

这个练习让我真正体会到了动态类型语言的乐趣。 我在 C 中看不到这样的解决方案。

Answer 76

C function：

int f(int n) /* Treats numbers in the range 0XC0000000 to 0X3FFFFFFF as valid to
                generate f(f(x)) equal to -x. If n is within this range, it will
                project n outside the range. If n is outside the range, it will
                return the opposite of the number whose image is n. */
{
    return n ? n > 0 ? n <= 0X3FFFFFFF ? 0X3FFFFFFF + n : 0X3FFFFFFF - n :\
           n >= 0XC0000000 ? 0XC0000000 + n : 0XC0000000 - n : 0;
}

用于测试和下载的 Ideone 链接

Answer 77

这个在 Python 中。 适用于 n 的所有负值：

f = abs

Answer 78

这是我没有看到人们使用的变体。 由于这是 ruby，因此 32 位 integer 的东西会出现在 window 中（当然可以添加检查）。

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))}"
}

Answer 79

创建许多解决方案的一种方法是注意，如果我们将整数划分为两组 S 和 R st -S=S、-R=R 和 function g st g(R) = S

然后我们可以创建 f 如下：

如果 x 在 R 中，则 f(x) = g(x)

如果 x 在 S 中，则 f(x) = -invg(x)

其中 invg(g(x))=x 所以 invg 是 g 的逆 function。

上面提到的第一个解决方案是分区R=偶数，R=奇数，g(x)=x+1。

我们可以取任意两个无限集合 T,P st T+U= 整数集合，并取 S=T+(-T), R=U+(-U)。

然后 -S=S 和 -R=R 根据它们的定义，我们可以将 g 视为从 S 到 R 的任何 1-1 对应关系，因为这两个集合都是无限且可数的，所以必须存在。

因此，这将为我们提供许多解决方案，但当然并非所有解决方案都可以编程，因为它们不会被有限定义。

一个可能的例子是：

R= 能被 3 整除的数，S= 不能被 3 整除的数。

然后我们取 g(6r) = 3r+1, g(6r+3) = 3r+2。

Answer 80

很简单，只要让f返回看起来等于任何integer 的东西，并且可以从 integer 转换。

public class Agreeable
{
    public static bool operator==(Agreeable c, int n)
        { return true; }

    public static bool operator!=(Agreeable c, int n)
        { return false; }

    public static implicit operator Agreeable(int n)
        { return new Agreeable(); }
}

class Program
{
    public static Agreeable f(Agreeable c)
        { return c; }

    static void Main(string[] args)
    {
        Debug.Assert(f(f(0)) == 0);
        Debug.Assert(f(f(5)) == -5);
        Debug.Assert(f(f(-5)) == 5);
        Debug.Assert(f(f(int.MaxValue)) == -int.MaxValue);
    }
}

Answer 81

const unsigned long Magic = 0x8000000;

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

    return n + Magic;
} 

0~2^31

Answer 82

int j = 0;

void int f(int n)
{    
    j++;

    if(j==2)
    {
       j = 0;
       return -n;
    }

    return n;
}

:D

Answer 83

以下情况如何：

int f (int n)
{
    static bool pass = false;
    pass = !pass;
    return pass? n : -n;
}

Answer 84

这适用于 -1073741823 到 1073741822 的范围：

int F(int n)
{
    if(n < 0)
    {
        if(n > -1073741824)
            n = -1073741824 + n;
        else n = -(n + 1073741824);
    }
    else
    {
        if(n < 1073741823)
            n = 1073741823 + n;
        else n = -(n - 1073741823);
    }
    return n;
}

它的工作原理是将 32 位有符号整数的可用范围一分为二。 function 的第一次迭代将n置于该范围之外。 第二次迭代检查它是否在此范围之外 - 如果是，则将其放回范围内但使其为负。

它实际上是一种保留有关值 n 的额外“位”信息的方法。

Answer 85

void f(int x)
{
     Console.WriteLine(string.Format("f(f({0})) == -{0}",x));
}

对不起，伙计们……这太诱人了；）

Answer 86

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);

Answer 87

另一个作弊解决方案。 我们使用一种允许运算符重载的语言。 然后我们让 f(x) 返回重载==的东西以始终返回 true。 这似乎与问题描述相符，但显然与谜题的精神背道而驰。

Ruby 示例：

class Cheat
  def ==(n)
     true
  end
end

def f(n)
  Cheat.new
end

这给了我们：

>> f(f(1)) == -1
=> true

但也（不太令人惊讶）

>> f(f(1)) == "hello world"
=> true

Answer 88

int f(const int n)  {
    static int last_n;

    if (n == 0)
        return 0;
    else if (n == last_n)
        return -n;
    else
    {
        last_n = n;
        return n;
    }
}

骇人听闻，但正确。

Answer 89

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

Answer 90

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) 

Answer 91

SQL服务器中的一种解决方案

create function dbo.fn_fo(@num int) -- OUTER FUNCTION
RETURNS int
AS
begin
RETURN @num * -1
end
GO

create function dbo.fn_fi(@num int) -- INNER FUNCTION
RETURNS int
AS
begin
RETURN @num * -1
end
GO

declare @num AS int = -42
SELECT dbo.fn_fo(dbo.fn_fi(@num)) -- Gives (-42)

Answer 92

也许我错过了什么？

这不是简单的事情吗：

    function f(n)
    {
        if(n ==0 || n < 0){return n;}
        return n * -1;
    }

编辑：

所以我错过了这个问题，哼哼，所以：

    function f(n)
    {
        if(!c(n,"z")&&!c(n,"n")){if(n==0){return "z"+n;}return "n"+n;}
        if( c(n,"z")){return 0;}return parseInt(n.replace("n",""))*-1;
    }
    function c(x,y){return x.indexOf(y) !==-1;}

丑陋但有效。

Answer 93

f(x) = 在二维笛卡尔坐标系中绕原点逆时针旋转 90 度的点 (x)。 只有一个数 x 的输入被假定为 (x, 0)，并且 y=0 的输出被提供为单个数 x。

object f: (object) x {
    if (x.length == 1)
        x = (x, 0)
    swap = x[0]
    x[1] = x[0]
    x[0] = -swap
    if (x[1] == 0)
        x = x[0]
    return x

Answer 94

我承认我会作弊，但仍然符合要求。 这是编程魔法，而不是真正的数学。 它适用于整个范围，除了-2 ^ 31。

int f(int n)
{
    static bool eFlag = false; // Only executed once
    eFlag = !eFlag;
    return eFlag?-n:n;
}

Answer 95

C++中的另一种作弊解决方案，运算符重载。

struct func {
    int n;
    func operator()(int k) { n = -k; return *this; }
    int operator()(const func &inst) { return inst.n; }
} f;

Answer 96

Objective-C

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

如果您要 go 从使用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 逻辑存储在 state 中，数字是奇数还是偶数。

Answer 97

我相信这符合所有要求。 没有说参数必须是 32 位有符号整数，只是你传入的值 'n' 是。

long long f(long long n)
{
    int high_int = n >> 32;
    int low_int  = n & 0xFFFFFFFF;

    if (high_int == 0) {
        return 0x100000000LL + low_int;
    } else {
        return -low_int;
    }
}

Answer 98

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 。

Answer 99

我试着打高尔夫罗德里克查普曼的这个答案。

无分支： 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%。 （正数和负数的随机数据集，足够的重复并阻止编译器优化代码，并进行预热。）这并不奇怪，考虑到非分支版本中的操作数量和可能的良好分支预测，因为事实上function 被调用两次： f(f(i)) 。 当我将基准更改为 measure: f(i)时，分支版本仅快 28%。 我认为这证明了分支预测在第一种情况下确实做得很好。 更多证明：当使用f(f(f(f(i))))进行测试时，分支版本的速度提高了 42%。

Answer 100

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] 仍未计算。

Answer 101

C# 过载：

string f(int i) {
  return i.ToString();
}

int f(string s) {
  return Int32.Parse(s) * -1;
}

或者

object f(object o) {
  if (o.ToString.StartsWith("s"))
    return Int32.Parse(s.Substring(1)) * -1;
  return "s" + i.ToString();
}

Answer 102

Tcl：

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

% f [f 1]
-1

沿着其他一些答案的思路......如果它是 integer，请返回一个返回该数字的负数的命令。 如果不是数字，则对其进行评估并返回结果。

Answer 103

这是一个 C/C++ 解决方案，不使用任何位运算符，也不需要任何数学库，尽管它有点作弊......

double f(double n)
{
    if (n == (double)(int)n)
        return n + 0.5;
    else
        return -(n - 0.5);
}

这适用于所有 32 位整数，唯一的例外是0x80000000 （因为它的反面不能存储在 32 位 integer 系统中）。 f(f(n)) == -n将始终为true ，除非在这种情况下。

不过，我确信有一种更简单、更快捷的方法来实现它。 这只是浮现在脑海中的第一件事。

Answer 104

Javascript

function f(n)  { 
        return typeof n === "number" ? 
        function() {return -n} : 
        n();
}

Answer 105

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

受@eipipuz 回答的启发，我写了这个 C++ function （但没有运行它）：

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

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

如果我们继续运行f(n)并将另一个f(n)作为参数n ，最左边的两位将像这样旋转：

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

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

示例 1：

• > f(00001111) = 01001111
• > f(01001111) = 10001111 [这是原始值的负数，00001111]

示例 2：

• > f(11101010) = 00101010
• > f(00101010) = 01101010 [这是原始值的负数，11101010]

Answer 106

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

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

    return ret;  
}  

Answer 107

我不知道这是否完全正确，但是一个简单的标志不起作用吗？ 在 C 中，使用 static 局部变量，我成功地做到了：

int main()
{
    int n = -256; // 32-bit signed integer
    printf("%d", f(f(n)));
}

int f(int n){
    static int x = 0; // not returning negative;
    switch(x){
        case 0:
            x = 1;
            return n;
            break;

        case 1:
            x = 0;
            return -n;
            break;
        default:
            return -999;
            break;
    }
}

Answer 108

#include <cmath>

int f(int n)
{
    static int count = 0;
    return ::cos(M_PI * count++) * n;
}

Answer 109

在awk中，由于几乎没有传递任何信息，因此必须采用允许 state 信息作为 ZC1C425268E68385D1AB5074C17A94F14 的一部分传递的方法，而不会传递返回的可用性：

jot - -5 5 | mawk 'function _(__,___) { 

     return (__~(___=" ")) \
      \
      ? substr("",sub("^[ ]?[+- ]*",\
        substr(" -",__~__,index("_"___,___)-\
              (__~"[-]")),__))\
            (__~"[-]"?"":___)__\
      : (+__<-__?___:(___)___)__ 

  } BEGIN { CONVFMT=OFMT="%.17g" 
  } { 
      print "orig",           +(__=$(__<__))<-__?__:" "__,
            "f(n)....",        _(__),_(_(__)),_(_(_(__))),
                         _(_(_(_(__)))), _(_(_(_(_(__))))) 

  }' |gcat -n | lgp3 5 

 1  orig -5 f(n)....  -5   5  -5   5  -5
 2  orig -4 f(n)....  -4   4  -4   4  -4
 3  orig -3 f(n)....  -3   3  -3   3  -3
 4  orig -2 f(n)....  -2   2  -2   2  -2
 5  orig -1 f(n)....  -1   1  -1   1  -1

 6  orig  0 f(n)....   0  -0   0  -0   0
 7  orig  1 f(n)....   1  -1   1  -1   1
 8  orig  2 f(n)....   2  -2   2  -2   2
 9  orig  3 f(n)....   3  -3   3  -3   3
10  orig  4 f(n)....   4  -4   4  -4   4

11  orig  5 f(n)....   5  -5   5  -5   5

所以这样做的限制是，只有整数或浮点值已经是字符串格式，可以使用而不会冒险，因为额外的 ASCII 空间\040被添加为 state 信息

这种方法的好处是

1. 它愿意为您提供“负零”，

2. 对于绝对值小于2^53的整数，只需添加一个加号，

   即+f(f(_))

   到 function 调用本身将代表您进行隐式类型转换，结果值将再次为数字

   对于大整数，只需substr()任何前导空格

3. 轻松处理大整数，而不会有因类型转换为双精度浮点数而损失精度的风险

`

    1   orig -99999999999999999999999999999999 
        f(n).... 
             -99999999999999999999999999999999   
              99999999999999999999999999999999
             -99999999999999999999999999999999   
              99999999999999999999999999999999  
             -99999999999999999999999999999999

 2  orig      -1239999999999999999999999999999 
    f(n)....  -1239999999999999999999999999999                   
               1239999999999999999999999999999
              -1239999999999999999999999999999
               1239999999999999999999999999999
              -1239999999999999999999999999999`

Answer 110

我参加这个聚会迟到了，现在可能是个墓地。 但是我有 2 个贡献，灵感来自viraptor以前的 Python 使用 lambda 的答案。 读者可能认为该解决方案仅在无类型语言中可行，并且在有类型语言中需要一些显式的额外标记。

但下面是 Haskell 中的解决方案 1 （我不是 Haskell 专家）。 它有点作弊，因为从技术上讲，这两个f是两种不同的实现。 （一个f:: Int -> () -> Int ，另一个f:: (() -> Int) -> Int ）

{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, FunctionalDependencies #-}

module Main where

class Tran σ τ | σ -> τ where
  tran :: σ -> τ

instance Tran Int (() -> Int) where
  tran n = \_ -> (-n)

instance Tran (() -> Int) Int where
  tran g = g ()

f :: Tran σ τ => σ -> τ
f = tran

main :: IO ()
main = do
  print $ f (f (42 :: Int)) -- --> -42
  print $ f (f (0 :: Int)) -- --> 0
  print $ f (f (-69 :: Int)) -- --> 69

接下来是 Typed Racket 中的解决方案 2 。 这个满足可能的最大域的属性，因为 Racket 中的Number最多包含复数：

#lang typed/racket

(: f (case->
      [Number -> (-> Number)]
      [(-> Number) -> Number]))
(define (f x)
  (if (number? x) (λ () (- x)) (x)))

(f (f 42))    ; --> -42
(f (f 0))     ; --> 0
(f (f -69))   ; --> 69
(f (f 3/4))   ; --> -3/4
(f (f 8+7i))  ; --> -8-7i

Answer 111

这个想法已在其他答案中使用，但我将其放入 Python 的一行中：

def f(n):
    return str(n) if type(n) == int else -int(n)

Answer 112

使用循环置换方法来做到这一点。

-bab -a

ab -a -b

在平凡的情况下 f(0) 返回 0

抱歉我的电话粗略回答，28 日之后我将发布一个完整版本（现在正在检查......）简要地说，认为 f(n) 是一个循环排列，问题是如何构造它。

定义 fk = f(f(f(f(...f(n))))) (k fs) 情况 k=2 0.普通情况 f(0) 返回 0 1. 分组，情况 k=2 ，组：{0} {1,2} {3,4}... {n,n+1 | (n+1)%2 = 0 }，注意：我只使用Z+，因为构造不需要使用负数。 2.构造置换：如果n % 2 = 0，那么a=n-1 b=n 如果n % 2 = 1，那么a=nb=n+1

这将产生相同的排列，因为 n 和 f(n) 在同一组中。

注意排列为 P 返回 P(n)

对于 k=2t，只做上面相同的事情，只是 MOD k。 对于k=2t-1，虽然方法行得通，但是没有意义，啊？ (f(n) = -n 没问题)

Answer 113

保存 state 是作弊，但它可以工作，将操作分成两部分： -n = (~n + 1) 表示整数

int f(int n) {
    static int a = 1;
    a = !a;
    if (a) {
        return (~n);
    } else {
        return (n+1);
    }
}

Answer 114

was hinting at a modular arithmetic solution.我认为暗示了模块化算术解决方案。 在一些模基 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)

Answer 115

int f(int x){
    if (x < 0)
        return x;
    return ~x+1; //two's complement
}

Answer 116

PHP，不使用全局变量：

function f($num) {
  static $mem;

  $answer = $num-$mem;

  if ($mem == 0) {
    $mem = $num*2;
  } else {
    $mem = 0;
  }

  return $answer;
}

适用于整数、浮点数和数字字符串！

刚刚意识到这做了一些不必要的工作，但是，无论如何

Answer 117

不记得你的最后一个 state 是一个足够好的答案吗？

int f (int n)
{
    //if count 
    static int count = 0;

    if (count == 0)
        { 
            count = 1;
            return n;
        }

    if (n == 0)
        return 0;
    else if (n > 0)
    {
        count = 0;
        return abs(n)*(-1);
    } 
    else
    {
        count = 0;
        return abs(n);
    }
}

int main()
{
    int n = 42;
    std::cout << f(f(n))
}

Answer 118

我还没有看过其他答案，我假设已经彻底讨论了按位技术。

我以为我会在 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();
}

整个ImplicitlyConvertibleToInt类型和重载是必要的，因为临时对象不能绑定到非常量引用。

当然，现在看它是不确定的f(n)是否在-n之前执行。

对于这种程度的邪恶，也许更好的解决方案很简单：

struct ComparesTrueToInt
{
    ComparesTrueToInt(int) { } // implicit construction from int
};
bool operator == (ComparesTrueToInt, int) const { return true; }

ComparesTrueToInt f(ComparesTrueToInt ct) { return ComparesTrueToInt(); }

Answer 119

少于 50 个字符 (C#)

int f(int n) { return (n <= 0) ? n : f(-n); }

或者更容易阅读：

static int f(int n) { 
  if (n <= 0)
    return n;
  else 
    return f(-n);
}

去测试

static void Main(string[] args) {
    for (int n = int.MinValue; n < int.MaxValue; n+=1) {
        Console.Out.WriteLine("Value: " + n + " Result: " + f(f(n)));
    }
}

它有效（假设我正确理解了这个问题）

Answer 120

怎么样

int f(int n)
{
    return -abs(n);
}