introduzione

Nella teoria dei numeri, diciamo che un numero è $k$ liscio quando i suoi fattori primi sono tutti al massimo $k$ . Ad esempio, 2940 è 7-smooth perché $2940=2^2\cdot3\cdot5\cdot7^2$ .

Qui, definiamo una coppia $k$ smooth come due numeri interi consecutivi che sono entrambi $k$ smooth. Un esempio di 7 coppie lisce sarà $(4374,4375)$ perché $4374=2\cdot3^7$ e $4375=5^4\cdot7$ . Curiosità: questa è in realtà la più grande coppia 7-smooth .

Størmer dimostrò nel 1897 che per ogni $k$ , ci sono solo finitamente molte coppie $k$ smooth , e questo fatto è noto come Teorema di Størmer .

Sfida

Il tuo compito è quello di scrivere un programma o una funzione che, dato un numero primo di input $k$ , restituisca o restituisca tutte le coppie $k$ smooth senza duplicati (l'ordine all'interno della coppia non ha importanza) nell'ordine che desideri.

Si noti che per i numeri primi $p$ e $q$ , supponendo $p<q$ , tutte le coppie $p$ smooth sono anche coppie $q$ smooth.

I / O di esempio

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)

Restrizione

Il programma o la funzione dovrebbero teoricamente terminare a tempo finito per tutti gli input. Le scappatoie standard non sono consentite per impostazione predefinita.

Criteri vincenti

Poiché si tratta di una sfida di code-golf , vince l'invio valido più breve per ogni lingua.

JavaScript (ES7),  234  232 byte

Trova le soluzioni risolvendo le equazioni di Pell nella forma $x^2-2qy^2=1$ , dove $q$ è un numero libero quadrato liscio $P$

Questa è un'implementazione della procedura di Derrick Henry Lehmer , derivata dalla procedura originale di Størmer.

Restituisce un oggetto le cui chiavi e valori descrivono le coppie $P$ smooth.

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

Provalo online!

Come?

La funzione di supporto $s$ Verifica se un dato intero $n$ è un $P$ numero -liscia quando viene chiamata con $i=0$ , o libera una piazza ¹ $P$ numero -liscia quando viene chiamata con $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)

Cerchiamo tutti i numeri lisci e senza quadrato di ¹ $P$ in $[1..P^P-1]$ , dove $P^P$ è usato come limite superiore per $P!$.

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

Per ogni numero $n$ trovato sopra, cerchiamo la soluzione fondamentale dell'equazione di Pell$x^2-ny^2=1$ :

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

(il codice sopra è la versione non ricorsiva della mia risposta a questa altra sfida )

Una volta trovata la soluzione fondamentale $(x_1,y_1)$ , calcoliamo le soluzioni $(x_k,y_k)$ con $k\le max(3,(P+1)/2)$ , usando le relazioni di ricorrenza:

Per ogni $x_k$ , testiamo se $x_k$ è dispari e entrambi $(x_k-1)/2$ e $(x_k+1)/2$ sono $P$ smooth. In tal caso, li memorizziamo nell'oggetto $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: Poiché non verifica la primalità dei divisori, la funzione $s$ sarà effettivamente vera per alcuni numeri liberi non quadrati, anche quando viene chiamata con $i=1$ . L'idea è di filtrare la maggior parte di essi in modo che non vengano risolte troppe equazioni di Pell inutili.}

Gelatina , 16 14 byte

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

Provalo online!

Verifica la presenza di coppie fino a $4^k$ che è inefficiente per $k$ più grandi, ma dovrebbe assicurarsi che non ne manchi nulla.

Grazie a @JonathanAllan per aver salvato 1 byte!

Spiegazione

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 byte

°Lü‚ʒfà@

Provalo online!

Spiegazione:

°            # 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

Gelatina , 123 byte

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

Provalo online!

Questa è una risposta Jelly relativamente efficiente ma lunga che utilizza il metodo delle frazioni continue per risolvere la soluzione fondamentale per le equazioni di Pell $2×$ trova ogni numero senza quadrati k-smooth, trova $\max(3, \frac{k+1}{2})$ soluzioni per ciascuno e quindi verifica se $\frac{x-1}{2}, \frac{x+1}{2}$sono lisci per ogni soluzione. Questo è il metodo di Lehmer, come descritto nel link Wikipedia della domanda .

Un programma completo che accetta un singolo argomento, $k$e restituisce un elenco di elenchi di coppie. Il codice sopra non ordina l'output finale, ma lo fa il collegamento TIO.

Haskell , 118 107 byte

-11 byte grazie a nimi

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

Provalo online!

• q n calcola un elenco di tutti i fattori primi di n
• f k genera un elenco di $k$- coppie lisce per un dato k filtrando un elenco di tutte le coppie

Gelatina , 24 byte

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

Provalo online!

Questo richiede molto tempo per 7, ma si calcola molto più velocemente se si rimuove la quadratura del fattoriale: provalo online!

Spiegazione:

³!²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 byte grazie a @JonathanAllen

Python 3 + sympy, 116 byte

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]

Provalo online!

Python 3 + sympy, 111 byte

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

Provalo online!

Due variazioni sulla mia risposta Jelly ma in Python 3. Entrambe definiscono una funzione che accetta un argomento k. Il primo restituisce un elenco di tuple delle coppie che soddisfano i criteri. Il secondo li stampa su stdout.

Wolfram Language (Mathematica) , 241 byte

usa le equazioni di Pell

(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@#&]])&

Provalo online!

Pyth , 15 byte

f!>#QsPMTCtBS^4

Provalo online!

Utilizza l'osservazione di Nick Kennedy secondo cui nessun numero di output sarà maggiore di 4^k.

05AB1E , 16 byte

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

Provalo online (estremamente inefficiente, quindi time out per$n\gt3$..). Ecco un'alternativa leggermente più veloce , anche se ancora piuttosto lenta ..

Spiegazione:

°                # 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 byte

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

Esegui ed esegui il debug

Questo non è il programma più breve possibile, ma inizia a produrre output non appena vengono trovate le coppie corrispondenti. Alla fine termina , ma l'output viene prodotto come viene trovato.

Rubino , 89 + 8 = 97 byte

Usa la -rprimebandiera. Per ogni numero$i$ dal 1 al $4^n$, mappalo su [i, i+1]se entrambi lo sono$n$liscio, altrimenti mappalo su false, quindi pota tutto falsedall'elenco.

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

Provalo online!