Вступление

В теории чисел мы говорим, что число является $k$ гладким, когда все его простые множители не больше $k$ . Так , например, 2940 : 7-гладкой , так как $2940=2^2\cdot3\cdot5\cdot7^2$ .

Здесь мы определяем $k$ -гладкую пару как два последовательных целых числа, оба из которых $k$ -гладкие. Пример 7-гладкой пары будет $(4374,4375)$ , так как $4374=2\cdot3^7$ и $4375=5^4\cdot7$ . Забавный факт: это на самом деле самая большая пара из 7-гладких .

В 1897 году Штермер доказал, что для каждого $k$ существует только конечное число $k$ -гладких пар , и этот факт известен как теорема Штермера .

Вызов

Ваша задача - написать программу или функцию, которая при заданном вводе простого числа $k$ выводит или возвращает все $k$ -гладкие пары без дубликатов (порядок внутри пары не имеет значения) в любом порядке.

Следует отметить, что для простых чисел $p$ и $q$ , предполагая, что $p<q$ , все $p$ -гладкие пары также являются $q$ -гладкими парами.

Образец ввода / вывода

Input: 2
Output: (1, 2)

Input: 3
Output: (1, 2), (2, 3), (3, 4), (8, 9)

Input: 5
Output: (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (8, 9), (9, 10), (15, 16), (24, 25), (80, 81)

Input: 7
Output: (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10), (14, 15),
        (15, 16), (20, 21), (24, 25), (27, 28), (35, 36), (48, 49), (49, 50), (63, 64),
        (80, 81), (125, 126), (224, 225), (2400, 2401), (4374, 4375)

ограничение

Программа или функция должны теоретически завершаться за конечное время для всех входов. Стандартные лазейки по умолчанию запрещены.

Критерии победы

Поскольку это соревнование по коду для игры в гольф , выигрывает самая короткая действительная подача для каждого языка.

JavaScript (ES7),  234  232 байта

Находит решения путем решения уравнений Пелла вида $x^2-2qy^2=1$ , где $q$ - $P$ -гладкое квадратное свободное число.

Это реализация процедуры Деррика Генри Лемера , основанная на оригинальной процедуре Штермера.

Возвращает объект, ключи и значения которого описывают $P$ -гладкие пары.

P=>[...Array(P**P)].map((_,n)=>(s=(n,i=0,k=2)=>k>P?n<2:n%k?s(n,i,k+1):s(n/k,i,k+i))(n,1)&&(_=>{for(x=1;(y=((++x*x-1)/n)**.5)%1;);(h=(x,y)=>k--&&h(X*x+n*Y*y,X*y+Y*x,x&s(x=~-x/2)&s(x+1)?r[x]=x+1:0))(X=x,Y=y,k=P<5?3:-~P/2)})(),r={})&&r

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

Как?

Вспомогательная функция $s$ проверяет, является ли данное целое число $n$ гладким $P$ числом, когда оно вызывается с $i=0$ , или свободным ^1- гладким числом $P$ когда оно вызывается с $i=1$ .

s = (
  n,
  i = 0,
  k = 2
) =>
  k > P ?
    n < 2
  :
    n % k ?
      s(n, i, k + 1)
    :
      s(n / k, i, k + i)

Мы ищем все квадратные свободные ¹ $P$ -гладкие числа в $[1..P^P-1]$ , где$P^P$ используется в качестве верхней границы для$P!$,

P=>[...Array(P ** P)].map((_, n) => s(n, 1) && (...))

Для каждого числа $n$ найденного выше, мы ищем фундаментальное решение уравнения Пелла $x^2-ny^2=1$ :

(_ => {
  for(x = 1; (y = ((++x * x - 1) / n) ** .5) % 1;);
  ...
})()

(приведенный выше код является нерекурсивной версией моего ответа на этот другой вызов )

Когда фундаментальное решение $(x_1,y_1)$ найдено, мы вычисляем решения $(x_k,y_k)$ с $k\le max(3,(P+1)/2)$ , используя рекуррентные соотношения:

Для каждого $x_k$ мы проверяем, является ли $x_k$ нечетным и оба $(x_k-1)/2$ и $(x_k+1)/2$ являются$P$ гладкими. Если это так, мы храним их в объекте$r$ .

( h = (x, y) =>
  k-- &&
  h(
    X * x + n * Y * y,
    X * y + Y * x,
    x &
    s(x = ~-x / 2) &
    s(x + 1) ?
      r[x] = x + 1
    :
      0
  )
)(X = x, Y = y, k = P < 5 ? 3 : -~P / 2)

^{1: поскольку она не проверяет простоту делителей, функция $s$ будет действительно верна для некоторых не квадратичных свободных чисел, даже если она вызывается с $i=1$ . Идея состоит в том, чтобы отфильтровать большинство из них, чтобы было решено не слишком много бесполезных уравнений Пелла.}

Желе , 16 14 байтов

4*ÆfṀ<ɗƇ‘rƝLÐṂ

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

Проверяет на пары до $4^k$ что неэффективно для больших$k$ но должно гарантировать, что ни одно не пропущено.

Спасибо @JonathanAllan за сохранение 1 байта!

объяснение

4*ÆfṀ<ɗƇ‘rƝLÐṂ  | Monadic link, input k

4*              | 4**k, call this n
      ɗƇ        | For each number from 1..n filter those where:
  Æf            |   - Prime factors
    Ṁ           |   - Maximum
     <  ‘       |   - Less than k+1
         rƝ     | Inclusive range between neighbouring values
           LÐṂ  | Keep only those of minimum length (i.e. adjacent values)

05AB1E , 8 байтов

°Lü‚ʒfà@

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

Объяснение:

°            # 10 ** the input
 Lü‚         # list of pairs up to that number
    ʒ        # filtered by...
     fà      # the greatest prime factor (of either element of the pair)...
       @     # is <= the input

Желе , 123 байта

¹©Æ½Ø.;µU×_ƭ/;²®_$÷2ị$}ʋ¥⁸;+®Æ½W¤:/$$µƬṪ€F¹;Ḋ$LḂ$?ṭ@ṫ-ṚZæ.ʋ¥ƒØ.,U¤-ịWµ1ịżU×®W¤Ɗ$æ.0ị$ṭµ³’H»3¤¡
ÆRŒPP€ḟ2ḤÇ€ẎḢ€+€Ø-HÆfṀ€<ẠʋƇ‘

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

$2×$$\max(3, \frac{k+1}{2})$$\frac{x-1}{2}, \frac{x+1}{2}$гладкие для каждого решения. Это метод Лемера, описанный в ссылке на вопрос в Википедии .

Полная программа, которая принимает один аргумент, $k$и возвращает список списков пар. Приведенный выше код не сортирует окончательный результат, но ссылка TIO делает.

Haskell , 118 107 байтов

-11 байт благодаря Ними

q 1=[1]
q n=(:)<*>q.div n$[x|x<-[2..n],mod n x==0]!!0
f k|let r=all(<=k).q=[(n,n+1)|n<-[1..4^k],r n,r(n+1)]

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

• q n вычисляет список всех основных факторов n
• f k генерирует список $k$-гладкие пары для данного k путем фильтрации списка всех пар

Желе , 24 байта

³!²R‘Ė
ÇÆFḢ€€€’<³FȦ$€Tị¢

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

Это занимает много времени для 7, но вычисляется намного быстрее, если вы уберете квадрат факториала: попробуйте онлайн!

Объяснение:

³!²R‘Ė                Generates a list like [[1,2],[2,3],...]
³!²                  Take the square of the factorial of the input
   R                 Range 1 through through the above number.
    ‘Ė               Decrement and enumerate, yielding desired list


ÇÆFḢ€€€’<³FȦ$€Tị¢  
Ç                    Get the list of pairs  
 ÆF                  Get the prime factors of each number
   Ḣ€€€              Get the base of each
       ’<³           Is each base less than or equal to the input?
          FȦ$€       Check that all bases of a pair fit the above.
              T      Get a list of the truthy indexes
               ị¢    Index into the original list of pairs
                     Implicit output

-3 байта благодаря @JonathanAllen

Python 3 + sympy, 116 байт

import sympy
def f(k):x=[i for i in range(2,4**k)if max(sympy.factorint(i))<=k];return[(y,y+1)for y in x if y+1in x]

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

Python 3 + sympy, 111 байт

from sympy import*
def f(k):
 b=1
 for i in range(2,4**k):
  x=max(factorint(i))<=k
  if x&b:print(i-1,i)
  b=x

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

Две вариации на мой ответа Jelly, но в Python 3. Они оба определяют функцию, которая принимает аргумент k. Первый возвращает список кортежей пар, которые соответствуют критериям. Второй выводит их на стандартный вывод.

Wolfram Language (Mathematica) , 241 байт

использует уравнения Пелла

(s=#;v@a_:=Max[#&@@@#&/@FactorInteger@a]<=s;Select[{#-1,#+1}/2&/@(t={};k=y=1;While[k<=Max[3,(s+1)/2],If[IntegerQ[x=Sqrt[1+2y^2#]],t~AppendTo~x;k++];y++];t),v@#&]&/@Join[{1},Select[Range[3,Times@@Prime@Range@PrimePi@s],SquareFreeQ@#&&v@#&]])&

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

Pyth , 15 байт

f!>#QsPMTCtBS^4

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

Использует замечание Ника Кеннеди о том, что ни один выходной номер не будет больше, чем 4^k.

05AB1E , 16 байтов

°LʒfàI>‹}Xšü‚ʒ¥`

Попробуйте онлайн (крайне неэффективно, поэтому время ожидания$n\gt3$..). Здесь немного более быстрая альтернатива , хотя все еще довольно медленная ..

Объяснение:

°                # Take 10 to the power of the (implicit) input
 L               # Create a list in the range [1, 10^input]
  ʒ              # Filter this list by:
   fà            #  Get the maximum prime factor
     I>‹         #  And check if it's smaller than or equal to the input
        }Xš      # After the filter: prepend 1 again
           ü‚    # Create pairs
             ʒ   # And filter these pairs by:
              ¥` #  Where the forward difference / delta is 1

Stax , 14 байт

Θ",²aÇu,á‼⌐çLB

Запустите и отладьте его

Это не самая короткая из возможных программ, но она начинает производить вывод, как только найдены подходящие пары. Это в конечном итоге завершается , но вывод производится, как он был найден.

Рубин , 89 + 8 = 97 байт

Использует -rprimeфлаг. Для каждого номера$i$ от 1 до $4^n$, сопоставьте его, [i, i+1]если оба$n$-Smooth, в противном случае сопоставьте его false, затем удалите все falseиз списка.

->n{g=->x{x.prime_division.all?{|b,_|b<=n}};(1..4**n).map{|i|g[i]&&g[i+1]&&[i,i+1]}-[!1]}

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