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

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

这适用于所有32位整数，只有一个异常0x80000000（因为它的相反值不能存储在32位整数系统中）。f（f（n））==-n将始终为真，除非在这种情况下。

不过，我相信有一种更简单、更快的方法来实现它。这只是我第一个想到的。

适用于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
}

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

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

从来没有人说过f（x）必须是同一类型。

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


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

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

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

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

在PHP中

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

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

这个解决方案的妙处在于，无论您是从字符串还是整数开始，它都是有效的，并且在返回f（n）时不会明显改变任何内容。

在我看来，面试官在问，“这位应聘者是否知道如何标记数据以供以后操作”，以及“这位应聘人员是否知道如何在最少更改数据的情况下标记数据？”你可以使用双精度、字符串或任何其他你想使用的数据类型来实现这一点。