Поодинокі ходи

Дошка - це нескінченна двовимірна квадратна сітка, як безмежна шахова дошка. Шматок зі значенням N (рухомий N ) може переміститися до будь-якого квадрата, який знаходиться на відстані рівно квадратного кореня N від його поточного квадрата (евклідова відстань, вимірювана центром до центру).

Наприклад:

• Автомобіль 1 може переміститися до будь-якого квадрата, який горизонтально або вертикально примикає
• Двохмісний двигун може переміститися до будь-якого квадрата, який знаходиться по діагоналі
• П’ятирічковий рухається, як шаховий лицар

Зауважте, що не всі N-машини можуть рухатися. Трехмісний двигун ніколи не може залишити свій поточний квадрат, тому що жоден з квадратів на дошці не є відстаньм точно кореня 3 від поточного квадрата.

Кілька ходів

Якщо дозволено рухатися повторно, деякі шматки можуть досягати будь-якого квадрата на дошці. Наприклад, одномобільний та 5-ти рухомий можуть це зробити як. Двоповерховий двигун може рухатися тільки по діагоналі і може досягати лише половини квадратів. Шматок, який не може рухатися, як тривимірний, не може досягти жодного з квадратів (початковий квадрат не вважається «досягнутим», якщо не відбувається руху) .

Зображення показують, до яких квадратів можна дійти. Детальніше про наведення курсору. Клацніть для збільшення зображення.

• Квадрати, доступні в 1 і більше рухів, позначені чорним кольором
• Квадрати, доступні рівно за 1 хід, показані червоними шматками
  (крім 3-х рушій, які не можуть рухатись)

Яка частка дошки може досягти даного N-Mover?

Вхідні дані

• Позитивне ціле число N

Вихід

• Пропорція дошки, яку може досягти N-двигун
• Це число від 0 до 1 (обидва включно)
• Для цього завдання дозволено виведення у вигляді дробу в найнижчих термінах, як 1/4

Таким чином, для введення 10і обидва, 1/2і 0.5є прийнятними виходами. Вихід як окремий чисельник та знаменник також прийнятний, включаючи мови, які не підтримують ні float, ні дроби. Наприклад, 1 2або [1, 2].

Для цілих виходів (0 і 1) прийнятними є будь-який з наступних форматів:

• При 0: 0, 0.0, 0/1, 0 1,[0, 1]
• для 1: 1, 1.0, 1/1, 1 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.

Для кожного простого коефіцієнта $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, алгоритм тепер підтримується доказом

Математика, 80 байт

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

Цей код здебільшого спирається на математичну теорему. Основна ідея полягає в тому, що код запитує щільність решітки з урахуванням деякого генеруючого набору.

Точніше, нам надано деяку колекцію векторів - а саме тих, довжина яких у квадраті дорівнює N - і попросили обчислити щільність набору можливих сум цих векторів порівняно з усіма цілими векторами. Математика в грі полягає в тому, що ми завжди можемо знайти два вектори (і їхні протилежні), які "генерують" (тобто чиї суми) того ж набору, що і оригінальна колекція. LatticeReduce робить саме це.

Якщо у вас всього два вектори, ви можете уявити, як намалювати однаковий паралелограм, по центру в кожній досяжній точці, але довжини ребра якого задані векторами, таким чином, що площина цілком обложена цими паралелограмами. (Уявімо, наприклад, решітку «ромбових» фігур для n = 2). Площа кожного паралелограма є визначальною для двох генеруючих векторів. Бажана пропорція площини є зворотною цією площею, оскільки кожен паралелограм має в ньому лише одну точку досяжності.

Код є досить простою реалізацією: генеруйте вектори, використовуйте 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квадраті довжини, кожен з яких поворотується в точку досяжності від початку, як ніби це походження.
• Усі рухи бувають групами з чотирьох із знаками ++ +- -+ --, що дозволяє розширити плитку, що перекривається, через інші три квадранти за допомогою дзеркального відображення та обертання.

Сітківка 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

Якщо результат не є ні квадратом, ні двома квадратами, то результат дорівнює нулю.

11+
1/$.&

Обчисліть зворотну у вигляді десяткового дробу.

Regex (ECMAScript, зворотний вихід), 256 163 157 94 83 82 байт

-93 байт завдяки Neil
-6 байт знову дякує Neil
-63 байт, роблячи ділення без захоплення дільника
-11 байт завдяки одночасному необов'язковому поділу на постійну та квадратному корені -1 байта Грімі,
переміщуючи умову кінця збігу і повернення значення захоплення в цикл як друга альтернатива, завдяки Гримі

Для цього використовується така ж математика, як і відповідь JavaScript Шиєру Асакото .

Вхід не одинаковий. Оскільки чистий регулярний вираз може повернути як вихід підстроку з вхідного сигналу (тобто натуральне число, менший або рівний вводу), або "не збігається", цей регулярний вираз повертає зворотну частку дошки, яка є N-переміщувачем може досягти. Оскільки зворотний показник 0 є нескінченним, у цьому випадку він повертає "no match".

ПОПЕРЕДЖЕННЯ СПОЙЛЕРА : Для квадратного кореня цей регекс використовує варіант узагальненого алгоритму множення, який не є очевидним і може стати корисною головоломкою для розробки самостійно. Для отримання додаткової інформації дивіться пояснення до цієї форми алгоритму в « Знайти число Рокко» .

$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)

Regex (ECMAScript + (? *), Зворотний вихід), 207 138 132 байт

Застаріло, роблячи ділення без захоплення дільника (тобто тепер тотожне вище).

Regex (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÷²

Повна програма brute forcer ; можливо довший код, ніж маршрут основного фактора (я можу спробувати це пізніше).

Спробуйте в Інтернеті!

Починається зі створення одиночних ходів в якості координат потім неодноразово переміщається з усіх досягнутих місць , які акумулюють результатів, приймаючи по модулю nкожної координати (обмежитися nпо nквадраті) і збереження тих , які різні , поки фіксована точка не буде досягнута; потім, нарешті, ділить рахунок наn^2

05AB1E , 27 26 25 байт

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

Порт відповіді JavaScript @ShieruAsakoto , тому обов'язково підтримайте його також!

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

Ó                   # 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 байт

Ця програма використовує маршрут основного фактора. Я заборгований Adám, dzaima, H.PWiz, J.Sallé та ngn. Сад APL - прекрасне місце для вивчення APL, і вони завжди готові допомогти

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

Спробуйте в Інтернеті!

Ungolfing

Частина 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

Ця програма використовує маршрут основного фактора. Навчившись декількох хитрощів, пишучи це, я сильно вдячний Адаму, Дзаймі, Х.Піві, Дж. Салле та Нгґну. Сад APL - це чудове місце для вивчення APL, і вони завжди готові допомогти (інакше ця публікація ніколи не збилася б із місця :)

Редагувати: -1 байт від ngn. -2 байти від Adám і ще -2 від ngn. -1 байт від ngn.

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

Спробуйте в Інтернеті!

Ungolfing

Це програма з двох частин:

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.