Dato un intero positivo $n$ che non è un quadrato, trova la soluzione fondamentale $(x,y)$ dell'equazione di Pell associata

Dettagli

• Il fondamentale è una coppia di numeri interi soddisfa l'equazione in cui è minimo e positivo. (C'è sempre la soluzione banale che non viene conteggiata.)$(x,y)$$x,y$$x$$(x,y)=(1,0)$
• Puoi presumere che $n$ non sia un quadrato.

Esempi

 n           x    y
 1           -    -
 2           3    2
 3           2    1
 4           -    -
 5           9    4
 6           5    2
 7           8    3
 8           3    1
 9           -    -
10          19    6
11          10    3
12           7    2
13         649    180
14          15    4
15           4    1
16           -    -
17          33    8
18          17    4
19         170    39
20           9    2
21          55    12
22         197    42
23          24    5
24           5    1
25           -    -
26          51    10
27          26    5
28         127    24
29        9801    1820
30          11    2
31        1520    273
32          17    3
33          23    4
34          35    6
35           6    1
36           -    -
37          73    12
38          37    6
39          25    4
40          19    3
41        2049    320
42          13    2
43        3482    531
44         199    30
45         161    24
46       24335    3588
47          48    7
48           7    1
49           -    -
50          99    14
51          50    7
52         649    90
53       66249    9100
54         485    66
55          89    12
56          15    2
57         151    20
58       19603    2574
59         530    69
60          31    4
61  1766319049    226153980
62          63    8
63           8    1
64           -    -
65         129    16
66          65    8
67       48842    5967
68          33    4
69        7775    936
70         251    30
71        3480    413
72          17    2
73     2281249    267000
74        3699    430
75          26    3
76       57799    6630
77         351    40
78          53    6
79          80    9
80           9    1
81           -    -
82         163    18
83          82    9
84          55    6
85      285769    30996
86       10405    1122
87          28    3
88         197    21
89      500001    53000
90          19    2
91        1574    165
92        1151    120
93       12151    1260
94     2143295    221064
95          39    4
96          49    5
97    62809633    6377352
98          99    10
99          10    1

Sequenze OEIS pertinenti: A002350 A002349 A033313 A033317

Piet , 612 codici

Prende n dall'input standard. Emette y quindi x , separati da spazio.

Dimensione del codice 1:

Dimensione del codice 4, per una visualizzazione più semplice:

Spiegazione

Dai un'occhiata a questa traccia NPiet , che mostra il programma che calcola la soluzione per un valore di input di 99.

Non sono sicuro di aver mai sentito parlare dell'equazione di Pell prima di questa sfida, quindi ho ottenuto tutto quanto segue da Wikipedia; in particolare, queste sezioni di tre articoli:

• Equazione di Pell § Soluzione fondamentale mediante frazioni continue
• Metodi di calcolo delle radici quadrate § Espansione continua della frazione
• Frazione continua § Frazioni continue e convergenti infinite

Fondamentalmente, ciò che facciamo è questo:

1. Ottieni $n$ dall'input standard.
2. Trova $\lfloor\sqrt n\rfloor$incrementando un contatore fino a quando il suo quadrato supera$n$, quindi diminuiscilo una volta. (Questo è il primo loop che puoi vedere nella traccia, in alto a sinistra.)
3. Impostare alcune variabili per calcolare $x$ e $y$ dalla frazione continua di $\sqrt n$ .
4. Controlla se $x$ e $y$ adattano ancora all'equazione di Pell. Se lo fanno, emetti i valori (questo è il ramo verso il basso a circa 2/3 del modo in cui attraversano) e quindi esci (correndo nel blocco rosso all'estrema sinistra).
5. In caso contrario, aggiorna in modo iterativo le variabili e torna al passaggio 4. (Questo è l'anello largo verso destra, indietro attraverso il fondo e ricongiungersi non a metà strada.)

Sinceramente non ho idea se un approccio alla forza bruta sarebbe più breve e non ho intenzione di provarlo! Va bene, quindi l'ho provato.

Piet , 184 codici

Questa è l'alternativa alla forza bruta che ho detto ( nell'altra mia risposta ) che non volevo scrivere. Ci vogliono più di 2 minuti per calcolare la soluzione per n = 13. Non voglio davvero provarla su n = 29 ... ma verifica per ogni n fino a 20, quindi sono sicuro che sia corretta.

Come quell'altra risposta, questa prende n dall'input standard e produce y quindi x , separati da spazio.

Dimensione del codice 1:

Dimensione del codice 4, per una visualizzazione più semplice:

Spiegazione

Ecco la traccia NPiet per un valore di input di 5.

Questa è la più brutale della forza bruta, che scorre sia su $x$ che su $y$ . Altre soluzioni potrebbero scorrere su $x$ e quindi calcolare $y=\sqrt{\frac{x^2-1}{n}}$ , ma sonowimps.

Partendo da $x=2$ e $y=1$ , questo controlla se $x$ ed $y$ hanno ancora risolto l'equazione. Se ha (la forcella in basso vicino a destra), emette i valori ed esce.

In caso contrario, continua a sinistra, dove $y$ viene incrementato e confrontato con $x$ . (Poi c'è un po 'di direzione per seguire il percorso a zig-zag.)

Quest'ultimo confronto è dove il percorso si divide intorno alla metà sinistra. Se sono uguali, $x$ viene incrementato e $y$ viene riportato a 1. E torniamo a verificare se è ancora una soluzione.

Ho ancora degli spazi bianchi a disposizione, quindi forse vedrò se riesco a incorporare quel calcolo con radice quadrata senza ingrandire il programma.

Brachylog , 16 byte

;1↔;Ċz×ᵐ-1∧Ċ√ᵐℕᵐ

Provalo online!

Spiegazione

;1↔                Take the list [1, Input]
   ;Ċz             Zip it with a couple of two unknown variables: [[1,I],[Input,J]]
      ×ᵐ           Map multiply: [I, Input×J]
        -1         I - Input×J must be equal to 1
          ∧        (and)
           Ċ√ᵐ     We are looking for the square roots of these two unknown variables
              ℕᵐ   And they must be natural numbers
                   (implicit attempt to find values that match those constraints)

Pari / GP , 34 byte

PARI / GP ha quasi un built-in per questo: quadunitfornisce l' unità fondamentale del campo quadratico $\mathbb{Q}(\sqrt{D})$, dove$D$è ildiscriminantedel campo. In altre parole,quadunit(4*n)risolve l'equazione di Pell$x^2 - n \cdot y^2 = \pm 1$. Quindi devo prendere il quadrato quando la sua norma è$-1$.

Non so quale algoritmo utilizzi, ma funziona anche quando $n$ non è privo di quadrati.

Le risposte sono fornite nella forma x + y*w, dove windica $\sqrt{n}$ .

n->(a=quadunit(4*n))*a^(norm(a)<0)

Provalo online!

Wolfram Language (Mathematica) , 46 byte

FindInstance[x^2-y^2#==1&&x>1,{x,y},Integers]&

Provalo online!

05AB1E , 17 16 14 byte

Salvataggio di un byte grazie a Kevin Cruijssen .
Uscite[y, x]

∞.Δn*>t©1%_}®‚

Provalo online!

Spiegazione

∞                 # from the infinite list of numbers [1 ...]
 .Δ        }      # find the first number that returns true under
   n              # square
    *             # multiply with input
     >            # increment
      t©          # sqrt (and save to register as potential x)
        1%        # modulus 1
          _       # logical negation
            ®‚    # pair result (y) with register (x)

Java 8, 74 73 72 byte

n->{int x=1;var y=.1;for(;y%1>0;)y=Math.sqrt(-x*~++x/n);return x+" "+y;}

-1 byte grazie a @Arnauld .
-1 byte grazie a @ OlivierGrégoire .

Provalo online.

Spiegazione:

n->{                 // Method with double parameter and string return-type
  int x=1;           //  Integer `x`, starting at 1
  var y=.1;          //  Double `y`, starting at 0.1
  for(;y%1>0;)       //  Loop as long as `y` contains decimal digits:
    y=               //   Set `y` to:
      Math.sqrt(     //    The square-root of:
        -x*          //     Negative `x`, multiplied by
           ~++x      //     `(-x-2)` (or `-(x+1)-1)` to be exact)
                     //     (because we increase `x` by 1 first with `++x`)
               /n);  //     Divided by the input
  return x+" "+y;}   //  After the loop, return `x` and `y` with space-delimiter as result

R, 66 56 54 53 52 47 45 byte

un programma completo

n=scan();while((x=(1+n*T^2)^.5)%%1)T=T+1;x;+T

-1 -2 grazie a @Giuseppe

-7 grazie a @Giuseppe & @Robin Ryder -2 @JAD

Gelatina , 40 byte

½©%1İ$<®‘¤$п¹;Ḋ$LḂ$?Ḟṭ@ṫ-ṚZæ.ʋ¥ƒØ.,U¤-ị

Provalo online!

Una risposta alternativa alla gelatina, meno rigogliosa ma più efficiente algoritmicamente quando xey sono grandi. Questo trova i convergenti della frazione continuata regolare che si avvicinano alla radice quadrata di n, e quindi controlla che risolvono l'equazione di Pell. Ora trova correttamente il periodo della frazione continuata regolare.

Grazie a @TimPederick, ho anche implementato una soluzione basata su numeri interi che dovrebbe gestire qualsiasi numero:

Gelatina , 68 byte

U×_ƭ/;²®_$÷2ị$}ʋ¥µ;+®Æ½W¤:/$$
¹©Æ½Ø.;ÇƬṪ€F¹;Ḋ$LḂ$?ṭ@ṫ-ṚZæ.ʋ¥ƒØ.,U¤-ị

Provalo online!

Ad esempio, la soluzione per 1234567890 ha 1936 e 1932 cifre rispettivamente per il numeratore e il denominatore.

JavaScript (ES7), 47 byte

n=>(g=x=>(y=((x*x-1)/n)**.5)%1?g(x+1):[x,y])(2)

Provalo online!

Di seguito è una versione alternativa di 49 byte che tiene traccia di$x²-1$ direttamente invece di quadrare $x$ ad ogni iterazione:

n=>[(g=x=>(y=(x/n)**.5)%1?1+g(x+=k+=2):2)(k=3),y]

Provalo online!

Oppure possiamo andare in modo non ricorsivo per 50 byte :

n=>eval('for(x=1;(y=((++x*x-1)/n)**.5)%1;);[x,y]')

Provalo online!

TI-BASIC,  44  42 41 byte

Ans→N:"√(N⁻¹(X²-1→Y₁:1→X:Repeat not(fPart(Ans:X+1→X:Y₁:End:{X,Ans

L'input è $n$.
Output is a list whose values correspond to $(x,y)$.

Uses the equation $y=\sqrt{\frac{x^2-1}{n}}$ for $x\ge2$ to calculate the fundamental solution.
The current $(x,y)$ pair for that equation is a fundamental solution iff $y\bmod1=0$.

Examples:

6
               6
prgmCDGF12
           {5 2}
10
              10
prgmCDGF12
          {19 6}
13
              13
prgmCDGF12
       {649 180}

Explanation:

Ans→N:"√(N⁻¹(X²+1→Y₁:1→X:Repeat not(fPart(Ans:X+1→X:Y₁:End:{X,Ans  ;full logic

Ans→N                                                              ;store the input in "N"
      "√(N⁻¹(X²+1→Y₁                                               ;store the aforementioned
                                                                   ; equation into the first
                                                                   ; function variable
                     1→X                                           ;store 1 in "X"
                         Repeat not(fPart(Ans          End         ;loop until "Ans" is
                                                                   ; an integer
                                              X+1→X                ;increment "X" by 1
                                                    Y₁             ;evaluate the function
                                                                   ; stored in this variable
                                                                   ; at "X" and leave the
                                                                   ; result in "Ans"
                                                           {X,Ans  ;create a list whose
                                                                   ; values contain "X" and
                                                                   ; "Ans" and leave it in
                                                                   ; "Ans"
                                                                   ;implicitly print "Ans"

Note: TI-BASIC is a tokenized language. Character count does not equal byte count.

MATL, 17 bytes

`@:Ut!G*-!1=&fts~

Try it online!

Explanation

The code keeps increasing a counter k = 1, 2, 3, ... For each k, solutions x, y with 1 ≤ x ≤ k, 1 ≤ y ≤ k are searched. The process when some solution if found.

This procedure is guaranteed to find only one solution, which is precisely the fundamental one. To see why, note that

1. Any solution x>0, y>0 for n>1 satisfies x>y.
2. Se x , y è una soluzione e x ', y ' è una soluzione diversa, allora necessariamente x ≠ x ' e y ≠ y '.

Come conseguenza di 1 e 2,

• Quando la procedura si interrompe su un dato k , esiste solo una soluzione per quel k , perché se ci fossero due soluzioni una sarebbe stata trovata prima e il processo si sarebbe fermato con un k più piccolo .
• Questa soluzione è fondamentale, perché, ancora una volta, se ci fosse una soluzione con x più piccoli , sarebbe stata trovata in precedenza.

`       % Do...while
  @:U   %   Push row vector [1^2, 2^2, ..., k^2] where k is the iteration index
  t!    %   Duplicate and transpose. Gives the column vector [1^2; 2^2; ...; k^2]
  G*    %   Multiply by input n, element-wise. Gives [n*1^2; n*2^2; ...; n*k^2]
  -     %   Subtract with broadcast. Gives a square matrix of size n
  !     %   Transpose, so that x corresponds to row index and y to column index
  1=&f  %   Push row and column indices of all entries that equal 1. There can
        %   only be (a) zero such entries, in which case the results are [], [],
        %   or (b) one such entry, in which case the results are the solution x, y
  ts~   %   Duplicate, sum, negate. This gives 1 in case (a) or 0 in case (b)
        % End (implicit). Proceed with next iteration if top of the stack is true;
        % that is, if no solution was found.
        % Display (implicit). The stack contains copies of [], and x, y on top.
        % The empty array [] is not displayed

Python 2 , 49 byte

a=input()**.5
x=2
while x%a*x>1:x+=1
print x,x//a

Provalo online!

Trova xil numero più piccolo sopra 1 dove x % sqrt(n) <= 1/x. Quindi, trova yda xcome y = floor(x / sqrt(n)).

Haskell , 46 byte

Una semplice ricerca della forza bruta. Questo si avvale del fatto che una soluzione fondamentale$(x,y)$ soddisfacente $x^2 - ny^2 = 1$ deve avere $y \leq x$.

f n=[(x,y)|x<-[1..],y<-[1..x],x^2-n*y^2==1]!!0

Provalo online!

C # (compilatore interattivo Visual C #), 70 69 byte

n=>{int x=1;var y=.1;for(;y%1>0;)y=Math.Sqrt(-x*~++x/n);return(x,y);}

Porta della mia risposta Java 8 , ma genera una tupla invece di una stringa per salvare byte.

Provalo online.

Gelatina , 15 byte

‘ɼ²×³‘½µ⁺%1$¿;®

Provalo online!

Un programma completo che accetta un singolo argomento ne restituisce una tupla di x, y.

Buccia , 12 byte

ḟΛ¤ȯ=→*⁰□π2N

Provalo online!

Spiegazione

ḟΛ¤ȯ=→*⁰□π2N  Input is n, accessed through ⁰.
           N  Natural numbers: [1,2,3,4,..
         π2   2-tuples, ordered by sum: [[1,1],[1,2],[2,1],[1,3],[2,2],..
ḟ             Find the first that satisfies this:
 Λ             All adjacent pairs x,y satisfy this:
  ¤     □       Square both: x²,y²
   ȯ  *⁰        Multiply second number by n: x²,ny²
     →          Increment second number: x²,ny²+1
    =           These are equal.

MathGolf , 12 byte

ökî²*)_°▼Þ√î

Provalo online!

Sto lanciando un Ave Maria quando si tratta della formattazione dell'output. Se non è consentito, ho una soluzione che è più lunga di 1 byte. Il formato di output è x.0y, dove si .0trova il separatore tra i due numeri.

Spiegazione

ö       ▼      do-while-true with popping
 k             read integer from input
  î²           index of current loop (1-based) squared
    *          multiply the two
     )         increment (gives the potential x candidate
      _        duplicate TOS
       °       is perfect square
         Þ     discard everything but TOS
          √    square root
           î   index of previous loop (1-based)

Ho preso ispirazione dalla risposta 05AB1E di Emigna, ma sono stato in grado di trovare alcuni miglioramenti. Se il separatore che ho scelto non è consentito, aggiungi uno spazio prima dell'ultimo byte per un conteggio dei byte di 13.

APL (NARS), 906 byte

r←sqrti w;i;c;m
m←⎕ct⋄⎕ct←0⋄r←1⋄→3×⍳w≤3⋄r←2⋄→3×⍳w≤8⋄r←w÷2⋄c←0
i←⌊(2×r)÷⍨w+r×r⋄→3×⍳1≠×r-i⋄r←i⋄c+←1⋄→2×⍳c<900⋄r←⍬
⎕ct←m

r←pell w;a0;a;p;q2;p2;t;q;P;P1;Q;c;m
   r←⍬⋄→0×⍳w≤0⋄a0←a←sqrti w⋄→0×⍳a≡⍬⋄m←⎕ct⋄⎕ct←0⋄Q←p←1⋄c←P←P1←q2←p2←0⋄q←÷a
L: t←p2+a×p⋄p2←p⋄p←t
   t←q2+a×q
   :if c≠0⋄q2←q⋄:endif
   q←t           
   P←(a×Q)-P
   →Z×⍳Q=0⋄Q←Q÷⍨w-P×P
   →Z×⍳Q=0⋄a←⌊Q÷⍨a0+P
   c+←1⋄→L×⍳(1≠Qׯ1*c)∧c<10000
   r←p,q
   :if c=10000⋄r←⍬⋄:endif
Z: ⎕ct←m

Sopra ci sono 2 funzioni sqrti che trovano la radice quadrata del pavimento e la funzione pell restituisce Zilde per errore, e si basa sulla lettura della pagina http://mathworld.wolfram.com/PellEquation.html che userebbe l'algo per conoscere il sqrt di un numero trhu continua la frazione (anche se uso un algo per conoscere sqrt usando il metodo newton) e si ferma quando trova p e q tale che

 p^2-w*q^2=1=((-1)^c)*Qnext

Test:

  ⎕fmt pell 1x
┌0─┐
│ 0│
└~─┘
  ⎕fmt pell 2x
┌2───┐
│ 3 2│
└~───┘
  ⎕fmt pell 3x
┌2───┐
│ 2 1│
└~───┘
  ⎕fmt pell 5x
┌2───┐
│ 9 4│
└~───┘
  ⎕fmt pell 61x
┌2────────────────────┐
│ 1766319049 226153980│
└~────────────────────┘
  ⎕fmt pell 4x
┌0─┐
│ 0│
└~─┘
  ⎕fmt pell 7373x
┌2───────────────────────────────────────────────────────────┐
│ 146386147086753607603444659849 1704817376311393106805466060│
└~───────────────────────────────────────────────────────────┘
  ⎕fmt pell 1000000000000000000000000000002x
┌2────────────────────────────────────────────────┐
│ 1000000000000000000000000000001 1000000000000000│
└~────────────────────────────────────────────────┘

C'è un limite per i cicli nel loop nella funzione sqrti e un limite per i cicli per il loop nella funzione Pell, sia per il possibile numero di caso sono troppo grandi o algo non convergono ... (Non so se sqrti convergere ogni possibile input e lo stesso anche la funzione Pell)

Groovy , 53 byte

n->x=1;for(y=0.1d;y%1>0;)y=((++x*x-1)/n)**0.5;x+" "+y

Provalo online!

Le risposte Java e C # di Port of Kevin Cruijssen

Pyth, 15 byte

fsIJ@ct*TTQ2 2J

Provalo online qui . L'output viene xquindi yseparato da una nuova riga.

Wolfram Language (Mathematica) , 41 byte

{1//.y_/;!NumberQ[x=√(y^2#+1)]:>y+1,x}&

√è il carattere Unicode a 3 byte # 221A. Emette la soluzione nell'ordine (y, x) anziché (x, y). Come al solito con l'imperfetto //.e le sue iterazioni limitate, funziona solo su input in cui il vero valore diy è al massimo 65538.

Provalo online!

> <> , 45 byte

11v
+$\~:1
:}/!?:-1v?=1-*}:{*:@:{*:
$  naon;>

Provalo online!

Algoritmo di forza bruta, ricerca dall'alto x=2, con y=x-1e decrescente su ciascun loop, incrementando xquando yraggiunge 0. L'output è xseguito da y, separato da una nuova riga.

C # (compilatore interattivo Visual C #) , 69 byte

n=>{for(int x=2,y;;x++)for(y=0;y<=x;y++)if(x*x-y*y*n==1)return(x,y);}

Provalo online!

Python 3 , 75 byte

lambda i:next((x,y)for x in range(2,i**i)for y in range(x)if~-x**2==i*y**2)

Provalo online!

Spiegazione

Forza bruta. utilizzando

Questo codice verrebbe eseguito anche in Python 2. Tuttavia, la funzione range () in Python 2 crea un elenco anziché un generatore come in Python 3 ed è quindi immensamente inefficiente.

Con tempo e memoria inifinte, si potrebbe usare una comprensione dell'elenco invece dell'iteratore e salvare 3 byte in questo modo:

Python 3 , 72 byte

lambda i:[(x,y)for x in range(i**i)for y in range(x)if~-x**2==i*y**2][1]

Provalo online!

Python 2 , 64 byte

f=lambda n,x=2,y=1:x*x-n*y*y-1and f(n,x+(x==y),y*(y<x)+1)or(x,y)

Provalo online!

Ritorni (x, y).