Nhiệm vụ của bạn là tính căn bậc hai của 2 bằng Phương pháp Newton - với một chút thay đổi. Chương trình của bạn là tính toán một lần lặp bằng Phương pháp của Newton và xuất mã nguồn cho lần lặp sau (phải có khả năng thực hiện tương tự).

Phương pháp của Newton được mô tả khá kỹ lưỡng trên Wikipedia

Để tính căn bậc 2 bằng phương pháp Newton, bạn:

• Định nghĩa f(x) = x^2 - 2
• Định nghĩa f'(x) = 2x
• Xác định x[0](dự đoán ban đầu)= 1
• Định nghĩa x[n+1] = x[n] - (f[n] / f'[n])

Mỗi lần lặp sẽ di chuyển x [n] gần hơn với căn bậc hai của hai. Vì thế -

• x[0] = 1
• x[1] = x[0] - f(x[0])/f'(x[0]) = 1 - (1 ^ 2 - 2) / (2 * 1) = 1.5
• x[2] = x[1] - f(x[1])/f'(x[1]) = 1.5 - (1.5 ^ 2 - 2) / (2 * 1.5) = 1.416666667
• x[3] = x[2] - f(x[2])/f'(x[1]) = 1.416666667 - (1.416666667 ^ 2 - 2) / (2 * 1.416666667) = 1.414215686
• và v.v.

Chương trình của bạn sẽ:

• Tính toán x[n]đâu nlà số lần chương trình đã được chạy
• Xuất mã nguồn cho một chương trình hợp lệ trong cùng một ngôn ngữ phải tính toán x[n+1]và đáp ứng cùng tiêu chí của câu hỏi này.
• Dòng đầu tiên của mã nguồn phải là kết quả tính toán, được nhận xét đúng. Nếu nguồn yêu cầu một cái gì đó cụ thể (chẳng hạn như một shebang) trên dòng đầu tiên, kết quả có thể được đặt trên dòng thứ hai.

Lưu ý rằng

• Chương trình của bạn phải sử dụng dự đoán ban đầu về x[0] = 1
• Các lỗ hổng tiêu chuẩn được áp dụng
• Bất kỳ chức năng xây dựng, căn bậc hai hoặc hàm xroot đều bị cấm
• Chương trình của bạn không được chấp nhận bất kỳ đầu vào nào. Nó phải hoàn toàn khép kín.

Điểm của bạn là kích thước của chương trình ban đầu của bạn theo byte UTF-8. Điểm thấp nhất sẽ thắng.

Lisp thường gặp, 223 95 68 66

(#1=(lambda(x p)(format t"~S~%~S"p`(,x',x,(+(/ p 2)(/ p)))))'#1#1)

Bây giờ tôi đã đọc báo cáo vấn đề cẩn thận hơn (cảm ơn, primo !) Tôi nhận thấy rằng dòng đầu tiên phải là kết quả của tính toán, không phải là nó cần phải chứa kết quả. Vì vậy, tôi nghĩ rằng những nỗ lực trước đây của tôi không hoàn toàn tuân theo các quy tắc. Điều này nên.

Ví dụ sử dụng (SBCL 1.1.15):

$ sbcl --script nq.lisp | tee nq2.lisp
1
((LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P)))))
 '(LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P))))) 3/2)
$ sbcl --script nq2.lisp | tee nq3.lisp
3/2
((LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P)))))
 '(LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P))))) 17/12)
$ sbcl --script nq3.lisp | tee nq4.lisp
17/12
((LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P)))))
 '(LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P))))) 577/408)
$ sbcl --script nq4.lisp | tee nq5.lisp
577/408
((LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P)))))
 '(LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P)))))
 665857/470832)
$ sbcl --script nq5.lisp | tee nq6.lisp
665857/470832
((LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P)))))
 '(LAMBDA (X P) (FORMAT T "~S~%~S" P `(,X ',X ,(+ (/ P 2) (/ P)))))
 886731088897/627013566048)
$

Python 60 byte

x=1.
o='x=%s\no=%r;print o%%(x/2+1/x,o)';print o%(x/2+1/x,o)

Tôi đã đơn giản hóa công thức một chút, sử dụng các thay thế sau:

  x-(x²-2)/(2x)
= (2x²)/(2x)-(x²-2)/(2x)
= (2x²-x²+2)/(2x)
= (x²+2)/(2x)
= (x+2/x)/2
= x/2+1/x

Tôi hy vọng đó không phải là một vấn đề.

Chương trình tiến hành theo cách sau:

$ python newton-quine.py
x=1.5
o='x=%s\no=%r;print o%%(x/2+1/x,o)';print o%(x/2+1/x,o)

$ python newton-quine.py
x=1.41666666667
o='x=%s\no=%r;print o%%(x/2+1/x,o)';print o%(x/2+1/x,o)

$ python newton-quine.py
x=1.41421568627
o='x=%s\no=%r;print o%%(x/2+1/x,o)';print o%(x/2+1/x,o)

$ python newton-quine.py
x=1.41421356237
o='x=%s\no=%r;print o%%(x/2+1/x,o)';print o%(x/2+1/x,o)

v.v.

CJam, 20 byte

1
{\d_2/1@/+p"_~"}_~

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

Đầu ra

$ cjam <(echo -e '1\n{\d_2/1@/+p"_~"}_~'); echo
1.5
{\d_2/1@/+p"_~"}_~
$ cjam <(cjam <(echo -e '1\n{\d_2/1@/+p"_~"}_~')); echo
1.4166666666666665
{\d_2/1@/+p"_~"}_~
$ cjam <(cjam <(cjam <(echo -e '1\n{\d_2/1@/+p"_~"}_~'))); echo
1.4142156862745097
{\d_2/1@/+p"_~"}_~
$ cjam <(cjam <(cjam <(cjam <(echo -e '1\n{\d_2/1@/+p"_~"}_~')))); echo
1.4142135623746899
{\d_2/1@/+p"_~"}_~

Làm thế nào nó hoạt động

1       " Push the initial guess.                                                 ";
{       "                                                                         ";
  \d    " Swap the code block with the initial guess and cast to Double.          ";
  _2/   " Duplicate the initial guess and divide the copy by 2.                   ";
  1@/   " Push 1, rotate the initial guess on top and divide.                     ";
  +p    " Add the quotients and print.                                            ";
  "_~"  " Push the string '_~'.                                                   ";
}       "                                                                         ";
_~      " Duplicate the code block (to leave a copy on the stack) and execute it. ";

Bản thảo 6, 38 36

(f=x=>"(f="+f+")("+(x/2+1/x)+")")(1)
(f=x=>"(f="+f+")("+(x/2+1/x)+")")(1.5)
(f=x=>"(f="+f+")("+(x/2+1/x)+")")(1.4166666666666665)
(f=x=>"(f="+f+")("+(x/2+1/x)+")")(1.4142156862745097)
(f=x=>"(f="+f+")("+(x/2+1/x)+")")(1.4142135623746899)

JavaScript, 51

(function f(x){return "("+f+")("+(x/2+1/x)+")"})(1)

Điều này giống như ở trên, đối với các trình duyệt cũ hơn.

Lư 129

Có lẽ cách quá dài, nhưng Lua quine hút vì lồng [[ ]]là một tính năng không dùng nữa. Nhưng nó hoạt động bất kể:

x=1.0;x=x/2.+1./x;l=[[io.write('x=',x,';x=x/2.+1./x;l=[','[',l,']','];',l)]];io.write('x=',x,';x=x/2.+1./x;l=[','[',l,']','];',l)

Sẽ tốt hơn một chút để xem nếu bạn thêm dòng mới thay vì dấu hai chấm:

x=1.0
x=x/2.+1./x
l=[[io.write('x=',x,'\nx=x/2.+1./x\nl=[','[',l,']','];',l)]];io.write('x=',x,'\nx=x/2.+1./x\nl=[','[',l,']','];',l)

J - 102 88 byte

Điều này thật kinh khủng như tôi đang thực hiện các nhiệm vụ (tôi có thể sẽ sửa đổi điều này khi tôi có ý tưởng tốt hơn). Phao của J được giới hạn ở 5 vị trí thập phân, nhưng bằng cách thay thế dòng đầu tiên bằng x=:1xnó sẽ là một phần có độ chính xác vô hạn.

Edit 1: I got better idea. Also added the explanation.

x=:1
((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'x=:((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'''

Vài lần lặp đầu tiên:

x=:1.5
((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'x=:((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'''

x=:1.41667
((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'x=:((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'''

x=:1.41422
((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'x=:((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'''

Giải trình

((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'x=:((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:)'''
((3&{.,[:":(x%2)+1%x"_),:3&}.,],{:,{:) The quine-function
                         3&}.,],{:,{:  Build the second row
                         3&}.          Get everything but the first 3 characters from the string
                             ,]        Get the whole string and concat
                               ,{:     Get the last item (') and concat
                                  ,{:  -||-
 (3&{.,[:":(x%2)+1%x"_)                Build the first row
       [:":(x%2)+1%x"_                 Calculate x/2 + 1/x (stolen from Pythoneer) and stringify
  3&{.                                 Take the first 3 characters from the string (x=:)
      ,                                Concatenate 'x=:' and the result
                       ,:              Concatenate the two rows

Ruby, 65

x=1.0
puts"x=#{x/2+1/x}",<<'1'*2,1
puts"x=#{x/2+1/x}",<<'1'*2,1
1

Như thường xuyên xảy ra, đây gần như là một cổng thẳng của giải pháp Python.