Mục tiêu rất đơn giản: Đưa ra một giải pháp thực khác xcho phương trình sin(x) = -mx, đầu vào đã cho m, với số lượng byte ít nhất.

Thông số kỹ thuật:

• Câu trả lời của bạn phải chính xác đến 3 con số quan trọng.
• Bạn có thể xuất ra bất kỳ giải pháp thực tế nào ngoài giải pháp tầm thường x=0. Bạn có thể giả sử mlà có ít nhất một giải pháp tồn tại. Bạn cũng có thể giả định m!=0.

Một giải pháp python tối ưu rõ ràng bằng cách sử dụng độ dốc giảm dần :

from math import *
from random import *
a=x=0.001
m = 5.
def dE(x):return 2*(sin(x)+m*x+1)*(cos(x)+m)
for i in xrange(1000): x-=dE(x)*a
print x

Các trường hợp thử nghiệm

-0.25 -> ±2.4746
-0.1  -> ±2.8523 or ±7.0682 or ±8.4232
 0.2  -> ±4.1046 or ±4.9063 

ised : 32 28 byte

Sử dụng phép lặp của Newton bắt đầu từ π:

{:x-{sinx+$1*x}/{cosx+$1}:}:::pi

Đối số được truyền vào $1, có thể được lấy từ một tệp, như thế này:

ised --l inputfile.txt 'code'

Một chút kém ổn định, nhưng phiên bản ngắn hơn:

{:{x-tanx}/{1+$1/cosx}:}:::pi

Đôi khi nó ném các cảnh báo giới hạn lặp nhưng độ chính xác có vẻ tốt khi xem xét các điều kiện.

Phiên bản Unicode (cùng bytecount):

{λ{x-tanx}/{1+$1/cosx}}∙π

Bắt đầu từ 4 cắt một byte khác và dường như hội tụ đến cùng các giá trị

{λ{x-tanx}/{1+$1/cosx}}∙4

Haskell, 34 byte

f m=until(\x->sin x< -m*x)(+1e-3)0

Đếm xtừ 0 đến 0,001 cho đến khi sin(x)< -m*x.

Ví dụ về Ouput

f -0.2 ->   2.595999999999825
f -0.1 ->   2.852999999999797
f  0.0 ->   3.141999999999765
f  0.1 ->   3.4999999999997256
f  0.2 ->   4.1049999999997056

Toán học, 28 byte

x/.FindRoot[Sinc@x+#,{x,1}]&

Tìm kiếm một gốc số từ dự đoán ban đầu x=1. Các trường hợp thử nghiệm:

% /@ {-0.25, -0.1, 0.2}
(* {2.47458, 2.85234, 4.10462} *)

C, 99 byte

#include<math.h>
float f(float m){float x=1,y;do{x=(y=sin(x)+m*x)+x;}while(fabs(y)>1e-4);return x;}

vô dụng:

#include<math.h>
float f(float m){
 float x=1,y;
 do{x=(y=sin(x)+m*x)+x;}while(fabs(y)>1e-4);
 return x;
}

MATL , 17 byte

`@2e3/tY,wG_*>}4M

Điều này sử dụng tìm kiếm tuyến tính trên trục thực dương, vì vậy nó chậm. Tất cả các trường hợp thử nghiệm kết thúc trong vòng 1 phút trong trình biên dịch trực tuyến.

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

Giải trình

`         % Do...while
  @       %   Push iteration index, starting at 1
  2e3/    %   Divide by 2000
  t       %   Duplicate
  Y,      %   Sine
  w       %   Swap
  G_*     %   Multiply by minus the input
  >       %   Does the sine exceed that? If so, next iteration
}         % Finally (execute after last iteration, before exiting loop)
   4M     %   Push input of sine function again
          % Implicit end
          % Implicit display

C ++ 11, 92 91 byte

-1 byte để sử dụng #import

#import<cmath>
using F=float;F f(F m,F x=1){F y=sin(x)+m*x;return fabs(y)>1e-4?f(m,x+y):x;}

Python 2, 81 78 byte

Lặp lại điểm

Như lambda đệ quy

from math import*
f=lambda m,x=1:abs(sin(x)+m*x)>1e-4and f(m,sin(x)+m*x+x)or x

Như vòng lặp (81 byte):

from math import*
m=input()
x=1
while abs(sin(x)+m*x)>1e-4:x=sin(x)+m*x+x
print x

Toán học, 52 byte

NSolve[Sin@x==-x#,x,Reals][[;;,1,2]]~DeleteCases~0.&

Chức năng ẩn danh. Lấy một số làm đầu vào và trả về một danh sách các số làm đầu ra. Chỉ sử dụng NSolveđể giải phương trình gần đúng.

Tiên đề, 364 byte

bisezione(f,a,b)==(fa:=f(a);fb:=f(b);a>b or fa*fb>0=>"fail";e:=1/(10**(digits()-3));x1:=a;v:=x2:=b;i:=1;y:=f(v);if(abs(y)>e)then repeat(t:=(x2-x1)/2.0;v:=x1+t;y:=f(v);i:=i+1;if i>999 or t<=e or abs(y)<e then break;if fb*y<0 then(x1:=v;fa:=y)else if fa*y<0 then(x2:=v;fb:=y)else break);i>999 or abs(y)>e=>"fail";v)
macro g(m) == bisezione(x+->(sin(x)+m*x), 0.1, 4.3)

ungolf

bisezione(f,a,b)==
    fa:=f(a);fb:=f(b)
    a>b or fa*fb>0=>"fail"
    e:=1/(10**(digits()-3))
    x1:=a;v:=x2:=b;i:=1;y:=f(v)
    if(abs(y)>e) then
      repeat
        t:=(x2-x1)/2.0;v:=x1+t;y:=f(v);i:=i+1
        if i>999 or t<=e or abs(y)<e then break
        if      fb*y<0 then(x1:=v;fa:=y)
        else if fa*y<0 then(x2:=v;fb:=y)
        else break
    i>999 or abs(y)>e=>"fail"
    v

macro g(m) == bisezione(x+->(sin(x)+m*x), 0.1, 4.3)

các kết quả

(3) -> g(0.2)
   AXIOM will attempt to step through and interpret the code.
   (3)  4.1046198505 579058527
                                                              Type: Float
(4) -> g(-0.1)
   (4)  2.8523418944 500916556
                                                              Type: Float
(5) -> g(-0.25)
   (5)  2.4745767873 698290098
                                                              Type: Float

Haskell, 50 byte

Tôi mới tìm hiểu về phương pháp của newton trong lớp calc của tôi, vì vậy ở đây haskellsử dụng phương pháp của newton.

f m=foldl(\x _->x-(sin x+m*x)/(cos x+m))0[1..10]