我经常访问一个编程博客，激发了这一挑战。请在此处查看原始帖子：编程难题

挑战

定义一个函数f:Q->Q，以便f(f(n)) = -n对所有非零整数n，其中，Q是有理数的集合。

细节

请使用您喜欢的任何语言定义一个函数或程序f，该函数或程序接受一个数字作为参数n并返回或输出一个数字f(n)。

可以通过最适合您的语言的机制来提供输入：函数自变量，从STDIN读取，命令行自变量，堆栈位置，语音输入，帮派标志等。

输出应该是功能/程序的返回值或打印到STDOUT。

我想将答案限制为不利用程序状态或从函数外部可见的全局内存/数据的函数f。例如，将计数器保留在该计数之外将对调用f次数f进行计数，并且仅基于此计数进行否定对任何人来说都不是挑战或有趣的事情。做出的决定f应仅依赖f词法范围内的数据。

但是，此限制可能不适用于某些面向堆栈的语言或其他无法区分这些类型的数据或范围的语言。请运用您最好的判断力来迎接挑战的精神。

计分

通用代码高尔夫规则适用-您的得分是源代码中的字节数。

最小答案要求的域和共域是f有理数的子集Q。如果将的域和共域限制f为整数Z，则分数是源代码中字节数的90％的上限。

抢七

如果出现平局，将按以下顺序使用：

1. 源代码中可打印的非空白符号数量最少
2. 最早提交答案的日期和时间

编辑

您不需要支持任意大小的数字。请使用您选择的语言（通常分别为整数和浮点）解释集合Z和Q数据类型。

如果您的解决方案完全依赖于数据类型的基础结构或位模式，请描述其局限性以及如何使用它。

J，9分（10个字符）

基于stackoverflow答案：

   (*-[*_1&^)

第一个想法（13个字符）：

   ((-*)-2&|*+:)

   ((-*)-2&|*+:) _10 _9 _8 _7 _6 _5 _4 _3 _2 _1 0 1 2 3 4 5 6 7 8 9 10
_9 10 _7 8 _5 6 _3 4 _1 2 0 _2 1 _4 3 _6 5 _8 7 _10 9

   ((-*)-2&|*+:) _9 10 _7 8 _5 6 _3 4 _1 2 0 _2 1 _4 3 _6 5 _8 7 _10 9
10 9 8 7 6 5 4 3 2 1 0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _10

Python：61 34 30 29 27点

f：Q-> Q

在数学上：

       | 0.5-x   if x is in Q \ Z
f(x) = |
       | x+0.5   if x is in Z

在Python中：

f=lambda x:.5+[x,-x][x%1>0]

经过测试

filter(lambda n: n[0] != -n[1], map(lambda n:(n,f(f(n))),range(0,50)))

背后的逻辑：

当您取一个整数n并将其放入时，f您将得到x+0.5。这不再是整数，因此下一个应用程序将0.5-(x+0.5)是-x。

学分

谢谢

• Bakuriu将其从61个字符减少到34个字符。
• 可变性，可将代码大小进一步减少到30个字符。
• 复制，以将代码大小减少到29个字符（并解决潜在的浮点问题）。
• aditsu提到了上述更改带来的不一致。

笔记

首先，我认为可以

f = lambda n: 1j*n

但是它的f：N-> C是不允许的：-/

C，41点（41或45个字符）

可同时使用32位和64位。

f : Z -> Z（除外INT_MAX）：

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

如果我们不必包括，0则可以删除一些字符（41个字符）：

f : Z -> Z（0＆除外INT_MAX）：

f(n){return (abs(n)%2*2-1)*n+(-n<n)*2-1;}

此函数通过将所有整数根据其符号和奇偶校验分为4组来工作。

因此，我们有4种不同的组合：

+ even, + odd, - even, - odd

由于我们需要切换数字的符号，而不是两遍之后的奇偶校验，因此我们得到了两个不同的可能序列：

  + even -> - odd -> - even -> + odd -\
^-------------------------------------/

  + even -> + odd -> - even -> - odd -\
^-------------------------------------/

在此示例中，我选择了第一个。

首先，我们需要将所有偶数正整数映射到奇数负整数。我们通过更改符号并增加数字来做到这一点（您也可以选择减少数字）：

f1(n) = -n + 1

然后，我们需要将所有奇数负整数映射为偶数负整数。我们需要确保f2(f1(n)) = -n：

f2(f1(n)) = -n
f2(-n + 1) = -n
f2(-n) = -n - 1
f2(n) = n - 1

使用相同的方法，我们发现f3和f4：

f3(n) = -n - 1
f4(n) =  n + 1

要将这些功能组合为一个功能，我们观察到每次n切换偶数的符号，n每次n为正时，我们加一，否则我们减一：

f1(n) = -n + 1 (+ even)
f2(n) =  n - 1 (- odd)
f2(n) = -n - 1 (- even)
f4(n) =  n + 1 (+ odd)

因此，可以将其重写为：

f(n) = odd(n) * n + sign(n)

其中odd(n)返回1奇数和-1偶数。

共有4个解决方案：

f(n) = odd(n) * n + sign(n)  (edge cases: f(f(0))  -> -2, f(f(INT_MAX))   -> -8)
f(n) = even(n) * n - sign(n) (edge cases: f(f(0))  -> -2, f(f(INT_MIN+1)) -> -6)
f(n) = odd(n) * n - sign(n)  (edge cases: f(f(1))  -> -3, f(f(INT_MIN))   -> -5)
f(n) = even(n) * n + sign(n) (edge cases: f(f(-1)) -> -1, f(f(INT_MIN))   -> -5)

INT_MIN在-INT_MIN == INT_MIN=>的所有4个函数中，可能总是被视为边缘情况f(f(INT_MIN)) = INT_MIN。

这是我的努力。

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

现场示例：

int main()
{
  for(int i=-10; i<10; i=i+3)
    std::cout << f(f(i)) << "\n";
}

输入类型cn可以根据您的需要任意定制。此版本适用于大小小于2 ^ 32-1的整数文字。

JavaScript，18岁

f=n=>n%1?.5-n:n+.5

使用新的粗箭头符号（Firefox 22）。

其他版本（18）：

f=n=>n%1?-.5/n:.5/n

先前版本（20）：

f=n=>n-~~n?.5-n:n+.5

例：

> [-3,-2,-1,1,2,3].map(f).map(f)
[3, 2, 1, -1, -2, -3]

Mathematica 18

f=#+1/2-4#(#-⌊#⌋)&

这⌊...⌋是发言权功能。它仅使用有理数（不包括列表，复数等）

f[10]
f[f[10]]

21/2

-10

f[-5]
f[f[-5]]

-9/2

5

x86汇编语言（FASM）。参数和结果在eax寄存器中。

适用于-2 ^ 30 <N <+ 2 ^ 30-1

16个字节的可执行代码。

        use32

f_n:
        lea     edx, [2*eax]
        xor     edx, eax
        btc     eax, 30
        shl     edx, 1
        jnc     .end
        neg     eax
.end:
        retn

通用Lisp：35个字节

(defun f(x)(/(if(> 1 x)-1/2 1/2)x))

方案（和球拍）：36个字节

(define(f x)(/(if(> 1 x)-1/2 1/2)x))

取消评论和解释：

(define (f x)
  (/             ;; divide
     (if (> 1 x) ;; if x is below 1 
         -1/2    ;; then -1/2 (the fraction)
         1/2)    ;; else 1/2 (the fraction)
      x))        ;; gets divided with x

对于任何号码x在[1,->]该if会变成分数1/2是在两种语言真实的确切数目。

然后，除法部分将变为，(/ 1/2 x)因此分数1/(x*2)始终低于1。因为1它将是1/2，因为2它是1/4等等。

对于小于1的任何数字，if它将变成小数-1/2，这使函数做到了(/ -1/2 x)，-1/(2*x)但是由于我们可以期望该值是上一次运行的结果，因此可以将x替换为1 /（x * 2）进行两次应用-1/((1/(x*2))*2) = -x

例如，由于1转到1/2第二个应用程序是(/ -1/2 1/2) ==> -1

C，60（⌈66*.9⌉）

int f(int x){if(!x&1||!~x)return ~x;if(x<0)return x-1;return x+1;}

这是一个未压缩的版本：

int f(int x){
    if(!x&1 || !~x) return ~x;
    if(x<0) return x-1;
    return x+1;
}

此方法仅使用整数，因此可获得90％的分数加分。我最初是用Java编写的，但意识到该程序尤其可以从C风格的逻辑运算符中受益。

由于没有与对应的整数-INT_MIN，因此f(f(INT_MIN))返回INT_MIN。

底层映射在代数上相当简单。执行该语句x=f(x)将x替换为：

• x+1，如果x是正数和奇数
• -x+1，如果x是积极甚至
• x-1，如果x是负数和奇数
• -x-1，如果x是负数，甚至

下次将函数应用于x时，每种情况的结果都将落在下一种情况下。

如您所见，将一个案例与紧随其后的案例进行组合会产生-x。

该代码是对函数进行一些巧妙简化的结果，以利用二进制补码整数的位结构。

> <>，21 + 3 = 24字节，22点

:0)$:0($:1$2%2*-*+-n;

使用官方的Python解释器，并使用-v命令行选项输入输入，费用为3个字节。

我感觉这会更好-我会继续研究并尝试将其击倒。

给定输入n，程序输出

(n>0) - ((n<0) + n * (1 - 2*(n%2)))

哪里(n>0)和(n<0)是布尔值。这等效于明胶的Python答案

(n>0) - (n<0) - n * (-1)**n

但><>没有内置的幂运算符，因此我们使用(1 - 2*(n%2))代替(-1)**n。

接下来是数学理论-如果（且仅）您感兴趣，请阅读：

给定任何函数f: Z -> Z，f(f(n)) = -n对于nin 中的所有函数Z，我们将立即看到f(f(f(f(n)))) = n，或者换句话说，f^4是身份函数。特别是，f是可逆的，其逆函数是f^3。因此f是的置换Z，并且因为f^4 = Id，它遵循的每轨道（或周期）f具有大小两种1，2或4。

接下来，我们看到f(0) = 0。证明：f(0) = f(-0) = f(f(f(0))) = -f(0)，因此f(0) = 0，根据需要。相反，假设x是在长度的一个周期1或2，所以f(f(x)) = x。那就-x = x这样x = 0。

因此f，除了处的固定点（1个周期）外，它完全由4个周期组成0。

此外，每个4周期必须具有形式(x, y, -x, -y)，并且通过旋转该周期，我们可以假定x和y均为正。相反，将非零整数分区的4个周期的每个此类乘积确定的选择f。

因此，每个的选择f唯一地对应于一个有向图，该有向图的顶点是正整数，因此每个顶点都准确地入射到一个箭头，无论该箭头是进入还是退出。更准确地说，在基础无向图中，每个顶点都精确地具有度1。（(x y -x -y)带有x和y正号的每个4周期对应于箭头x --> y。）

在这个答案（这里其他几个答案）的功能对应于图，其中1 --> 2，3 --> 4和一般2k-1 --> 2k。

这样的图是具有无限对有序对的序列的双射图(a_n, p_n)，其中每个a_n是一个正整数，每个p_n是0或1：或者给定一个序列(a_1, p_1), (a_2, p_2), (a_3, p_3), ...，我们首先1与配对1 + a_1，然后根据是还是形成箭头1 --> 1 + a_1或箭头。本质上，取决于的奇偶性，箭头可以是符号，也可以是符号。1 + a_1 --> 1p_101<>p_1

接下来，取最小的未配对正整数k，并从中k精确计数a_2，跳过已与某物配对的任何数字。k与结果配对，然后根据p_2上述方法设置箭头的方向。然后用重复(a_3, p_3)，等等。

每个箭头最终都将以这种方式确定，因此过程定义明确。这个答案中的函数与序列相对应(1,0), (1,0), (1,0), ...，因为在步骤中n，最小的未配对整数为，2n-1并且没有大于2n-1已与任何对象配对的整数，因此我们得到2n-1 --> 2n了每个n（因为每个箭头都p_n等于，所以以这种方式定向箭头0）。

该集合的基数为(N*2)^N = N^N，在该答案的最后一段中等于2^N实数的基数。

要解决早期的J答案（我没有足够的声誉来评论原始答案）：

(*+[*1-~2*2|])

它只是取代了_1&^有1-~2*2|]，这给了相反的符号。所以我改变了-一个+（只事项的输入1和_1）。

测试如下：

   (*+[*1-~2*2|])6 3 _9 _8 1r2 _4.6 0 1 _1
7 _2 8 _9 1 7.28 0 2 _2
   (*+[*1-~2*2|])7 _2 8 _9 1 7.28 0 2 _2
_6 _3 9 8 0 _10.3568 0 _1 1

   NB. f^:2 = f@:f
   (*+[*1-~2*2|])^:(2)6 3 _9 _8 1r2 _4.6 0 1 _1
_6 _3 9 8 2 _5.0832 0 _1 1

如您所见，域和范围均为实数，但仅适用于整数（包括0）。

说明：

(   *     + [ *  1-~    2*     2|]    )
 signum n + n * pred (twice (n mod 2))

高尔夫脚本 ceiling(26*.9)=24

Golfscript仅处理整数，因此，将Z奖金总共应用24点：

.{..0>2*(\)2%!2*(@*+}{ }if

0的特殊情况占8个字符。忽略0，我们可以得到17分的答案：

..0>2*(\)2%!2*(@*+

此代码x对堆栈顶部的整数执行以下操作：

• 如果x为0，0则不使用任何规则。
• 如果x是偶数，则取反x。
• 如果x为正，则添加1。
• 如果x为负，则减去1。

这在一个循环中逻辑地连接4个数字的集合，其中f遍历该循环的元素，并且该循环的相对角彼此为负。每个整数都是1个此类循环的一部分，除了0（特殊情况）外。例如，对于{-8, -7, 7, 8}：

• 7 f -> 8
• 8 f -> -7
• -7 f -> -8
• -8 f -> 7

我能想到的唯一相关的测试用例是负数奇数，负数偶数，正数奇数，正数偶数，0然后我投入讨论-1，1因为它们的接近0可能导致了问题：

[-10 -5 -1 0 1 5 10]
{.{..0>2*(\)2%!2*(@*+}{ }if}:f;
{f f}%
-> [10,5,1,0,-1,-5,-10]

我确信实际的GolfScript可以有所改善。好像不应该占用26个字符！很想听听一些建议。

Java，只是为了好玩

这是一个在ℤ和ℤ²之间进行实际双射的实现，这同时是一个奇函数（g（-x）== -g（x））。它将对应的ℤ²元素视为复数并将其乘以“ i”，然后转换回ℤ。

f（x）=g⁻¹（ig（x））
f（f（x））=g⁻¹（-g（x））=-x

该函数在O（1）中运行。

public class Ffn {
    public static int f(int n) {
        if (n == 0) {
            return 0;
        }
        // adjust sign
        int s = n > 0 ? 1 : -1;
        int m = n * s;
        // calculate square "radius"
        int r = (int) (Math.sqrt(2 * m - 1) + 1) / 2;
        int q = r * 2;
        // starting point
        int x = r, y = r;
        int k = q * (r - 1) + 1;

        if (m - k < q) {
            // go left
            x -= m - k;
        }
        else {
            // go left
            x -= q;
            // go down
            y -= m - k - q;
        }

        // multiply by i
        int x2 = -y * s, y2 = x * s;
        // adjust sign
        s = y2 < x2 || y2 == x2 && x2 < 0 ? -1 : 1;
        x2 *= s;
        y2 *= s;

        if (y2 == r) {
            // go left
            k += r - x2;
        }
        else {
            // go left and down
            k += q + r - y2;
        }
        return k * s;
    }

    public static void main(final String... args) {
        for (int i = 0; i < 1000000; ++i) {
            if (f(f(i)) != -i || f(f(-i)) != i) {
                System.out.println(i);
            }
        }
    }
}

PS新年快乐！

Python 3-38

与@moose的答案类似，但是f(n) == n。适用于所有整数值。

f=lambda x:x*(isinstance(x,int)*2.0-1)

Perl，33岁（非空白）

sub f{($=)=@_;$=-$_[0]?-$=:"$=.1"}

编辑：

• $=.".1"缩短为"$=.1"（感谢ardnew）。

数学：

取消高尔夫：

# script.pl
sub f {
  ($=) = @_;   # short for $= = int($_[0]); 
               # "int" is implicit in assignments to $=;
               # ($=) can be prepended by "local" to get
               # the function free of side effects.

  $= - $_[0] ? # short for $= != $_[0], check if input is integer
    -$=        # input is not an integer  
  : $= . ".1"  # input is integer
}  

# Testing
chomp;
$_ = sprintf "f(f($_)) = f(%s) = %s\n", f($_), f(f($_));

例子：

perl -p script.pl
7
f(f(7)) = f(7.1) = -7
2
f(f(2)) = f(2.1) = -2
0
f(f(0)) = f(0.1) = 0
-1
f(f(-1)) = f(-1.1) = 1
-10
f(f(-10)) = f(-10.1) = 10
-1.23
f(f(-1.23)) = f(1) = 1.1
3.4
f(f(3.4)) = f(-3) = -3.1
1.0
f(f(1.0)) = f(1.1) = -1

朱莉娅26岁

julia> f(n::Int)=n//1
f (generic function with 1 method)
julia> f(n)=int(-n)
f (generic function with 2 methods)
julia> f(f(4))
-4

不是超级竞争，但是朱利安（Julian）非常重要，因为它依赖于多个调度。如果它是Int，则使na不合法；如果其他任何值，则使它具有负号。一个人可能会反对说这是2个函数，但是Julia认为这是一个有两种方法的函数，它等效于使用类型为if的语句定义一个函数n。

糖果，20 18字节

使用3-> 4-> -3-> -4-> 3技巧。

~A2%{|m}1A0>{+|-}.

要调用它，请使用解释器上的-i开关

双重发票示例：

$ candy -i 7 -e '~A2%{|m}1A0>{+|-}.'
program length: 18
>>> 8
$ candy -i 8 -e '~A2%{|m}1A0>{+|-}.'
program length: 18
>>> -7
$ candy -i -7 -e '~A2%{|m}1A0>{+|-}.'
program length: 18
>>> -8
$ candy -i -8 -e '~A2%{|m}1A0>{+|-}.'
program length: 18
>>> 7

长表：

peekA
pushA
digit2
mod          # even/odd
if
else
  negate     # negate even numbers
endif
digit1
pushA
digit0
greater      # positive/negative
if
  add        # add two numbers from stack (original stack value, and delta)
else
  sub        # diff two numbers from stack (original stack value, and delta)
endif
retSub

Dyalog APL，9分

×-⍨⊢ׯ1*⊢

源是9个字节长，有资格获得赠金（完全没有帮助）。它还使用顶部SO答案中的公式。

Python：32个字节（29分）

f：Z-> Z

f=lambda n:(n>0)-(n<0)-n*(-1)**n

使用Ben Reich的方法。

山地车队 22

@S;N,"--$x?N)→N~N#~-N&

Java，113个字节

该方法非常简单。它最终产生了比我预期的更多的字节，但是也许可以降低一点。

public class F{public static int f(int x){if(x<0)x+=-2147483647-++x;x+=1073741824;return x<0?-2147483647-++x:x;}

它利用Java愉快地让变量环绕的事实，基本上创建了x的4个不同的“区域”。我必须对负数进行一些棘手的转换，这是导致最终结果超出预期的主要原因。

除-2147483648外，还适用于所有x。

与golfscript答案相同的数字序列（3、4，-3，-4、3 ...），但在perl中实现（去除空格后为42个字符）

sub f{($_[0]%2?1:-1)*$_[0]+($_[0]<0?-1:1)}

更清晰：

sub f { ($_[0] % 2 ? $_[0] : -$_[0] ) + ( $_[0] < 0 ? -1 : 1 ) }

甚至更清晰：

sub f {
  my $n = shift;
  my $sign = $n >= 0 ? 1 : -1;
  # note that in perl $n % 2 is the same as int($n) % 2
  if( $n % 2 ) {
    # odd: add one to magnitude
    return $n + $sign
  } else {
    # even: subtract one from magnitude then invert
    return -($n - $sign)
  }
}

输出：

ski@anito:~/mysrc/.../acme$ echo 3 | perl -e 'sub f{($_[0]%2?1:-1)*$_[0] + ($_[0]<0?-1:1)}; my $x = <>; for(0..10) { print "$_: $x\n"; $x = f($x); }'
0: 3
1: 4
2: -3
3: -4
4: 3
5: 4
6: -3
7: -4
8: 3
9: 4
10: -3

Sed，25个字节。

|sed s/0+/0-/|sed s/^/0+/

用法：

$ echo 1.23 |sed s/0+/0-/|sed s/^/0+/
0+1.23
$ echo 0+1.23 |sed s/0+/0-/|sed s/^/0+/
0+0-1.23

Matlab，26个字符

f=@(n) (n<0)-(n<0)-n*(-1)^n

C ++- 63 55.8

代码如下所示：

int f(int n){return (n&45056?n^45056:n|45056)*(n&45056?-1:1);}

它不适用于第四个字节等于0xB的整数，因为它使用该值来跟踪通过。否则，将对Z的任何成员（包括零）起作用。

更新了Synthetica提供的功能（显然现在应该为此功劳的人）

语言：Python

字符数：41个，包括空格

f=lambda x:-float(x) if str(x)==x else`x`

Prolog，36个字节

码：

X*Y:-X//1=:=X,Y is 0.5+X;Y is 0.5-X.

解释：

Dyadic predicate which converts integers to floats and floats back to negated integers.

例：

10*X.
X = 10.5

10*Y,Y*X.
X = -10,
Y = 10.5

JavaScript的ES6，27 26个字节

a=>a%1?-Math.floor(a):a+.2

鼠标2002，21个 19 12字节

$A1%[1%_|1%]

定义一个功能A; 称呼它#A,#A,?;;（它将等待用户输入任何数字）。另外，也可以像#A,#A,n;;在哪里一样叫它n。

朱莉娅，21岁

f(x)=(1-2(1>x>-1))/2x

然后

julia> f(f(12//1))
-12//1

p // q是茱莉亚对有理数的字面表示。