この課題は、私が頻繁に使用するプログラミングブログに触発されました。ここで元の投稿を参照してください：プログラミングパズル

チャレンジ

すべての非ゼロ整数、およびが有理数のセットであるf:Q->Qような関数を定義します。f(f(n)) = -nnQ

詳細

あなたが好みの言語では、定義してください1つの機能やプログラムf、パラメータとして受け入れる1の数nを返すまたは出力1つの数を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。

クレジット

おかげで

• 61文字から34文字にそれを削除するためのBakuriu。
• コードサイズをさらに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

2つのパスの後、パリティではなく数の符号を切り替える必要があるため、2つの異なるシーケンスを取得できます。

  + 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

これらの関数を1つの関数に結合するために、毎回n符号が切り替わり、n毎回n正になると1ずつ増加し、それ以外の場合は1ずつ減少することがわかります。

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)

where 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

Common 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,->]if1/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、if xが正で奇数
• -x+1、x正の場合、偶数
• x-1、xが負で奇数の場合
• -x-1、x負の場合、偶数

各ケースの結果は、次に関数がxに適用されるときに次のケースに該当します。

ご覧のとおり、ケースとそれに続くケースを構成すると、が得られ-xます。

このコードは、2の補数整数のビット構造を利用するための、関数の巧妙な単純化の結果です。

> <>、21 + 3 = 24バイト、22ポイント

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

使用する公式のPythonインタプリタを、そして使用-v3バイトの費用で、入力を入力するには、コマンドラインオプションを。

私はこれがもっと良いかもしれないと感じています-私はそれを見続けて、それを下にゴルフしようとします。

入力を考えるとn、プログラムの出力

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

どこ(n>0)とは(n<0)ブール値です。これはGelatinのPythonの答えと同等です

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

ただし><>、組み込みの指数演算子がないため(1 - 2*(n%2))、の代わりに使用し(-1)**nます。

続くのは数学的理論です-もし興味があるなら（そしてその場合のみ）読んでください

任意の関数を考えるf: Z -> Zようにf(f(n)) = -nすべてのためnで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つの矢印に入射します。より正確には、基礎となる無向グラフでは、すべての頂点に次数が正確にあり1ます。（各4サイクル(x y -x -y)とxし、y矢印に正相当x --> y。）

この答え（とここではいくつかの他の回答）内の関数は、グラフに対応し1 --> 2、3 --> 4、と一般的には2k-1 --> 2k。

そのようなグラフは、順序付きペアの無限シーケンスを持つ全単射で(a_n, p_n)あり、それぞれa_nが正の整数であり、それぞれp_nが0orまたはorのいずれか1です：シーケンスが与えられると、(a_1, p_1), (a_2, p_2), (a_3, p_3), ...最初にペアに1なり1 + a_1、次にis またはのいずれかに応じて矢印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&^withを置き換えるだけで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))

GolfScript ceiling(26*.9)=24

Golfscriptは整数のみを処理するZため、合計24ポイントにボーナスを適用します。

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

0の特殊なケースは8文字を占めます。0を無視すると、17ポイントの回答が得られます。

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

このコードはx、スタックの最上位の整数に対して次を実行します。

• x0の場合0、スタックをそのままにして、これ以上ルールを適用しません。
• x偶数の場合、否定しxます。
• xが正の場合、を追加し1ます。
• xが負の場合、減算し1ます。

これは、サイクル内の4つの数字のセットを論理的に接続します。この場合、サイクルのf要素をトラバースし、サイクルの反対側の角は互いに負になります。すべての整数は、特殊なケースである0を除き、そのようなサイクルのちょうど1つの一部です。たとえば、用{-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」を掛けてから、convertsに変換します。

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

それほど競争的ではありませんが、複数のディスパッチに依存しているため、非常にジュリアンです。Intの場合はna Rational、それ以外の場合はマイナス記号付きのintになります。これは2つの関数であることに反対するかもしれませんが、ジュリアはこれを2つのメソッドを持つ1つの関数と見なし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

ベンライヒの方法を使用。

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

その値を使用してパスを追跡するため、4番目のバイトが0xBに等しい整数では機能しません。それ以外の場合、ゼロを含むZの任意のメンバーで機能します。

Syntheticaが提供する機能で更新されました（明らかに、この時点でクレジットを取得する必要のあるもの）

言語：Python

文字数：41（空白を含む）

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

プロローグ、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は、ジュリアの有理数のリテラル表記です。