我认为最大的可能范围是暗示模块化算术解决方案。在一些模基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）

根据您的平台，某些语言允许您在函数中保持状态。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（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

MIN_INT不会失败：

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

目标-C

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

如果要从使用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逻辑存储为奇数或偶数的状态。

很简单，只需让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);
    }
}