Cho một số nguyên dương không phải là một hình vuông, tìm giải pháp cơ bản của phương trình Pell liên quan$n$$(x,y)$

Chi tiết

• Cơ bản là một cặp số nguyên thỏa mãn phương trình trong đó là cực tiểu và dương. (Luôn có giải pháp tầm thường không được tính.)$(x,y)$$x,y$$x$$(x,y)=(1,0)$
• Bạn có thể giả sử rằng không phải là một hình vuông.$n$

Ví dụ

 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

Các trình tự OEIS có liên quan: A002350 A002349 A033313 A033317

Piet , 612 codel

Mất n từ đầu vào tiêu chuẩn. Đầu ra y sau đó x , phân tách không gian.

Codel cỡ 1:

Codel size 4, để xem dễ dàng hơn:

Giải trình

Kiểm tra dấu vết NPiet này , cho thấy chương trình tính toán giải pháp cho giá trị đầu vào là 99.

Tôi không chắc liệu tôi đã từng nghe về phương trình của Pell trước thử thách này chưa, vì vậy tôi đã nhận được tất cả những điều sau đây từ Wikipedia; cụ thể, các phần của ba bài viết:

• Phương trình của Pell § Giải pháp cơ bản thông qua các phân số tiếp tục
• Phương pháp tính toán căn bậc hai § Tiếp tục mở rộng phân số
• Phần tiếp tục § Phân số và hội tụ vô hạn

Về cơ bản, những gì chúng tôi làm là đây:

1. Nhận $n$ từ đầu vào tiêu chuẩn.
2. Tìm $\lfloor\sqrt n\rfloor$bằng cách tăng một bộ đếm cho đến khi hình vuông của nó vượt quá$n$, sau đó giảm nó một lần. (Đây là vòng lặp đầu tiên bạn có thể thấy trong dấu vết, ở trên cùng bên trái.)
3. Thiết lập một số biến để tính $x$ và $y$ từ phần tiếp tục $\sqrt n$ .
4. Kiểm tra xem $x$ và $y$ phù hợp với phương trình của Pell chưa. Nếu có, hãy xuất các giá trị (đây là nhánh đi xuống khoảng 2/3 đường) và sau đó thoát (bằng cách chạy vào khối màu đỏ ở phía xa bên trái).
5. Nếu không, lặp lại cập nhật các biến và quay lại bước 4. (Đây là vòng lặp rộng ở bên phải, quay lại phía dưới và nối lại không quá nửa chừng.)

Tôi thực sự không biết liệu một cách tiếp cận vũ phu sẽ ngắn hơn hay không, và tôi sẽ không thử nó! Được rồi, vì vậy tôi đã thử nó.

Piet , 184 codel

Đây là sự thay thế vũ phu mà tôi đã nói (trong câu trả lời khác của tôi ) mà tôi không muốn viết. Phải mất hơn 2 phút để tính toán giải pháp cho n = 13. Tôi thực sự không muốn thử nó trên n = 29 ... nhưng nó kiểm tra cho mỗi n đến 20, vì vậy tôi tự tin rằng nó đúng.

Giống như câu trả lời khác, câu hỏi này lấy n từ đầu vào tiêu chuẩn và đầu ra y rồi x , được phân tách bằng dấu cách.

Codel cỡ 1:

Codel size 4, để xem dễ dàng hơn:

Giải trình

Đây là dấu vết NPiet cho giá trị đầu vào là 5.

Đây là sự tàn bạo nhất của lực lượng vũ phu, lặp đi lặp lại trên cả $x$ và $y$ . Các giải pháp khác có thể lặp qua $x$ và sau đó tính toán $y=\sqrt{\frac{x^2-1}{n}}$ , nhưng họwimps.

Bắt đầu từ $x=2$ và $y=1$ , điều này kiểm tra xem $x$ và $y$ đã giải phương trình chưa. Nếu nó có (ngã ba ở phía dưới gần bên phải), nó xuất ra các giá trị và thoát.

Nếu không, nó tiếp tục rời đi, trong đó $y$ được tăng lên và so với $x$ . (Sau đó, có một số hướng đi đôi để đi theo con đường ngoằn ngoèo.)

So sánh cuối cùng này là nơi đường dẫn phân chia xung quanh giữa bên trái. Nếu chúng bằng nhau, $x$ được tăng lên và $y$ được đặt trở lại 1. Và chúng tôi quay lại để kiểm tra xem đó có phải là giải pháp chưa.

Tôi vẫn còn một số khoảng trắng có sẵn, vì vậy có lẽ tôi sẽ xem liệu tôi có thể kết hợp phép tính căn bậc hai đó mà không mở rộng chương trình hay không.

Brachylog , 16 byte

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

Hãy thử trực tuyến!

Giải trình

;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 gần như có một built-in cho việc này: quadunitcung cấp cho các đơn vị cơ bản của lĩnh vực phương $\mathbb{Q}(\sqrt{D})$, trong đó$D$làphân biệt đối xửcủa lĩnh vực. Nói cách khác,quadunit(4*n)giải quyết phương trình của Pell$x^2 - n \cdot y^2 = \pm 1$. Vì vậy, tôi phải lấy hình vuông khi định mức của nó là$-1$.

Tôi không biết nó sử dụng thuật toán gì, nhưng nó thậm chí hoạt động khi $n$ không có hình vuông.

Câu trả lời được đưa ra trong các hình thức x + y*w, nơi wbiểu thị $\sqrt{n}$ .

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 46 byte

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

Hãy thử trực tuyến!

05AB1E , 17 16 14 byte

Đã lưu một byte nhờ Kevin Cruijssen .
Đầu ra[y, x]

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

Hãy thử trực tuyến!

Giải trình

∞                 # 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 nhờ @Arnauld .
-1 byte nhờ @ OlivierGrégoire .

Hãy thử trực tuyến.

Giải trình:

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

một chương trình đầy đủ

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

-1 -2 nhờ @Giuseppe

-7 cảm ơn @Giuseppe & @Robin Ryder -2 @JAD

Thạch , 40 byte

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

Hãy thử trực tuyến!

Một câu trả lời Jelly khác, ít chơi golf hơn nhưng hiệu quả hơn về mặt thuật toán khi x và y lớn. Điều này tìm thấy các điểm hội tụ của phần tiếp tục đều đặn xấp xỉ căn bậc hai của n, và sau đó kiểm tra xem phương trình nào giải phương trình Pell. Bây giờ tìm đúng thời gian của phân số tiếp tục thường xuyên.

Nhờ @TimPederick, tôi cũng đã triển khai một giải pháp dựa trên số nguyên sẽ xử lý bất kỳ số nào:

Thạch , 68 byte

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

Hãy thử trực tuyến!

Ví dụ: giải pháp cho 1234567890 có 1936 và 1932 chữ số cho tử số và mẫu số tương ứng.

JavaScript (ES7), 47 byte

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

Hãy thử trực tuyến!

$x²-1$$x$

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

Hãy thử trực tuyến!

Hoặc chúng ta có thể đi theo cách không đệ quy cho 50 byte :

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

Hãy thử trực tuyến!

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

$n$
$(x,y)$

$y=\sqrt{\frac{x^2-1}{n}}$$x\ge2$
$(x,y)$$y\bmod1=0$

Ví dụ:

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

Giải trình:

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"

Lưu ý: TI-BASIC là ngôn ngữ được mã hóa. Số lượng ký tự không bằng số byte.

MATL , 17 byte

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

Hãy thử trực tuyến!

Giải trình

Mã này tiếp tục gia tăng một bộ đếm k = 1, 2, 3, ... Đối với mỗi k , giải pháp x , y với 1 ≤ x ≤ k , 1 ≤ y ≤ k được tìm kiếm. Quá trình khi một số giải pháp nếu tìm thấy.

Thủ tục này được đảm bảo chỉ tìm thấy một giải pháp, đó chính xác là giải pháp cơ bản. Để xem tại sao, lưu ý rằng

1. Mọi giải pháp x > 0, y > 0 với n > 1 đều thỏa mãn x > y .
2. Nếu x , y là một giải pháp và x ', y ' là một giải pháp khác nhau thì nhất thiết phải là x ≠ x ' và y ≠ y '.

Hậu quả của 1 và 2,

• Khi thủ tục dừng ở một k cho trước , chỉ có một giải pháp tồn tại cho k đó , bởi vì nếu có hai giải pháp, một trong số chúng sẽ được tìm thấy trước đó và quá trình sẽ dừng lại với k nhỏ hơn .
• Giải pháp này là giải pháp cơ bản, bởi vì, một lần nữa, nếu có một giải pháp có x nhỏ hơn thì nó sẽ được tìm thấy trước đó.

`       % 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

Hãy thử trực tuyến!

Tìm xsố nhỏ nhất trên 1 trong đóx % sqrt(n) <= 1/x . Sau đó, tìm thấy ytừ xnhư y = floor(x / sqrt(n)).

Haskell , 46 byte

$(x,y)$$x^2 - ny^2 = 1$$y \leq x$

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

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác 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);}

Cổng trả lời Java 8 của tôi , nhưng xuất ra một tuple thay vì một chuỗi để lưu byte.

Hãy thử trực tuyến.

Thạch , 15 byte

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

Hãy thử trực tuyến!

Một chương trình đầy đủ có một đối số duy nhất nvà trả về một tuple x, y.

Husk , 12 byte

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

Hãy thử trực tuyến!

Giải trình

ḟΛ¤ȯ=→*⁰□π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î²*)_°▼Þ√î

Hãy thử trực tuyến!

Tôi đang ném một kinh Kính Mừng khi nói đến định dạng đầu ra. Nếu nó không được phép, tôi có một giải pháp dài hơn 1 byte. Định dạng đầu ra là x.0y, .0dấu phân cách giữa hai số.

Giải trình

ö       ▼      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)

Tôi lấy một số cảm hứng từ câu trả lời 05AB1E của Emigna, nhưng đã có thể tìm thấy một số cải tiến. Nếu dấu phân cách tôi chọn không được phép, hãy thêm khoảng trắng trước byte cuối cùng cho số byte là 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

Ở trên có 2 hàm chức năng sqrti sẽ tìm thấy căn bậc hai và hàm vuông sẽ trả về lỗi Zilde và dựa trên việc đọc trang http://mathworld.wolfram.com/PellEquation.html nó sẽ sử dụng thuật toán để biết sqrt của một số trhu tiếp tục phân số (ngay cả khi tôi sử dụng một thuật toán để biết sqrt bằng phương pháp newton) và dừng lại khi nó tìm thấy p và q sao cho

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

Kiểm tra:

  ⎕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ó giới hạn cho các chu kỳ trong vòng lặp trong hàm sqrti và giới hạn cho các chu kỳ cho vòng lặp trong hàm Pell, cả hai số trường hợp có thể là quá lớn hoặc algo không hội tụ ... (Tôi không biết nếu sqrti hội tụ mọi đầu vào có thể và chức năng Pell cũng vậy)

Groovy , 53 byte

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

Hãy thử trực tuyến!

Các câu trả lời Java và C # của cảng Kevin Cruijssen

Bình thường, 15 byte

fsIJ@ct*TTQ2 2J

Hãy thử trực tuyến tại đây . Đầu ra xsau đó được yphân tách bằng một dòng mới.

Ngôn ngữ Wolfram (Mathicala) , 41 byte

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

√là ký tự Unicode 3 byte # 221A. Đưa ra giải pháp theo thứ tự (y, x) thay vì (x, y). Như thường lệ với sự không hoàn hảo//. lần lặp và giới hạn của nó, chỉ hoạt động trên các đầu vào trong đó giá trị thực của tối đa ylà 65538.

Hãy thử trực tuyến!

> <> , 45 byte

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

Hãy thử trực tuyến!

Thuật toán Brute force, tìm kiếm từ x=2trên xuống, với y=x-1và giảm dần trên mỗi vòng lặp, tăng dần xkhi yđạt đến 0. Đầu ra được xtheo sau y, cách nhau bởi một dòng mới.

C # (Trình biên dịch tương tác 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);}

Hãy thử trực tuyến!

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)

Hãy thử trực tuyến!

Giải trình

Mã này cũng sẽ chạy trong Python 2. Tuy nhiên, hàm phạm vi () trong Python 2 tạo ra một danh sách thay vì một trình tạo như trong Python 3 và do đó vô cùng kém hiệu quả.

Với thời gian và bộ nhớ inifinte, người ta có thể sử dụng một sự hiểu biết danh sách thay vì trình lặp và lưu 3 byte như vậy:

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]

Hãy thử trực tuyến!

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)

Hãy thử trực tuyến!

Trả về (x, y).