シングルムーブ

ボードは、無限のチェス盤のような無限の2次元の正方形グリッドです。値N（N-mover）を持つピースは、現在の正方形（中心から中心まで測定されたユークリッド距離）からNの平方根の距離にある任意の正方形に移動できます。

例えば：

• 1ムーバーは、水平方向または垂直方向に隣接する任意の正方形に移動できます
• 2発動機は、斜めに隣接する任意の正方形に移動できます
• 5発動機はチェスの騎士のように動く

すべてのNムーバーが移動できるわけではないことに注意してください。ボード上の正方形はどれも現在の正方形から正確にルート3の距離にないため、3ムーバーは現在の正方形から離れることはできません。

複数の動き

繰り返し移動できる場合、一部のピースはボード上の任意の正方形に到達できます。たとえば、1ムーバーと5ムーバーの両方でこれを実行できます。2ムーバーは斜めにしか移動できず、正方形の半分にしか到達できません。3ムーバーのように移動できないピースは、どの正方形にも到達できません（移動が発生しない場合、開始正方形は「到達」としてカウントされません）。

画像は、到達可能な正方形を示しています。ホバーの詳細。画像をクリックすると拡大します。

• 1つ以上の動きで到達可能な正方形は黒でマークされます
• 正確に1回の移動で到達可能な正方形は、赤い部分で表示されます
  （移動できない3ムーバーを除く）。

特定のNムーバーが到達できるボードの割合は？

入力

• 正の整数N

出力

• N-moverが到達できるボードの割合
• これは0から1までの数値です（両方を含む）
• この課題では、1/4などの最低条件の分数としての出力が許可されます

だから、入力のために10、両方1/2と0.5許容出力です。個別の分子と分母としての出力も許容され、浮動小数点も分数もサポートしない言語も含まれます。たとえば、1 2または[1, 2]。

整数出力（0および1）の場合、次のいずれかが受け入れ可能な形式です。

• 0の場合：0、0.0、0/1、0 1、[0, 1]
• 1： 、1、1.0、、1/11 1[1, 1]

得点

これはコードゴルフです。スコアは、バイト単位のコードの長さです。各言語について、最短のコードが優先されます。

テストケース

形式で input : output as fraction : output as decimal

  1 : 1     : 1
  2 : 1/2   : 0.5
  3 : 0     : 0
  4 : 1/4   : 0.25
  5 : 1     : 1
  6 : 0     : 0
  7 : 0     : 0
  8 : 1/8   : 0.125
  9 : 1/9   : 0.1111111111111111111111111111
 10 : 1/2   : 0.5
 13 : 1     : 1
 16 : 1/16  : 0.0625
 18 : 1/18  : 0.05555555555555555555555555556
 20 : 1/4   : 0.25
 25 : 1     : 1
 26 : 1/2   : 0.5
 64 : 1/64  : 0.015625
 65 : 1     : 1
 72 : 1/72  : 0.01388888888888888888888888889
 73 : 1     : 1
 74 : 1/2   : 0.5
 80 : 1/16  : 0.0625
 81 : 1/81  : 0.01234567901234567901234567901
 82 : 1/2   : 0.5
144 : 1/144 : 0.006944444444444444444444444444
145 : 1     : 1
146 : 1/2   : 0.5
148 : 1/4   : 0.25
153 : 1/9   : 0.1111111111111111111111111111
160 : 1/32  : 0.03125
161 : 0     : 0
162 : 1/162 : 0.006172839506172839506172839506
163 : 0     : 0
164 : 1/4   : 0.25
241 : 1     : 1
242 : 1/242 : 0.004132231404958677685950413223
244 : 1/4   : 0.25
245 : 1/49  : 0.02040816326530612244897959184
260 : 1/4   : 0.25
261 : 1/9   : 0.1111111111111111111111111111
288 : 1/288 : 0.003472222222222222222222222222
290 : 1/2   : 0.5
292 : 1/4   : 0.25
293 : 1     : 1
324 : 1/324 : 0.003086419753086419753086419753
325 : 1     : 1
326 : 0     : 0
360 : 1/72  : 0.01388888888888888888888888889
361 : 1/361 : 0.002770083102493074792243767313
362 : 1/2   : 0.5
369 : 1/9   : 0.1111111111111111111111111111
370 : 1/2   : 0.5
449 : 1     : 1
450 : 1/18  : 0.05555555555555555555555555556
488 : 1/8   : 0.125
489 : 0     : 0
490 : 1/98  : 0.01020408163265306122448979592
520 : 1/8   : 0.125
521 : 1     : 1
522 : 1/18  : 0.05555555555555555555555555556
544 : 1/32  : 0.03125
548 : 1/4   : 0.25
549 : 1/9   : 0.1111111111111111111111111111
584 : 1/8   : 0.125
585 : 1/9   : 0.1111111111111111111111111111
586 : 1/2   : 0.5
592 : 1/16  : 0.0625
593 : 1     : 1
596 : 1/4   : 0.25
605 : 1/121 : 0.008264462809917355371900826446
610 : 1/2   : 0.5
611 : 0     : 0
612 : 1/36  : 0.02777777777777777777777777778
613 : 1     : 1
624 : 0     : 0
625 : 1     : 1

JavaScriptの（Node.jsの）、144の 138 125 74 73 70バイト

f=(x,n=2,c=0)=>x%n?x-!c?f(x,n+1)/(n%4>2?n/=~c&1:n%4)**c:1:f(x/n,n,c+1)

オンラインでお試しください！

-4バイトありがとう@Arnauld！

元のアプローチ、125バイト

a=>(F=(x,n=2)=>n*n>x?[x,0]:x%n?F(x,n+1):[n,...F(x/n,n)])(a).map(y=>r-y?(z*=[,1,.5,p%2?0:1/r][r%4]**p,r=y,p=1):p++,z=r=p=1)&&z

オンラインでお試しください！

3Blue1Brownによるプライム規則性に隠れているビデオPiに触発されました。

数の因数分解の各素因数について、計算します。$p^n$$f(p^n)$

• もし奇数であり、 -。行く場所がないからです$n$$p\equiv 3\text{ (mod 4)}$$f(p^n)=0$
• もし偶数であり、 -。$n$$p\equiv 3\text{ (mod 4)}$$f(p^n)=\frac{1}{p^n}$
• もし -。$p=2$$f(2^n)=\frac{1}{2^n}$
• もし -。$p\equiv 1\text{ (mod 4)}$$f(p^n)=1$

これらすべての関数値を掛けると、そこにあります。

更新

Math.SEの貢献者の努力のおかげで、アルゴリズムは今では証明によって裏付けられています

Mathematica、80バイト

d[n_]:=If[#=={},0,1/Det@LatticeReduce@#]&@Select[Tuples[Range[-n,n],2],#.#==n&];

このコードは、ほとんど数学的な定理に依存しています。基本的な考え方は、コードが生成セットが与えられると格子の密度を求めるということです。

より正確には、ベクトルのコレクション、つまり長さの2乗がNであるものが与えられ、すべての整数ベクトルと比較して、これらのベクトルの可能な和の集合の密度を計算するように求められます。演じられている数学は、元のコレクションと同じセットを「生成」する（つまりその和が）2つのベクトル（およびその逆）を常に見つけることができるということです。LatticeReduceはまさにそれを行います。

ベクトルが2つしかない場合、到達可能な各ポイントを中心とする同一の平行四辺形を描くことを想像できますが、エッジの長さは与えられたベクトルであり、平面はこれらの平行四辺形によって完全にタイル張りされます。（たとえば、n = 2の「ダイヤモンド」形状の格子を想像してください）。各平行四辺形の面積は、2つの生成ベクトルの決定要因です。各平行四辺形には到達可能な点が1つしかないため、平面の望ましい割合はこの領域の逆数です。

コードはかなり単純な実装です。ベクトルを生成し、LatticeReduceを使用し、行列式を取得してから逆数を取得します。（ただし、おそらくより良くゴルフすることができます）

クリーン、189の 185 172 171バイト

import StdEnv
$n#r=[~n..n]
#p=[[x,y]\\x<-r,y<-r|x^2+y^2==n]
=sum[1.0\\_<-iter n(\q=removeDup[k\\[a,b]<-[[0,0]:p],[u,v]<-q,k<-[[a+u,b+v]]|all(\e=n>=e&&e>0)k])p]/toReal(n^2)

オンラインでお試しください！

n最初の象限の原点を角とする-辺の長さの正方形で到達可能なすべての位置を検索しn^2、すべてのセルの一部を到達可能にするために除算します。

これは次の理由で機能します。

• 到達可能な平面全体は、このn辺の長さの正方形の重複コピーと見なすことができ、それぞれが原点であるかのように、原点から到達可能な点を角とする。
• すべての動きは、記号の付いた4つのグループに分かれ++ +- -+ --ており、ミラーリングと回転によって、重なり合うタイルを他の3つの象限に拡張できます。

網膜0.8.2、126の 82バイト

.+
$*
+`^(1(1111)+)(?<!^\3+(11+))(\1)*$
1$#4$*
^(?!((^1|11\2)+)\1?$)1+
0
11+
1/$.&

オンラインでお試しください！リンクにはテストケースが含まれます。説明：

.+
$*

単項に変換します。

+`^(1(1111)+)(?<!^\3+(11+))(\1)*$
1$#4$*

形式の素因数で繰り返し除算し4k+1ます。

^(?!((^1|11\2)+)\1?$)1+
0

結果が正方形でも正方形の2倍でもない場合、結果はゼロになります。

11+
1/$.&

小数として逆数を計算します。

正規表現（ECMAScriptの、相互アウト）、256の 163 157 94 83 82バイト

-93は、バイトニールのおかげ
-6バイトニール再びおかげで
-63除数を捕捉することなく除算を行うことにより、バイト
-11おかげバイト汚れの同時オプションの分割によって定数と平方根
エンド一致条件を移動させることにより-1バイトGrimyのおかげで、2番目の選択肢としてループに値をキャプチャする

これは、アサコトシエルのJavaScriptアンサーと同じ数学を使用しています。

入力は単項です。純粋な正規表現は、入力から部分文字列（つまり、入力以下の自然数）または「一致なし」のみを出力として返すことができるため、この正規表現は、N-moverの割合の逆数を返します。届くことができます。0の逆数は無限であるため、その場合は「一致なし」を返します。

ネタバレ警告：この正規表現は、一般化された乗算アルゴリズムの変形を使用します。これは自明ではなく、自分で解決する価値のあるパズルになる可能性があります。詳細については、「ロッコ番号を見つける」のアルゴリズムのこの形式の説明を参照してください。

$p$$p\equiv 1\text{ (mod 4)}$$m$$m$$\equiv 3\text{ (mod 4)}$$m$$m/2$$m$$m$

$m$$m/2$$p$$\equiv 3\text{ (mod 4)}$

^(?=((?=(x+)(?!(\2+)(\2\3)+$)((\2{4})+$))\5|((xx?)(\8*))(?=(\7*)\9+$)\7*$\10)+$)\1

オンラインでお試しください！
オンラインでお試しください！（テストケースのみ）

^
(?=
    (                          # Capture return value, which will just be the value
                               # matched by the last iteration of this loop.
    # Divide tail by every one of its prime factors that's ≡1 mod 4, as many times as
    # possible.
        (?=
            (x+)               # \2 = quotient
            (?!(\2+)(\2\3)+$)  # Assert divisor is prime
            ((\2{4})+$)        # Assert divisor ≡1 mod 4; \5 = tool to make tail = \2
        )\5                    # tail = \2
    |
    # When the above alternative has been done as many times as possible:
    # Test if tail or tail/2 is a perfect square. If this test fails, the regex engine
    # will backtrack into the division loop above, and run the same perfect square
    # test on every previous number (effectively "multiplying" it by each previous P
    # in reverse, one at a time). This will not cause a failure of the test to change
    # into a success, however, because the odd power of a prime ≡3 mod 4 will see be
    # present in the number at every step. Allowing this backtracking to happen is a
    # golf optimization, and it does make the regex slower.
    # Failure of this perfect square test results in returning "no match" and indicates
    # a return value of zero.
        (                      # \7 = \8 * sqrt(tail / \8)
            (xx?)              # \8 = control whether to take sqrt(tail)
                               #                         or 2*sqrt(tail/2)
            (\8*)              # \9 = \7 - \8
        )
        (?=
            (\7*)\9+$          # Iff \8 * (\7 / \8)^2 == our number, then the first match
                               # here must result in \10==0
        )
        \7*$\10                # Test for divisibility by \7 and for \10==0
                               # simultaneously
    )+
    $                          # Require that the last iteration of the above loop was
                               # the perfect square test. Since the first alternative,
                               # the division, always leaves >=1 in tail, this guarantees
                               # that the last step is a successful perfect square test,
                               # or else the result will be "no match".
)
\1                             # Return value (which is a reciprocal)

正規表現（のECMAScript +（？*）、逆数出力）、207の 138 132バイト

除数をキャプチャせずに除算を行うことで廃止されました（つまり、上記と同じになりました）。

正規表現（ECMAScript 2018、相互出力）、212 140 134バイト

除数をキャプチャせずに除算を行うことで廃止されました（つまり、上記と同じになりました）。

正規表現（ECMAScript、小数部出力）、80バイト

このバージョンでは、分子は\10（設定されていない場合はゼロ/ NPCG）で返され、分母はで返されます\7。

相互出力バージョンとは異なり：

• ゼロの入力は正しく処理されません（そのバージョンと同様に「一致なし」を返しますが、それとは異なり、ゼロの出力値には対応しません）。
• 完全二乗検定が失敗した場合、除算ループに戻りませんので、このバージョンは実行時間がより効率的です。

このような出力仕様の大きな欠点は、プログラム自体に含まれていないことです。

((?=(x+)(?!(\2+)(\2\3)+$)((\2{4})+$))\5)*((((x)x?)(\9*))(?=(\8*)\11+$)\8*$\12|x)

オンラインでお試しください！
オンラインでお試しください！（テストケースのみ）

# No need to anchor, since we return a match for all inputs in the domain.
# Divide tail by every one of its prime factors that's ≡1 mod 4
(
    (?=
        (x+)               # \2 = quotient
        (?!(\2+)(\2\3)+$)  # Assert divisor is prime
        ((\2{4})+$)        # Assert divisor ≡1 mod 4; \5 = tool to make tail = \2
    )\5                    # tail = \2
)*
# Test if tail or tail/2 is a perfect square. If this test succeeds, return tail as
# the denominator and 1 as the numerator.
(                          # \7 = denominator output
    (                      # \8 = \9 * sqrt(tail / \9)
        ((x)x?)            # \9 = control whether to take sqrt(tail) or 2*sqrt(tail/2);
                           # \10 = numerator output (NPCG to represent zero)
        (\9*)              # \11 = \8 - \9
    )
    (?=
        (\8*)\11+$         # Iff \9 * (\8 / \9)^2 == our number, then the first match
                           # here must result in \12==0
    )
    \8*$\12                # Test for divisibility by \8 and for \12==0
                           # simultaneously
|
# Failure of the perfect square test results in returning 0/1 as the answer, so here
# we return a denominator of 1.
    x
)

ゼリー、 25  24 バイト

ÆFµ%4,2CḄ:3+2Ịị,*/ʋ÷*/)P

素因数経路を使用したモナドリンク。

オンラインでお試しください！

どうやって？

ÆFµ%4,2CḄ:3+2Ịị,*/ʋ÷*/)P - Link: integer, n               e.g. 11250
ÆF                       - prime factor, exponent pairs        [[2,1], [3,2], [5,4]]
  µ                   )  - for each pair [F,E]:
    4,2                  -   literal list [4,2]
   %                     -   modulo (vectorises)                [2,1]  [3,0]  [1,0]
       C                 -   complement (1-x)                  [-1,0] [-2,1]  [0,1]
        Ḅ                -   from base 2                         -2     -3      1      
         :3              -   integer divide by three             -1     -1      0
           +2            -   add two (call this v)                1      1      3
                  ʋ      -   last four links as a dyad, f(v, [F,E])
             Ị           -     insignificant? (abs(x)<=1 ? 1 : 0)   1      1      0
                */       -     reduce by exponentiation (i.e. F^E)  2      9     625
               ,         -     pair v with that                   [1,2]  [1,9]  [3,625]
              ị          -     left (Ị) index into right (that)     1      1     625
                    */   -   reduce by exponentiation (i.e. F^E)    2      9     625
                   ÷     -   divide                                1/2    1/9  625/625
                       P - product                                 1/18 = 0.05555555555555555

前の25は：

ŒRp`²S⁼ɗƇ⁸+€`Ẏ;Ɗ%³QƊÐLL÷²

完全なプログラムブルートフォーサー。おそらく素因数経路よりも長いコード（後で試すかもしれません）。

オンラインでお試しください！

モジュロ取る、繰り返し、結果蓄積すべての到達位置から移動する座標として、単一の移動を作成することによって開始するn各々の（に制限する座標nによってn象限）と固定点に到達するまで別個であるものを保持します。そして最後にカウントをn^2

05AB1E、27 26 25 バイト

ÓεNØ©<iozë®4%D≠iyÈ®ymz*]P

@ShieruAsakotoのJavaScriptの回答のポートです。必ず彼にも賛成してください！

オンラインそれを試してみたり、すべてのテストケースを確認してください。

説明：

Ó                   # Get all prime exponent's of the (implicit) input's prime factorization
                    #  i.e. 6 → [1,1]      (6 → 2**1 * 3**1)
                    #  i.e. 18 → [1,2]     (18 → 2**1 * 3**2)
                    #  i.e. 20 → [2,0,1]   (20 → 2**2 * 3**0 * 5**1)
                    #  i.e. 25 → [0,0,2]   (25 → 2**0 * 3**0 * 5**2)
 ε                  # Map each value `n` to:
  NØ                #  Get the prime `p` at the map-index
                    #   i.e. map-index=0,1,2,3,4,5 → 2,3,5,7,11,13
    ©               #  Store it in the register (without popping)
     <i             #  If `p` is exactly 2:
       oz           #   Calculate 1/(2**`n`)
                    #    i.e. `n`=0,1,2 → 1,0.5,0.25
      ë             #  Else:
       ®4%          #   Calculate `p` modulo-4
                    #    i.e. `p`=3,5,7,11,13 → 3,1,3,3,1
          D         #   Duplicate the result (the 1 if the following check is falsey)
           ≠i       #   If `p` modulo-4 is NOT 1 (in which case it is 3):
             yÈ     #    Check if `n` is even (1 if truthy; 0 if falsey)
                    #     i.e. `n`=0,1,2,3,4 → 1,0,1,0,1
             ®ymz   #    Calculate 1/(`p`**`n`)
                    #     i.e. `p`=3 & `n`=2 → 0.1111111111111111 (1/9)
                    #     i.e. `p`=7 & `n`=1 → 0.14285714285714285 (1/7)
              *     #    Multiply both with each other
                    #     i.e. 1 * 0.1111111111111111 → 0.1111111111111111
                    #     i.e. 0 * 0.14285714285714285 → 0
 ]                  # Close both if-statements and the map
                    #  i.e. [1,1] → [0.5,0.0]
                    #  i.e. [1,2] → [0.5,0.1111111111111111]
                    #  i.e. [2,0,1] → [0.25,1.0,1]
                    #  i.e. [0,0,2] → [1.0,1.0,1]
  P                 # Take the product of all mapped values
                    #  i.e. [0.5,0.0] → 0.0
                    #  i.e. [0.5,0.1111111111111111] → 0.05555555555555555
                    #  i.e. [0.25,1.0,1] → 0.25
                    #  i.e. [1.0,1.0,1] → 1.0
                    # (and output implicitly as result)

APL（Dyalog Extended）、21バイト

このプログラムは、素因数経路を使用します。アダム、ザイマ、H.PWiz、J。サレ、NGNに感謝します。APLオーチャードはAPLを学ぶのに最適な場所であり、いつでも喜んでお手伝いします

(×/÷,3≠4|*∘≢⌸)⍭*1≠4|⍭

オンラインでお試しください！

アンゴルフ

このコードのパート2は、以下のDyalog Unicodeバージョンと同じであるため、この説明では、 ⍭*1≠4|⍭

⍭*1≠4|⍭

      ⍭  Gives us a list of the prime factors of our input.
           Example for 45: 3 3 5
  1≠4|   Checks if each prime is of the form 4k+1.
⍭*       Takes each prime to the power of 1 or 0,
           turning all the 4k+1 primes into 1s.
           Example for 45: 3 3 1

APL（Dyalog Unicode）、41 40 36 35 バイト^SBCS

このプログラムは、素因数経路を使用します。これを書いている間にいくつかのトリックを学び、私はアダム、dzaima、H.PWiz、J.Sallé、およびngnに深く感謝しています。APLオーチャードはAPLを学ぶのに最適な場所であり、彼らはいつでも喜んで支援します（または、この投稿は決して成功しませんでした:)

編集：NGNから-1バイト。Adámから-2バイト、ngnから-2バイト。NGNから-1バイト。

{(×/÷,3≠4|*∘≢⌸)p*1≠4|p←¯2÷/∪∧\⍵∨⍳⍵}

オンラインでお試しください！

アンゴルフ

これは、2つの部分に分かれたプログラムです。

p*1≠4|p←¯2÷/∪∧\⍵∨⍳⍵  Part 1

      p←             We can define variables mid-dfn (a function in {} brackets).
               ⍵∨⍳⍵  We take the GCD of our input 
                       with every member of range(1, input).
            ∪∧\      This returns all the unique LCMs of every prefix
                       of our list of GCDs.
                       Example for 31500: 1 2 6 12 60 420 1260 6300 31500
        ¯2÷/         We divide pairwise (and in reverse)
                       by using a filter window of negative two (¯2).
                       Example for 31500: 2 3 2 5 7 3 5 5
  1≠4|p              Check if the primes are 1 modulo 4 or not
p*                   And take each prime to the power of the result (1 or 0),
                       turning the 4k+3 primes into 1s
                       and leaving any 2s and 4k+3 primes.
                       Example for 31500: 2 3 2 1 7 3 1 1

(×/÷,3≠4|*∘≢⌸)  Part 2

(            )  We apply all this to the filtered array of primes.
         *∘≢⌸   This takes all of our primes to their exponents
                  (the number of times those primes appear in the factorization).
                  Example for 31500: 4 9 1 7
     3≠4|       Then we take each prime modulo 4 and check if not equal to 3.
                  We will only get a falsey if any 4k+3 primes, as an even number of
                  4k+3 primes multiplied together will result in some 4m+1.
                  Example for 31500: 1 1 1 0
   ÷,           We append the results of the above condition check
                  to the reciprocals of the primes in p.
                  Example for 31500: (1/2) (1/3) (1/2) 1 (1/7) (1/3) 1 1 1 1 1 0
 ×/             We multiply it all together, resulting in a positive fraction or 0
                  depending on our condition check.
                  Example for 31500: 0
                We return the results of all our checks implicitly.