ข้อมูลทั่วไป:

จากวิกิพีเดีย : เศษส่วนอียิปต์คือผลรวมของเศษส่วนของหน่วยที่แตกต่างกัน นั่นคือแต่ละส่วนในนิพจน์มีตัวเศษเท่ากับ 1 และตัวส่วนที่เป็นจำนวนเต็มบวกและตัวส่วนทั้งหมดต่างจากกัน ค่าของนิพจน์ประเภทนี้คือจำนวนตรรกยะบวก a / b จำนวนตรรกยะที่เป็นบวกทุกค่าสามารถแทนได้ด้วยเศษส่วนอียิปต์

ท้าทาย:

เขียนฟังก์ชันที่สั้นที่สุดที่จะคืนค่าของตัวส่วนทั้งหมดสำหรับชุดเศษส่วนหน่วยที่เล็กที่สุดซึ่งรวมกันเป็นเศษส่วนที่กำหนด

กฎ / ข้อ จำกัด :

• อินพุตจะเป็นค่าจำนวนเต็มบวกสองค่า
  • ซึ่งสามารถเปิดSTDIN, argvคั่นด้วยเครื่องหมายจุลภาค, คั่นด้วยช่องว่างหรือวิธีอื่นที่คุณต้องการ
• ค่าอินพุตแรกจะเป็นตัวเศษและค่าอินพุตที่สองคือตัวหาร
• ค่าอินพุตแรกจะน้อยกว่าค่าที่สอง
• ผลลัพธ์อาจรวมถึงค่าที่เกินขีด จำกัด หน่วยความจำของระบบ / ภาษา (RAM, MAX_INT หรือข้อ จำกัด อื่น ๆ ของรหัส / ระบบ) หากเกิดเหตุการณ์เช่นนี้ให้ตัดทอนผลลัพธ์ด้วยค่าสูงสุดเท่าที่จะเป็นไปได้และสังเกตว่า (เช่น...)
• เอาต์พุตควรสามารถจัดการกับค่าส่วนได้อย่างน้อย 2,147,483,647 (2 ³¹ -1, ลงนาม 32- บิตint)
  • ค่าที่สูงขึ้น ( longฯลฯ ) เป็นที่ยอมรับอย่างสมบูรณ์
• ผลลัพธ์จะเป็นรายการของค่าทั้งหมดของส่วนที่เล็กที่สุดของหน่วยเศษส่วนที่พบ (หรือเศษส่วนของตัวเองเช่น1/2)
• เอาต์พุตจะถูกเรียงลำดับจากน้อยไปมากตามค่าของตัวส่วน (เรียงตามค่าของเศษส่วน)
• เอาต์พุตสามารถถูกคั่นด้วยวิธีที่คุณต้องการ แต่ต้องมีอักขระบางตัวระหว่างเพื่อแยกความแตกต่างของค่าหนึ่งจากค่าถัดไป
• นี่คือรหัสกอล์ฟดังนั้นทางออกที่สั้นที่สุดชนะ

Exmaples:

• อินพุต 1:

  43, 48

• เอาท์พุท 1:

  2, 3, 16

• อินพุต 2:

  8/11

• เอาท์พุท 2:

  1/2 1/6 1/22 1/66

• อินพุต 3:

  5 121

• เอาท์พุท 3:

  33 121 363

เสียงกระเพื่อมสามัญ 137 ตัวอักษร

(defun z(n)(labels((i(n s r)(cond((= n 0)r)((< n(/ 1 s))(i n(ceiling(/ 1 n))r))(t(i(- n(/ 1 s))(1+ s)(cons s r))))))(reverse(i n 2'()))))

(z 43/48) -> (2 3 16)

(z 8/11) -> (2 5 37 4070)

(z 5/121) -> (25 757 763309 873960180913 1527612795642093418846225)

ไม่จำเป็นต้องกังวลเกี่ยวกับตัวเลขขนาดใหญ่หรือการจัดการสัญกรณ์เศษส่วน!

Python 2, 169 167 ตัวอักษร

x,y=input()
def R(n,a,b):
 if n<2:return[b/a][b%a:]
 for m in range((b+a-1)/a,b*n/a):
  L=R(n-1,a*m-b,m*b)
  if L:return[m]+L
n=L=0
while not L:n+=1;L=R(n,x,y)
print L

รับ args ที่คั่นด้วยเครื่องหมายจุลภาคบน stdin และพิมพ์รายการ python บน stdout

$ echo 8,11 | ./egypt.py 
[2, 5, 37, 4070]

PHP 82 ไบต์

<?for(fscanf(STDIN,"%d%d",$a,$b);$a;)++$i<$b/$a||printf("$i ",$a=$a*$i-$b,$b*=$i);

สิ่งนี้สามารถทำให้สั้นลงได้ แต่ตัวเศษและตัวส่วนปัจจุบันต้องเก็บเป็นตัวเลขทั้งหมดเพื่อหลีกเลี่ยงข้อผิดพลาดในการปัดเศษทศนิยม (แทนที่จะเก็บเศษส่วนในปัจจุบัน)

ตัวอย่างการใช้งาน:

$ echo 43 48 | php egyptian-fraction.php
2 3 16
$ echo 8 11 | php egyptian-fraction.php
2 5 37 4070

C, 163 177 ตัวอักษร

6/6 : สุดท้ายโปรแกรมจะจัดการการตัดทอนอย่างถูกต้องในทุกกรณี มันใช้ตัวอักษรมากกว่าที่ฉันคาดไว้ แต่มันก็คุ้มค่า โปรแกรมควร 100% เป็นไปตามข้อกำหนดของปัญหาในขณะนี้

d[99],c,z;
r(p,q,n,i){for(c=n+q%p<2,i=q/p;c?d[c++]=i,0:++i<n*q/p;)q>~0U/2/i?c=2:r(i*p-q,i*q,n-1);}
main(a,b){for(scanf("%d%d",&a,&b);!c;r(a,b,++z));while(--c)printf("%d\n",d[c]);}

โปรแกรมใช้ตัวเศษและส่วนในอินพุตมาตรฐาน ตัวหารจะถูกพิมพ์ไปยังเอาต์พุตมาตรฐานหนึ่งค่าต่อบรรทัด เอาต์พุตที่ถูกตัดทอนถูกระบุโดยการพิมพ์ตัวส่วนศูนย์ที่ท้ายรายการ:

$ ./a.out
2020 2064
2
3
7
402
242004

$ ./a.out
6745 7604
2
3
19
937
1007747
0

ตัวส่วนในตัวอย่างที่สองรวมกับ 95485142815/107645519046 ซึ่งแตกต่างจาก 6745/7604 โดยประมาณ 1e-14

Python 61 ตัวอักษร

อินพุตจาก STDIN คั่นด้วยเครื่องหมายจุลภาค
เอาต์พุตไปยัง STDOUT คั่นบรรทัดใหม่
ไม่ส่งคืนการแทนที่สั้นที่สุดเสมอ (เช่นสำหรับ 5/121)

a,b=input()
while a:
    i=(b+a-1)/a
    print"1/%d"%i
    a,b=a*i-b,i*b

จำนวนตัวอักษรโดยไม่ต้องขึ้นบรรทัดใหม่ที่ไม่จำเป็น (เช่นเข้าร่วมทุกบรรทัดภายในการwhileใช้;) ส่วนที่เป็น
จะปัดเศษขึ้นเพื่อให้ฉันรู้ หลังจากพิมพ์ผมแทนที่ด้วยซึ่งเป็นa/b
ib/a1/i <= a/b
1/ia/ba/b - 1/i(a*i-b)/(i*b)

C, 94 ไบต์

n,d,i;main(){scanf("%i%i",&n,&d);for(i=1;n>0&++i>0;){if(n*i>=d)printf("%i ",i),n=n*i-d,d*=i;}}

ลองใช้ออนไลน์

แก้ไข: โค้ดที่สั้นกว่านี้ถูกโพสต์ในความคิดเห็นดังนั้นฉันจึงแทนที่มัน ขอบคุณ!

Stax , 18 ไบต์

é├WüsOΩ↨÷╬6H╒σw[▐â

เรียกใช้และแก้ไขข้อบกพร่อง

ในแต่ละขั้นตอนจะพยายามย่อเล็กสุดที่ตามมา เศษ ดูเหมือนว่าจะใช้งานได้ แต่ฉันไม่สามารถพิสูจน์ได้

AXIOM, 753 ไบต์

L==>List FRAC INT
macro  M(q)==if c<m or(c=m and m<999 and reduce(max,map(denom,q))<xv)then(m:=c;a:=q;xv:=reduce(max,map(denom,a)))
f(x,n)==(y:=x;a:L:=[];c:=0;q:=denom x;q:=q^4;for i in n.. repeat((c:=c+1)>50=>(a:=[];break);1/i>y=>1;member?(1/i,a)=>1;a:=concat(a,1/i);(y:=y-1/i)=0=>break;numer(y)=1 and ~member?(y,a)=>(a:=concat(a,y);break);(i:=floor(1/y))>q=>(a:=[];break));a)
h(x:FRAC INT):L==(a:L:=[];x>1=>a;numer(x)=1=>[x];n:=max(2,floor(1/x));xv:=m:=999;d:=denom x;zd:=divisors d;z:=copy zd;for i in 2..30 repeat z:=concat(z,i*zd);d:=min(10*d,n+9*m);for i in n..d repeat((c:=maxIndex(b:=f(x,i)))=0=>1;c>m+1=>1;M(b);v:=reduce(+,delete(b,1));for j in z repeat((c:=1+maxIndex(q:=f(v,j)))=1=>1;member?(b.1,q)=>1;q:=concat(b.1,q);M(q)));reverse(sort a))

แนวคิดนี้จะใช้ "อัลกอริทึมโลภ" กับจุดเริ่มต้นที่แตกต่างกันและบันทึกรายการที่มีความยาวขั้นต่ำ แต่ไม่เสมอไปมันจะหาคำตอบ min ด้วยความแตกต่างน้อยกว่า: "array A จะน้อยกว่าอาร์เรย์ B ถ้าหาก A มีองค์ประกอบน้อยของ B หรือถ้าจำนวนองค์ประกอบของ A เท่ากับจำนวนองค์ประกอบของ B มากกว่า A มันน้อยกว่า B หากองค์ประกอบน้อยกว่าของ A ใหญ่กว่าจำนวนมากกว่าองค์ประกอบน้อยกว่าของ B " Ungolfed และทดสอบ

-- this would be the "Greedy Algorithm"
fracR(x,n)==
   y:=x;a:L:=[];c:=0;q:=denom x;q:=q^4
   for i in n.. repeat
      (c:=c+1)>50   =>(a:=[];break)
      1/i>y         =>1
      member?(1/i,a)=>1
      a:=concat(a,1/i)
      (y:=y-1/i)=0  =>break
      numer(y)=1 and ~member?(y,a)=>(a:=concat(a,y);break)
      (i:=floor(1/y))>q           =>(a:=[];break)
   a

-- Return one List a=[1/x1,...,1/xn] with xn PI and x=r/s=reduce(+,a) or return [] for fail
Frazione2SommaReciproci(x:FRAC INT):L==
    a:L:=[]
    x>1       =>a
    numer(x)=1=>[x]
    n:=max(2,floor(1/x));xv:=m:=999;d:=denom x;zd:=divisors d;z:=copy zd
    for i in 2..30 repeat z:=concat(z,i*zd)
    d:=min(10*d,n+9*m) 
    for i in n..d repeat
        (c:=maxIndex(b:=fracR(x,i)))=0=>1 
        c>m+1                         =>1
        M(b)
        v:=reduce(+,delete(b,1))
        for j in z repeat
              (c:=1+maxIndex(q:=fracR(v,j)))=1=>1
              member?(b.1,q)                  =>1
              q:=concat(b.1,q)
              M(q) 
    reverse(sort a)

(7) -> [[i,h(i)] for i in [1/23,2/23,43/48,8/11,5/121,2020/2064,6745/7604,77/79,732/733]]
   (7)
      1   1      2   1  1      43  1 1  1      8  1 1  1  1
   [[--,[--]], [--,[--,---]], [--,[-,-,--]], [--,[-,-,--,--]],
     23  23     23  12 276     48  2 3 16     11  2 6 22 66
      5    1  1   1      505  1 1 1  1    1
    [---,[--,---,---]], [---,[-,-,-,---,----]],
     121  33 121 363     516  2 3 7 602 1204
     6745  1 1  1  1    1      1       77  1 1 1  1  1   1
    [----,[-,-,--,---,-----,------]], [--,[-,-,-,--,---,---]],
     7604  2 3 19 950 72238 570300     79  2 3 8 79 474 632
     732  1 1 1  1   1    1     1
    [---,[-,-,-,--,----,-----,-----]]]
     733  2 3 7 45 7330 20524 26388
                                                      Type: List List Any
       Time: 0.07 (IN) + 200.50 (EV) + 0.03 (OT) + 9.28 (GC) = 209.88 sec
(8) -> h(124547787/123456789456123456)
   (8)
        1             1                         1
   [---------, ---------------, ---------------------------------,
    991247326  140441667310032  613970685539400439432280360548704
                                     1
    -------------------------------------------------------------------]
    3855153765004125533560441957890277453240310786542602992016409976384
                                              Type: List Fraction Integer
                     Time: 17.73 (EV) + 0.02 (OT) + 1.08 (GC) = 18.83 sec
(9) -> h(27538/27539)
         1 1 1  1  1    1      1        1
   (9)  [-,-,-,--,---,-----,------,----------]
         2 3 7 52 225 10332 826170 1100871525
                                              Type: List Fraction Integer
                     Time: 0.02 (IN) + 28.08 (EV) + 1.28 (GC) = 29.38 sec

การอ้างอิงและหมายเลขจาก: http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fractions/egyptian.html

สำหรับการเพิ่มบางอย่างด้านล่างนี้จะเป็นส่วนที่เหมาะสำหรับการค้นหาเศษส่วนความยาวขั้นต่ำที่มีตัวหารสูงสุดน้อยกว่า (และไม่เหมาะสำหรับ lengh)

L==>List FRAC INT

-- this would be the "Greedy Algorithm"
fracR(x,n)==
   y:=x;a:L:=[];c:=0;q:=denom x;q:=q^20
   for i in n.. repeat
      (c:=c+1)>1000  =>(a:=[];break)
      1/i>y          =>1
      member?(1/i,a) =>1
      a:=concat(a,1/i)
      (y:=y-1/i)=0  =>break
      numer(y)=1 and ~member?(y,a)=>(a:=concat(a,y);break)
      (i:=floor(1/y))>q           =>(a:=[];break)
   a

-- Return one List a=[1/x1,...,1/xn] with xn PI and x=r/s=reduce(+,a) or return [] for fail
Frazione2SommaReciproci(x:FRAC INT):L==
    a:L:=[]
    x>1       =>a
    numer(x)=1=>[x]
    n:=max(2,floor(1/x));xv:=m:=999;d:=denom x;zd:=divisors d;z:=copy zd; 
    w1:= if d>1.e10 then 1000 else 300; w2:= if d>1.e10 then 1000 else if d>1.e7 then 600 else if d>1.e5 then 500 else if d>1.e3 then 400 else 100;
    for i in 2..w1 repeat(mt:=(i*zd)::List PI;mv:=[yy for yy in mt|yy>=n];z:=sort(removeDuplicates(concat(z,mv)));#z>w2=>break)
    for i in z repeat
        (c:=maxIndex(b:=fracR(x,i)))=0=>1 
        c>m+1                         =>1
        if c<m or(c=m and m<999 and reduce(max,map(denom,b))<xv)then(m:=c;a:=b;xv:=reduce(max,map(denom,a)))
        v:=reduce(+,delete(b,1))
        for j in z repeat
              (c:=1+maxIndex(q:=fracR(v,j)))=1=>1
              member?(b.1,q)                  =>1
              q:=concat(b.1,q)
              if c<m or(c=m and m<999 and reduce(max,map(denom,q))<xv)then(m:=c;a:=q;xv:=reduce(max,map(denom,a)))
    reverse(sort a)

ผลลัพธ์:

(5) -> [[i,Frazione2SommaReciproci(i)] for i in [1/23,2/23,43/48,8/11,5/121,2020/2064,6745/7604,77/79,732/733]]
   (5)
      1   1      2   1  1      43  1 1  1      8  1 1  1  1
   [[--,[--]], [--,[--,---]], [--,[-,-,--]], [--,[-,-,--,--]],
     23  23     23  12 276     48  2 3 16     11  2 6 22 66
      5    1  1   1      505  1 1 1  1    1
    [---,[--,---,---]], [---,[-,-,-,---,----]],
     121  33 121 363     516  2 3 7 602 1204
     6745  1 1  1  1    1      1       77  1 1 1  1  1   1
    [----,[-,-,--,---,-----,------]], [--,[-,-,-,--,---,---]],
     7604  2 3 19 950 72238 570300     79  2 3 8 79 474 632
     732  1 1 1  1   1    1     1
    [---,[-,-,-,--,----,-----,-----]]]
     733  2 3 7 45 7330 20524 26388
                                                      Type: List List Any
                     Time: 0.08 (IN) + 53.45 (EV) + 3.03 (GC) = 56.57 sec
(6) -> Frazione2SommaReciproci(124547787/123456789456123456)
   (6)
        1            1               1                  1
   [---------, ------------, ----------------, -------------------,
    994074172  347757767307  2764751529594496  1142210063701888512
                      1
    -------------------------------------]
    2531144929865351036156388364636113408
                                              Type: List Fraction Integer
         Time: 0.15 (IN) + 78.30 (EV) + 0.02 (OT) + 5.28 (GC) = 83.75 sec
(7) -> Frazione2SommaReciproci(27538/27539)
         1 1 1  1   1     1       1       1
   (7)  [-,-,-,--,----,-------,-------,-------]
         2 3 7 43 1935 3717765 5204871 7105062
                                              Type: List Fraction Integer
                     Time: 0.05 (IN) + 45.43 (EV) + 2.42 (GC) = 47.90 sec

ดูเหมือนว่าตัวหารที่ดีจำนวนมากจะเป็นตัวหารปัจจัยของตัวหารส่วนอินพุต

C, 85 78 ไบต์

ปรับปรุงโดย@ceilingcat 78 ไบต์:

n,d;main(i){for(scanf("%i%i",&n,&d);n;n*++i/d&&printf("%i ",i,d*=i,n=n*i-d));}

ลองออนไลน์!

คำตอบเดิมของฉัน 85 ไบต์:

n,d,i=1;main(){for(scanf("%i%i",&n,&d);n&&++i;n*i/d?printf("%i ",i),n=n*i-d,d*=i:0);}

ลองออนไลน์!

ส่วนหนึ่งของเครดิตควรไปที่Jonathan Frechผู้เขียนโซลูชัน 94 ไบต์นี้ที่ฉันปรับปรุงให้ดีขึ้น

APL (NARS), 2502 ไบต์

fdn←{1∧÷⍵}⋄fnm←{1∧⍵}⋄ffl←{m←⎕ct⋄⎕ct←0⋄r←⌊⍵⋄⎕ct←m⋄r}⋄divisori←{a[⍋a←{∪×/¨{0=≢⍵:⊂⍬⋄s,(⊂1⌷⍵),¨s←∇1↓⍵}π⍵}⍵]}

r←frRF w;x;y;c;q;i;j
(x i)←w⋄i-←1⋄y←x⋄r←⍬⋄c←0⋄q←fdn x⋄q←q*20
i+←1
→4×⍳∼1000<c+←1⋄→6
j←÷i⋄→2×⍳j>y⋄→2×⍳(⊂j)∊r⋄r←r,(⊂j)⋄y←y-j⋄→0×⍳y=0⋄→5×⍳1≠fnm y⋄→5×⍳(⊂y)∊r⋄r←r,⊂y⋄→0
→2×⍳∼q<i←ffl ÷y
r←⍬

r←fr2SumF x;n;xv;m;d;zd;z;i;b;c;t;v;j;k;q;w1;w2;t;b1
z←r←⍬⋄→0×⍳1≤ffl x
:if 1=fnm x⋄r←,⊂x⋄→0⋄:endif
n←2⌈ffl÷x⋄xv←m←999⋄d←fdn x⋄zd←divisori d
w1←1000⋄w2←50⋄:if d>1.e10⋄w2←700⋄:elseif d>1.e7⋄w2←600⋄:elseif d>1.e5⋄w2←500⋄:elseif d>1.e3⋄w2←400⋄:elseif d>1.e2⋄w2←100⋄:endif
:for i :in ⍳w1⋄z←∪z∪k/⍨{⍵≥n}¨k←i×zd⋄:if w2<≢z⋄:leave⋄:endif⋄:endfor
z←∪z∪zd⋄z←z[⍋z]
:for i :in z
    :if 0=c←≢b←frRF x i ⋄:continue⋄:endif
    :if      c>m+1      ⋄:continue⋄:endif
    :if      c<m        ⋄m←c⋄r←b⋄xv←⌈/fdn¨b
    :elseif (c=m)∧(m<999)
         :if xv>t←⌈/fdn¨b⋄m←c⋄r←b⋄xv←t⋄:endif
    :endif
    :if c≤2⋄:continue⋄:endif
    v←↑+/1↓b⋄b1←(⊂↑b)
    :for j :in z
       :if 1=c←1+≢q←frRF v j⋄:continue⋄:endif
       :if        b1∊q      ⋄:continue⋄:endif
       q←b1,q
       :if  c<m⋄m←c⋄r←q     ⋄xv←⌈/fdn¨q
       :elseif (c=m)∧(m<999)
           :if xv>t←⌈/fdn¨q⋄m←c⋄r←q⋄xv←t⋄:endif
       :endif
    :endfor
:endfor
→0×⍳1≥≢r⋄r←r[⍋fdn¨r]

การ traslation จากรหัส AXIOM สำหรับปัญหานี้ไปยัง APL ใช้เป็นครั้งแรก (สำหรับฉัน) ประเภทเศษส่วน (นั่นคือ bignum ... )

103r233 หมายถึงเศษส่วน 103/233 ทดสอบ:

  ⎕fmt fr2SumF 1r23
┌1────┐
│ 1r23│
└~────┘
  ⎕fmt fr2SumF 2r23
┌2──────────┐
│ 1r12 1r276│
└~──────────┘
  ⎕fmt fr2SumF 43r48
┌3────────────┐
│ 1r2 1r3 1r16│
└~────────────┘
  fr2SumF 8r11
1r2 1r6 1r22 1r66 
  fr2SumF 5r121
1r33 1r121 1r363 
  fr2SumF 2020r2064
1r2 1r3 1r7 1r602 1r1204 
  fr2SumF 6745r7604
1r2 1r3 1r19 1r950 1r72238 1r570300 
  fr2SumF 77r79
1r2 1r3 1r8 1r79 1r474 1r632 
  fr2SumF 732r733
1r2 1r3 1r7 1r45 1r7330 1r20524 1r26388 
  fr2SumF 27538r27539
1r2 1r3 1r7 1r43 1r1935 1r3717765 1r5204871 1r7105062 
  fr2SumF 124547787r123456789456123456
1r994074172 1r347757767307 1r2764751529594496 1r1142210063701888512 
  1r2531144929865351036156388364636113408