这很简单！

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

例子：

规则如下：

0→ 0±2³¹ → ±2³¹古怪的→ 甚至，甚至→ -奇数：对于所有k，0<k<2³⁰: （2k-1）→ （2k）→ （-2k+1）→ （-2k）→ （2k-1）

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

在一的补码系统中，存在+0和-0。我们开始了：

对于所有k，0<k<2³⁰: （+2k）→ （+2k+1）→ （-2k）→ （-2k-1）→ （+2k）

很简单，只需让f返回看起来等于任何整数的值，并且可以从整数转换。

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

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

怎么样：

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

PHP，不使用全局变量：

function f($num) {
  static $mem;

  $answer = $num-$mem;

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

  return $answer;
}

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

只是意识到这会做一些不必要的工作，但是，不管怎样

嗯，我既不是数学，也不是编程高手，但这不是很容易吗？

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

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

或者我错过了什么？