Одиночные ходы

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

Например:

• Двигатель 1 может двигаться к любому квадрату, который расположен горизонтально или вертикально
• 2-движитель может двигаться на любой квадрат, который находится по диагонали
• 5-ходовой как шахматный рыцарь

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

Несколько ходов

Если разрешено перемещаться несколько раз, некоторые фигуры могут достигать любого квадрата на доске. Например, 1-движитель и 5-движитель могут сделать это. 2-движитель может двигаться только по диагонали и может достигать только половины квадратов. Часть, которая не может двигаться, как 3-движитель, не может достичь ни одного из квадратов (начальный квадрат не считается "достигнутым", если не происходит движение) .

Изображения показывают, какие квадраты могут быть достигнуты. Подробнее о наведении. Нажмите для увеличения изображения.

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

Какую пропорцию доски может достичь данный N-движитель?

вход

• Положительное целое число N

Выход

• Доля доски, которую может достичь N-движитель
• Это число от 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/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

Попробуйте онлайн!

Вдохновленный видео Pi, скрывающимся в главных закономерностях от 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 алгоритм теперь подкреплен доказательством

Mathematica, 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квадрата со стороны стороны, каждая из которых расположена в точке достижимости от начала координат, как если бы она была началом координат.
• Все движения объединяются в группы по четыре человека со знаками ++ +- -+ --, позволяющими распространять перекрывающуюся плитку через три других сектора путем зеркального отражения и вращения.

Retina 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 байта благодаря Нейлу
-6 байтов еще раз благодаря Нейлу
-63 байта путем деления без захвата делителя
-11 байтов благодаря одновременному необязательному делению на константу и квадратному корню Грими
байта -1 -1 путем перемещения условия конечного совпадения и захват значения возврата в цикл в качестве второй альтернативы, благодаря Грими

Здесь используется та же математика, что и в ответе Сиеру Асакото на JavaScript .

Вход в одинарный. Поскольку чистое регулярное выражение может возвращать в качестве выходных данных только подстроку из входных данных (т. Е. Натуральное число, меньшее или равное входному значению), или "нет совпадения", это регулярное выражение возвращает обратную пропорцию платы, на которой N-движитель может достигать. Поскольку обратное значение 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)

Regex (ECMAScript + (? *), Обратный вывод), 207 138 132 байта

Устранено делением без захвата делителя (то есть теперь идентично вышеописанному).

Regex (ECMAScript 2018, обратный вывод), 212 140 134 байта

Устранено делением без захвата делителя (то есть теперь идентично вышеописанному).

Regex (ECMAScript, вывод дроби), 80 байтов

В этой версии числитель возвращается в \10(ноль, если unset / 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

Порт @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 байт

Эта программа использует основной фактор маршрута. Я в долгу перед Адамом, Дзаймой, Х.П. Визом, Ж. Салле и нгн. APL Orchard - отличное место для изучения 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 Orchard - отличное место для изучения APL, и они всегда готовы помочь (или этот пост никогда бы не сдвинулся с мертвой точки :)

Редактировать: -1 байт от ngn. -2 байта от Адама и еще 2 от нгн. -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.