Einführung

In der Zahlentheorie sagen wir, dass eine Zahl $k$ glatt ist, wenn ihre Primfaktoren alle höchstens $k$ . Zum Beispiel ist 2940 7-glatt, weil $2940=2^2\cdot3\cdot5\cdot7^2$ .

Hier definieren wir ein $k$ glattes Paar als zwei aufeinanderfolgende ganze Zahlen, die beide $k$ glatt sind. Ein Beispiel von 7-Paar glatter wird $(4374,4375)$ , weil $4374=2\cdot3^7$ und $4375=5^4\cdot7$ . Lustige Tatsache: Dies ist tatsächlich das größte 7-Smooth-Paar .

Størmer bewies 1897, dass es für jedes $k$ nur endlich viele $k$ glatte Paare gibt , und diese Tatsache ist als Satz von Størmer bekannt .

Herausforderung

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu schreiben, die bei gegebener Primzahleingabe $k$ alle $k$ glatten Paare ohne Duplikat (Reihenfolge innerhalb des Paares ist egal) in beliebiger Reihenfolge ausgibt oder zurückgibt .

Bitte beachten Sie, dass für die Primzahlen $p$ und $q$ unter der Annahme von $p<q$ alle $p$ glatten Paare auch $q$ glatte Paare sind.

Beispiel-E / A

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)

Beschränkung

Das Programm oder die Funktion sollte theoretisch für alle Eingaben in endlicher Zeit enden. Standardlücken sind standardmäßig nicht zulässig.

Gewinnkriterien

Da dies eine Code-Golf- Herausforderung ist, gewinnt die kürzeste gültige Einsendung für jede Sprache.

JavaScript (ES7),  234  232 Byte

Findet die Lösungen durch Lösen von Pell-Gleichungen der Form $x^2-2qy^2=1$ , wobei $q$ eine $P$ glatte quadratfreie Zahl ist.

Dies ist eine Implementierung des Verfahrens von Derrick Henry Lehmer , abgeleitet von Størmers ursprünglichem Verfahren.

Gibt ein Objekt zurück, dessen Schlüssel und Werte die $P$ glatten Paare beschreiben.

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

Probieren Sie es online!

Wie?

Die Hilfsfunktion $s$ testet, ob eine gegebene Ganzzahl $n$ eine $P$ glatte Zahl ist, wenn sie mit $i=0$ aufgerufen wird , oder eine quadratfreie ¹ $P$ glatte Zahl, wenn sie mit $i=1$ aufgerufen wird .

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

Wir suchen nach allen quadratfreien ¹ $P$ -glatten Zahlen in $[1..P^P-1]$ , wobei $P^P$ als Obergrenze für $P!$.

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

Für jede oben gefundene Zahl $n$ suchen wir nach der fundamentalen Lösung der Pell-Gleichung $x^2-ny^2=1$ :

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

(Der obige Code ist die nicht-rekursive Version meiner Antwort auf diese andere Herausforderung. )

Sobald die fundamentale Lösung $(x_1,y_1)$ gefunden wurde, berechnen wir die Lösungen $(x_k,y_k)$ mit $k\le max(3,(P+1)/2)$ unter Verwendung der Wiederholungsrelationen:

Für jedes $x_k$ testen wir , ob $x_k$ ungerade ist, und beide $(x_k-1)/2$ und $(x_k+1)/2$ sind $P$ -Glatte. Wenn ja, speichern wir sie im Objekt $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: Da die Primalität der Divisoren nicht getestet wird, ist die Funktion $s$ für einige nicht-quadratische freie Zahlen sogar dann wahr, wenn sie mit $i=1$ aufgerufen wird . Die Idee ist, die meisten von ihnen herauszufiltern, damit nicht zu viele nutzlose Pell-Gleichungen gelöst werden.}

Jelly , 16 bis 14 Bytes

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

Probieren Sie es online!

Prüft auf Paare bis zu $4^k$ was für größere $k$ ineffizient ist, aber sicherstellen sollte, dass keine übersehen werden.

Vielen Dank an @ JonathanAllan für das Speichern von 1 Byte!

Erläuterung

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 Bytes

°Lü‚ʒfà@

Probieren Sie es online!

Erläuterung:

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

Jelly , 123 Bytes

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

Probieren Sie es online!

Dies ist eine relativ effiziente, aber lange Gelee-Antwort, die die Methode der fortgesetzten Brüche verwendet, um die grundlegende Lösung für die Pell-Gleichungen für zu lösen $2×$ jede k-glatte quadratfreie Zahl findet $\max(3, \frac{k+1}{2})$ lösungen für jeden und prüft dann ob $\frac{x-1}{2}, \frac{x+1}{2}$sind für jede Lösung glatt. Dies ist Lehmers Methode, wie im Wikipedia-Link der Frage beschrieben .

Ein vollständiges Programm, das ein einziges Argument benötigt, $k$und gibt eine Liste mit Listen von Paaren zurück. Der obige Code sortiert die endgültige Ausgabe nicht, der TIO-Link jedoch.

Haskell , 118 107 Bytes

-11 bytes dank 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)]

Probieren Sie es online!

• q n berechnet eine Liste aller Primfaktoren von n
• f k generiert eine Liste von $k$-glatte Paare für ein gegebenes k durch Filtern einer Liste aller Paare

Gelee , 24 Bytes

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

Probieren Sie es online!

Für 7 dauert dies lange, aber es wird viel schneller berechnet, wenn Sie die Quadratur der Fakultät entfernen: Probieren Sie es online aus!

Erläuterung:

³!²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 Bytes dank @JonathanAllen

Python 3 + Sympy, 116 Bytes

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]

Probieren Sie es online!

Python 3 + Sympy, 111 Bytes

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

Probieren Sie es online!

Zwei Variationen meiner Jelly-Antwort, aber in Python 3. Beide definieren eine Funktion, die ein Argument akzeptiert k. Die erste gibt eine Liste von Tupeln der Paare zurück, die die Kriterien erfüllen. Die Sekunde druckt sie zu stdout.

Wolfram Language (Mathematica) , 241 Byte

verwendet Pell-Gleichungen

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

Probieren Sie es online!

Pyth , 15 Bytes

f!>#QsPMTCtBS^4

Probieren Sie es online!

Verwendet die Beobachtung von Nick Kennedy, dass keine Ausgabenummer größer als sein wird 4^k.

05AB1E , 16 Bytes

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

Probieren Sie es online aus (extrem ineffizient, also zögern Sie nicht$n\gt3$..). Hier eine etwas schnellere Alternative , wenn auch noch ziemlich langsam.

Erläuterung:

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

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

Führen Sie es aus, und debuggen Sie es

Dies ist nicht das kürzestmögliche Programm, es wird jedoch ausgegeben, sobald passende Paare gefunden wurden. Es wird schließlich beendet , aber die Ausgabe wird so erstellt, wie sie gefunden wurde.

Ruby , 89 + 8 = 97 Bytes

Verwendet die -rprimeFlagge. Für jede Nummer$i$ von 1 bis $4^n$, ordnen Sie es zu, [i, i+1]wenn beide sind$n$-smooth, ordne es ansonsten zu falseund entferne dann alle falseaus der Liste.

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

Probieren Sie es online!