ฟังก์ชั่น Pi เป็นส่วนเสริมของแฟกทอเรียลเหนือ reals (หรือจำนวนที่ซับซ้อน) สำหรับจำนวนเต็มn , Π (n) = n! แต่เพื่อให้ได้คำจำกัดความเหนือ reals เรากำหนดมันโดยใช้อินทิกรัล:

ในการท้าทายนี้เราจะสลับฟังก์ชันΠ

รับจำนวนจริงZ ≥ 1ค้นหาบวกxดังกล่าวว่าΠ (x) = Z คำตอบของคุณจะต้องแม่นยำอย่างน้อย 5 หลัก

ตัวอย่าง:

120 -> 5.0000
10 -> 3.39008
3.14 -> 2.44815
2017 -> 6.53847
1.5 -> 1.66277

Mathematica, 17 15 27 ไบต์

FindInstance[#==x!&&x>0,x]&

เอาต์พุตดูเหมือนว่าโซลูชันอยู่{{x -> n}}ที่ไหนnซึ่งอาจไม่ได้รับอนุญาต

Pyth, 4 ไบต์

.I.!

โปรแกรมที่รับอินพุตของตัวเลขและพิมพ์ผลลัพธ์

ชุดทดสอบ

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

.I.!    Program. Input: Q
.I.!GQ  Implicit variable fill
.I      Find x such that:
  .!G    gamma(x+1)
     Q   == Q
        Implicitly print

MATL , 13 ไบต์

1`1e-5+tQYgG<

การใช้งานเชิงเส้นนี้ seach ในขั้นตอนของการเริ่มต้นที่1e-5 1ดังนั้นมันช้ามากและหมดเวลาในคอมไพเลอร์ออนไลน์

เพื่อทดสอบ, การเชื่อมโยงต่อไปนี้แทนที่ต้องการความถูกต้องโดย1e-5 ลองออนไลน์!1e-2

คำอธิบาย

1        % Push 1 (initial value)
`        % Do...while
  1e-5   %   Push 1e-5
  +      %   Add
  t      %   Duplicate
  QYg    %   Pi function (increase by 1, apply gamma function)
  G<     %   Is it less than the input? If so: next iteration
         % End (implicit)
         % Display (implicit)

GeoGebraขนาด 25 ไบต์

NSolve[Gamma(x+1)=A1,x=1]

ป้อนในการป้อนข้อมูล CAS A1และคาดว่าการป้อนข้อมูลของจำนวนในเซลล์สเปรดชีต {x = <result>}ส่งกลับอาร์เรย์หนึ่งองค์ประกอบของรูปแบบ

นี่คือ gif ของการประมวลผล:

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

Numerically Solveสมการต่อไปนี้: มีค่าเริ่มต้นGamma(x+1)=A1x=1

MATLAB, 59 ไบต์

@(x)fminsearch(@(t)(gamma(t+1)-x)^2,1,optimset('TolF',eps))

นี่คือฟังก์ชั่นนิรนามที่พบว่า minimizer ของความแตกต่างยกกำลังสองระหว่างฟังก์ชั่น Pi และอินพุตของมันเริ่มต้นที่1ด้วยความอดทนน้อยมาก (มอบให้โดยeps) เพื่อให้ได้ความแม่นยำที่ต้องการ

กรณีทดสอบ (ทำงานบน Matlab R2015b):

>> @(x)fminsearch(@(t)(gamma(t+1)-x)^2,1,optimset('TolF',eps))
ans = 
    @(x)fminsearch(@(t)(gamma(t+1)-x)^2,1,optimset('TolF',eps))
>> f = ans; format long; f(120), f(10), f(3.14), f(2017)
ans =
   5.000000000000008
ans =
   3.390077650547032
ans =
   2.448151165246967
ans =
   6.538472664321318

คุณทำได้ ลองออนไลน์ได้ใน Octave แต่น่าเสียดายที่ผลลัพธ์บางรายการขาดความแม่นยำที่ต้องการ

J, 86 33 ไบต์

((]-(-~^.@!)%[:^.@!D.1])^:_>:)@^.

ใช้วิธีของนิวตันด้วย log Pi เพื่อหลีกเลี่ยงการล้น

นี่เป็นรุ่นก่อนหน้าที่คำนวณ log แกมม่าโดยใช้การประมาณของ Stirling ขนาดขั้นตอน (1e3) และจำนวนคำใน Log Gamma (3) สามารถเพิ่มขึ้นได้เพื่อความแม่นยำที่สูงขึ้นด้วยค่าใช้จ่ายของประสิทธิภาพ

3 :'(-(k-~g)%%&1e3(g=:((%~12 _360 1260 p.&:%*:)+-+^~-&^.%:@%&2p1)@>:)D:1])^:_>:k=:^.y'

อีกเวอร์ชั่นที่คำนวณเงื่อนไขสัมประสิทธิ์ได้ทันที

3 :'(-((-^.y)+g)%%&1e3(g=:((%~(((%1-^@-)t:%]*<:)+:>:i.3)p.%@*:)+(*^.)-]+-:@^.@%&2p1)@>:)D:1])^:_>:^.y'

ลองออนไลน์! และเพื่อดูข้อกำหนดบรรจบกัน

คำอธิบาย

((]-(-~^.@!)%[:^.@!D.1])^:_>:)@^.  Input: float y
(                            )@^.  Operate on log(y)
                           >:        Increment, the initial guess is log(y)+1
 (                     )^:_          Repeat until convergence starting with x = log(y)+1
                      ]                Get x
               ^.@!                    The log Pi verb
             [:    D.1                 Approximate its first derivative at x
       ^.@!                            Apply log Pi to x
     -~                                Subtract log(y) from it
            %                          Divide it by the derivative
  ]-                                   Subtract it from x and use as next value of x

Mathematica ขนาด 21 ไบต์

FindRoot[#-x!,{x,1}]&

FindRoot ใช้วิธีการของนิวตันภายในเมื่อมีค่าเริ่มต้น

สองวิธีด้านล่างใช้วิธีของนิวตันโดยตรง

ทางเลือกโดยใช้ FixedPoint 45 ไบต์

FixedPoint[#-(#!-y)/Gamma'[#+1]&,Log[y=#]+1]&

การใช้วิธีการของนิวตันในการแก้ปัญหานี้อย่างแม่นยำยิ่งขึ้นเนื่องจาก Mathematica สามารถคำนวณอนุพันธ์โดยตรงแทนการประมาณ

การใช้กฎเพื่อแทนที่ซ้ำแล้วซ้ำอีกจะสั้นลง แต่มีข้อ จำกัด (65536) ถึงจำนวนการวนซ้ำที่สามารถดำเนินการที่อาจถูกตีในขณะที่FixedPointไม่มีขีด จำกัด

ทางเลือกอื่นโดยใช้กฎ 38 ไบต์

Log[y=#]+1//.x_->x-(x!-y)/Gamma'[x+1]&

เยลลี่ 34 ไบต์

Ḋ!Æl_®
ȷİ‘×;µ!ÆlI÷I÷@Ç_@ḊḢ
Æl©‘ÇÐĿ

ลองออนไลน์! หรือดูค่ากลางขณะที่พวกเขามาบรรจบกันดูค่ากลางที่พวกเขามาบรรจบกัน

การดำเนินการของการรวมกันของวิธีการของนิวตันและการประมาณอนุพันธ์ (วิธีเซแคนต์) เพื่อคำนวณค่าผกผันของΠ ( n )

มันจะแก้ปัญหาค่าผกผันของบันทึก ( Π ( n) )) แทนเพื่อหลีกเลี่ยงการล้น

มันเริ่มต้นด้วยการเดาเริ่มต้นx ₀ = y +1 โดยที่y = log ( Π ( n )) จากนั้นมันจะวนซ้ำจนกว่าการบรรจบกันโดยใช้x _{n +1} = x _n - (บันทึก ( Π ( x _n )) - y ) / (บันทึก (( Π (1.001 * x _n ))) - บันทึก ( Π ( x _n ))) / (0.001 * x _n ))

PARI / GP ขนาด 30 ไบต์

x->solve(t=1,x+1,gamma(t+1)-x)

พบว่าวิธีการแก้ปัญหาระหว่างและ1 x+1แต่น่าเสียดายที่เป็นพอที่จะไม่ใหญ่เป็นขอบเขตบนสำหรับการป้อนข้อมูลเช่นx1.5

Mathematica, 26 ไบต์

นี่เป็นอีกหนึ่งโซลูชั่น Mathematica!

การแก้สมการสามารถเปลี่ยนเป็นปัญหาการย่อให้เล็กที่สุดได้เสมอ

NArgMin[{(#-x!)^2,x>0},x]&

ค้นหาอาร์กิวเมนต์ที่ลดความแตกต่างระหว่างด้านซ้ายและด้านขวาของสมการให้เหลือน้อยที่สุด

การใช้ NArgMin แทนที่จะใช้ NMinimize บังคับให้เอาต์พุตเป็นผลลัพธ์ที่ต้องการแทนที่จะใช้เอาต์พุตตามกฎ verbose ปกติ (และช่วยประหยัดไบต์!)

C กับ libm, 111

อัพเดท - แก้ไขสำหรับอินพุต 1.5

f(double *z){double u=2**z,l=0,g=u,p=0;for(;log(fabs(g-p))>-14;)p=g,g=(u+l)/2,u=tgamma(g+1)>*z?g:(l=g,u);*z=g;}

gamma(x+1)เป็นฟังก์ชั่นที่เพิ่มขึ้นอย่างน่าเบื่อหน่ายในช่วงคำถาม Shis เป็นเพียงการค้นหาแบบไบนารีจนกระทั่งความแตกต่างระหว่างค่าที่ต่อเนื่องนั้นมีขนาดเล็ก ขอบเขตล่างเริ่มต้น0และขอบเขตบนเริ่มต้นคือ2*xและเริ่มต้นที่ถูกผูกไว้ด้านบน

อินพุทและเอาท์พุทคือผ่านตัวชี้ไปยังคู่ที่ผ่านไปยังฟังก์ชั่น

ฉันค่อนข้างมั่นใจว่าสิ่งนี้สามารถเล่นกอล์ฟได้ลึกกว่าโดยเฉพาะฉันไม่คิดว่าฉันต้องการ 4 คู่ในประเทศ แต่จนถึงตอนนี้ฉันไม่เห็นวิธีง่าย ๆ ในการลด

ลองออนไลน์ - สร้าง (เชื่อมโยงกับ libm) และทำงานในสคริปต์ทุบตี

ungolfed อย่างอ่อนโยน:

f(double *z){
    double u=2**z,l=0,g=u,p=0;
    for(;log(fabs(g-p))>-14;){
        p=g;
        g=(u+l)/2;
        u=tgamma(g+1)>*z?g:(l=g,u);*z=g;
    }
}