我承认我会作弊，但还是符合要求。这是编程魔术，而不是数学。它适用于整个范围，-2^31除外。

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

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

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

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

用咖啡脚本打高尔夫：

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

使用循环置换方法来实现这一点。

-b a b-a

a b-a-b

在微不足道的情况下f（0）返回0

对不起，我的电话回答很粗糙，28日后我将发布完整版本（现在正在检查…）简单地说，假设f（n）是一个循环排列，问题是如何构造它。

定义fk=f（f（f）f（…f（n））））（k fs）情况k=20.微不足道的情况f（0）返回01.分组，在情况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=n b=n+1

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

注意排列为P返回P（n）

对于k＝2t，只做上面相同的事情，只做MOD k。对于k＝2t-1，虽然该方法有效，但毫无意义，啊？（f（n）=-n正常）

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

我认为这不是一个很好的主意。

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

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