Ultraradical คืออะไร

ultraradicalหรือนำหัวรุนแรงของจำนวนจริงถูกกำหนดให้เป็นจริงเท่านั้นรากของสม quintic x 5 + x + = 0$a$$x^5+x+a=0$

ที่นี่เราใช้$UR(\cdot)$เพื่อแสดงถึงฟังก์ชั่น ultraradical ตัวอย่างเช่น$UR(-100010)=10$ตั้งแต่$10^5+10-100010=0$ 0

ท้าทาย

เขียนโปรแกรมเต็มรูปแบบหรือฟังก์ชั่นที่ใช้จำนวนจริงเป็นอินพุตและส่งกลับหรือส่งออกของบางเฉียบ

ความต้องการ

ไม่อนุญาตช่องโหว่มาตรฐาน ผลลัพธ์สำหรับกรณีทดสอบด้านล่างต้องมีความถูกต้องถึงตัวเลขอย่างน้อย 6 หลัก แต่โดยทั่วไปโปรแกรมควรคำนวณค่าที่สอดคล้องกันสำหรับอินพุตตัวเลขจริงที่ถูกต้อง

กรณีทดสอบ

มีทศนิยม 9 ตำแหน่งปัดเศษเป็น 0 เพื่อใช้อ้างอิง มีการเพิ่มคำอธิบายสำหรับกรณีทดสอบบางกรณี

 a                         | UR(a)
---------------------------+---------------------
             0             |   0.000 000 000        # 0
             1             |  -0.754 877 (666)      # UR(a) < 0 when a > 0
            -1             |   0.754 877 (666)      # UR(a) > 0 when a < 0
             1.414 213 562 |  -0.881 616 (566)      # UR(sqrt(2))
            -2.718 281 828 |   1.100 93(2 665)      # UR(-e)
             3.141 592 653 |  -1.147 96(5 385)      # UR(pi)
            -9.515 716 566 |   1.515 71(6 566)      # 5th root of 8, fractional parts should match
            10             |  -1.533 01(2 798)
          -100             |   2.499 20(3 570)
         1 000             |  -3.977 89(9 393)
      -100 010             |  10.000 0(00 000)      # a = (-10)^5 + (-10)
 1 073 741 888             | -64.000 0(00 000)      # a = 64^5 + 64

เกณฑ์การชนะ

การส่งที่ถูกต้องสั้นที่สุดในทุกภาษาชนะ

ภาษา Wolfram (Mathematica)ขนาด 20 ไบต์

Root[xx^5+x+#,1]&

ลองออนไลน์!

ยังคงอยู่ในตัว UltraRadicalแต่อย่างน้อยก็ไม่ได้เป็น

(ตัวละครจะปรากฏ|->ใน Mathematica คล้ายกับ=>ใน JS)

Python 3.8 (เผยแพร่ล่วงหน้า) , 60 ไบต์

f=lambda n,x=0:x!=(a:=x-(x**5+x+n)/(5*x**4+1))and f(n,a)or a

ลองออนไลน์!

วิธีการคำนวณซ้ำของนิวตัน $x' = x - \frac {f(x)} {f'(x)} = x - \frac {x^5+x+n} {5x^4+1}$

ในขณะที่ใช้$\frac {4x^5-n} {5x^4+1}$มีความเท่าเทียมกันทางคณิตศาสตร์ทำให้โปรแกรมวนซ้ำตลอดไป

วิธีอื่น ๆ :

Python 3.8 (เผยแพร่ล่วงหน้า) , 102 ไบต์

lambda x:a(x,-x*x-1,x*x+1)
a=lambda x,l,r:r<l+1e-9and l or(m:=(l+r)/2)**5+m+x>0and a(x,l,m)or a(x,m,r)

ลองออนไลน์!

ค้นหาไบนารี่เนื่องจากฟังก์ชั่นx^5+x+aนั้นเพิ่มขึ้น ตั้งค่าขอบเขต-abs(x)และabs(x)เป็นพอ แต่-x*x-1และx*x+1สั้นกว่า

ขีด จำกัด การเรียกซ้ำของ BTW Python ค่อนข้างต่ำเกินไปดังนั้นจึงจำเป็นต้องมี 1e-9 และ:=เรียกว่าตัวดำเนินการวอลรัส

JavaScript (ES7), 44 ไบต์

เวอร์ชันที่ปลอดภัยยิ่งขึ้นโดยใช้สูตรเดียวกับด้านล่าง แต่มีจำนวนการทำซ้ำที่แน่นอน

n=>(i=1e3,g=x=>i--?g(.8*x-n/(5*x**4+5)):x)``

ลองออนไลน์!

JavaScript (ES7),  43  42 ไบต์

วิธีการของนิวตันโดยใช้$5x^4+5$เป็นประมาณของ$f'(x)=5x^4+1$ 1

n=>(g=x=>x-(x-=(x+n/(x**4+1))/5)?g(x):x)``

ลองออนไลน์!

อย่างไร?

เราเริ่มต้นด้วย$x_0=0$และคำนวณซ้ำ:

จนกระทั่ง$x_k-x_{k+1}$ไม่มีนัยสำคัญ

เยลลี่ขนาด 8 ไบต์

;17B¤ÆrḢ

ลองออนไลน์!

มันทำงานอย่างไร:

• โครงสร้างรายการ[a, 1, 0, 0, 0, 1]โดย prepending aไปแทน binary 17ของ ทำไมรายการนี้ เพราะมันสอดคล้องกับค่าสัมประสิทธิ์ที่เรากำลังมองหา:

  [a, 1, 0, 0, 0, 1] -> P(x) := a + 1*x^1 + 0*x^2 + 0*x^3 + 0*x^4 + 1*x^5 = a + x + x^5
  

• จากนั้นÆrเป็นบิวด์อินที่แก้สมการพหุนามP(x) = 0ได้รับรายการค่าสัมประสิทธิ์ (สิ่งที่เราสร้างไว้ก่อนหน้านี้)

• เราสนใจเฉพาะโซลูชันที่แท้จริงเท่านั้นดังนั้นเราจึงเข้าสู่รายการแรกของรายการโซลูชันด้วย Ḣเรามีความสนใจเฉพาะในการแก้ปัญหาที่แท้จริงดังนั้นเราจึงใช้รายการแรกในรายการของการแก้ปัญหาที่มี

APL (Dyalog Unicode) , 11 10ไบต์^SBCS

-1 ขอบคุณ dzaima

ฟังก์ชันนำหน้าเงียบโดยไม่ระบุชื่อ

(--*∘5)⍣¯1

ลองออนไลน์!

(...)⍣¯1  ใช้ฟังก์ชัน tacit ต่อไปนี้เป็นลบในครั้งเดียว:

 - อาร์กิวเมนต์ที่ถูกทำให้ไร้ผล

 - ลบ

 *∘5 อาร์กิวเมนต์ยกกำลัง 5

ในสาระสำคัญนี้ถาม: ซึ่ง$x$ฉันจะต้องฟีด$f(x)=-x-x^5$ดังกล่าวว่าผลจะกลายเป็นปี$y$

R , 43 ไบต์

function(a)nlm(function(x)abs(x^5+x+a),a)$e

ลองออนไลน์!

nlm$x\mapsto |x^5+x+a|$nlma

R , 56 ไบต์

function(x)(y=polyroot(c(x,1,0,0,0,1)))[abs(Im(y))<1e-9]

ลองออนไลน์!

polyroot$a$polyroot

J , 14 ไบต์

{:@;@p.@,#:@17

ลองออนไลน์!

J ได้สร้างขึ้นสำหรับการแก้ชื่อพหุนาม ... p.

กรณีทดสอบ 4 รายการสุดท้ายหมดเวลาใน TIO แต่ในทางทฤษฎียังคงถูกต้อง

อย่างไร

ค่าสัมประสิทธิ์พหุนามสำหรับบิวด์อินของเจนั้นถูกนำมาเป็นรายการตัวเลขโดยมีสัมประสิทธิ์เป็นx^0อันดับแรก นี่หมายความว่ารายการคือ:

a 1 0 0 0 1

1 0 0 0 1เป็น 17 ในรูปของไบนารี่ดังนั้นเราจึงแทนค่าเป็น#:@17, จากนั้นจึงเพิ่มอินพุท,, ต่อจากนั้นนำไปใช้p., จากนั้นนำกล่องผลลัพธ์ออกด้วย raze ;แล้วนำองค์ประกอบสุดท้าย{:

Ruby , 53 41 ไบต์

->a{x=a/=5;99.times{x-=a/(x**4+1)+x/5};x}

ลองออนไลน์!

ใช้ Newton-Raphson พร้อมการวนซ้ำจำนวนคงที่และใช้การประมาณการแบบเดียวกับArnauld

Pari / GP , 34 32 26 24 ไบต์

a->-solve(X=0,a,a-X-X^5)

ลองออนไลน์!

05AB1E , 12 ไบต์

ΔyIy4m>/+5/-

ลองออนไลน์!

วิธีการของนิวตัน

k4, 33 31 ไบต์

{{y-(x+y+*/5#y)%5+5*/4#y}[x]/x}

newton-raphson คำนวณซ้ำ ๆ จนกระทั่งมีการรวมตัวเลข

แก้ไข: -2 ต้องขอบคุณ ngn!

อ๊ะเข้าใจผิดทั้งหมด ...

K (oK), 10 ไบต์

{-x+*/5#x}

Pari / GP 24 ไบต์

a->polrootsreal(x^5+x+a)

ลองออนไลน์!

C, 118b / 96B

#include<math.h>
double ur(double a){double x=a,t=1;while(fabs(t)>1e-6){t=x*x*x*x;t=(x*t+x+a)/(5*t+1);x-=t;}return x;}

118 ไบต์พร้อมชื่อฟังก์ชั่นดั้งเดิมและมีความแม่นยำพิเศษ (สองเท่า) ด้วย hacks บิตอาจจะดีกว่า แต่ไม่สามารถพกพาได้

96 ไบต์พร้อมการวนซ้ำที่แน่นอน

double ur(double a){double x=a,t;for(int k=0;k<99;k++){t=x*x*x*x;x=(4*x*t-a)/(5*t+1);}return x;}

ที่จริงแล้วฟังก์ชั่นของเราดีมากเราสามารถใช้วิธีการปรับตัวของนิวตันได้ดีขึ้น การใช้งานที่รวดเร็วและใช้งานได้จริง (150 ไบต์) จะเป็นเช่นนั้น

#include<math.h>
double ur(double a){double x=a/5,f=1,t;while(fabs(f)>1e-6){t=x*x*x*x;f=(t*(5*t*x+5*a+6*x)+a+x)/(15*t*t-10*a*x*x*x+1);x-=f;}return x;}

ฉันตรวจสอบว่ามันใช้งานได้ แต่ฉันขี้เกียจเกินกว่าที่จะรู้ว่ามันจะเร็วแค่ไหน ควรมีคำสั่งซื้ออย่างน้อยหนึ่งรายการที่เร็วกว่าของนิวตัน

สะอาด , 61 60 ไบต์

import StdEnv
$a=iter 99(\x=(3.0*x^5.0-a)/inc(4.0*x^4.0))0.0

ลองออนไลน์!

วิธีการของนิวตันใช้เป็นครั้งแรกในคำตอบของ user202729

สะอาด , 124 ไบต์

import StdEnv
$a= ?a(~a)with@x=abs(x^5.0+x+a);?u v|u-d==u=u|v+d==v=v= ?(u+if(@u< @v)0.0d)(v-if(@u> @v)0.0d)where d=(v-u)/3E1

ลองออนไลน์!

การค้นหา "ไบนารี" ทำให้พื้นที่การค้นหาแคบลงจนถึง 99.6% ของช่วงสูงสุดระหว่างขอบเขตสูงและต่ำในแต่ละการวนซ้ำแทนที่จะเป็น 50%

Python 3 + sympy, 72 ไบต์

lambda y:float(sympy.poly("x**5+x+"+str(y)).all_roots()[0])
import sympy

ลองออนไลน์!

อ็อกเทฟ 25 ไบต์

@(a)fzero(@(x)x^5+x+a,-a)

ลองออนไลน์!

Maplesoft Mapleขนาด 23 ไบต์

f:=a->fsolve(x^5+x+a=0)

น่าเสียดายที่ไม่มีผู้รวบรวม / เครื่องคิดเลขออนไลน์ของ Maple ออกมาที่นั่น AFAIK แต่รหัสค่อนข้างตรงไปตรงมา