ท้าทาย

รับจำนวนเต็มบวกNเอาท์พุทผลรวมของส่วนNกลับแรกเป็นเศษส่วนที่แน่นอนซึ่งจะแสดงเป็นคู่ของจำนวนเต็มในลำดับที่สอดคล้องกันเป็นตัวแทนของเศษและส่วน

กฎระเบียบ

• ผลลัพธ์จะต้องถูกต้อง

• เอาต์พุตควรเป็นจำนวนเต็มคู่ในลำดับที่สอดคล้องกันซึ่งแสดงถึงตัวเศษและส่วน

• ห้ามใช้ประเภทตัวเลขที่ไม่ใช่จำนวนเต็ม (มีอยู่แล้วภายในหรือไลบรารี)

  • การชี้แจง / ข้อยกเว้น: ประเภทที่ไม่ใช่ตัวเลขจะไม่เป็นไรหากค่าทั้งหมดที่ใช้คำนวณและส่งคืนเป็นจำนวนเต็ม (เช่นภาษาของคุณใช้ตัวเลขที่มีเหตุผลตามค่าเริ่มต้น แต่คุณใช้เลขคณิตเลขจำนวนเต็มในคำตอบของคุณเท่านั้น)

• ผลผลิตควรลดลงมากที่สุด ( 3/2ไม่เป็นไร6/4ไม่ใช่)

• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม

• การส่งควรทำงานสำหรับอินพุตอย่างน้อยถึง 20 หรือเมตานี้แล้วแต่จำนวนใดจะสูงกว่า

กรณีทดสอบ

1: 1/1
2: 3/2 (1/1 + 1/2)
3: 11/6 (1/1 + 1/2 + 1/3)
4: 25/12 etc.
5: 137/60
6: 49/20
20: 55835135/15519504
56: 252476961434436524654789/54749786241679275146400
226: 31741146384418617995319820836410246588253008380307063166243468230254437801429301078323028997161/5290225078451893176693594241665890914638817631063334447389979640757204083936351078274058192000

การสร้างกรณีทดสอบ (Python 3)

import fractions
def f(x):
    return sum(fractions.Fraction(1,i) for i in range(1,x+1))

คล้ายกับความท้าทายนี้และความท้าทายนี้

numerators มีOEIS A001008และตัวหารเป็นOEIS A002805

Python 2 , 80 79 ไบต์

D=1;N=n=0;exec"n+=1;y=N=N*n+D;x=D=D*n;"*input()
while y:x,y=y,x%y
print N/x,D/x

ลองออนไลน์!

พิมพ์ตัวเศษและส่วน

เย้! การสนับสนุน MathJax !!!! หนึ่งข้อสังเกต:

จากนั้นความคิดเกี่ยวกับการเรียกซ้ำสำหรับบวกในumerator:$n$N

และเป็นหนึ่งในไม่สามารถช่วยคิดของDenominator ซ้ำเช่นกัน ดังนั้น$n!$exec

เราต้องจ่าย Reduction Fiper Piper ด้วยการคำนวณ GCD ในwhileลูป แล้วเราก็เสร็จ

เยลลี่ 10 ไบต์

!:RS,!:g/$

ลองออนไลน์!

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

!:RS,!:g/$  Main link. Argument: n

!           Compute n!.
  R         Range; yield [1, ..., n].
 :          Divide n! by each k in [1, ..., n].
   S        Take the sum. Let's call it s.
     !      Compute n! again.
    ,       Pair; yield [s, n!].
      :g/$  Divide [s, n!] by their GCD.

J , 16 ไบต์

!(,%+.)1#.!%1+i.

ลองออนไลน์!

เรียกใช้ตัวอย่าง

f =: !(,%+.)1#.!%1+i.
f 6x
   20 49
f 20x
   15519504 55835135
f 56x
   54749786241679275146400 252476961434436524654789

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

!(,%+.)1#.!%1+i.    NB. Tacit verb
            1+i.    NB. 1 to n inclusive
          !%        NB. Divide factorial by 1 to n
       1#.          NB. Sum i.e. numerator (not reduced)
!                   NB. Factorial i.e. denominator (not reduced)
 (,%+.)             NB. Divide both by GCD

J , 9 ไบต์ใช้ชนิดเศษส่วน

1#.1%1+i.

ลองออนไลน์!

J ให้เศษส่วนสำหรับการหารภายในถ้าไม่สามารถหารได้

05AB1E , 10 ไบต์

!DIL÷O)D¿÷

ลองออนไลน์!

ใช้วิธีการเดียวกันกับรายการอื่น ๆ ทั้งหมด [denominator, numerator]เอาท์พุทเป็นในรูปแบบ

!DIL÷O)D¿÷   Full program. Let's call the input I.
!D           Push the factorial twice to the stack. STACK: [I!, I!]
  IL         Range from 1 to I. STACK: [I!, I!, [1 ... I]]
    ÷        Vectorized integer division. STACK: [I!, [I! / 1, I! / 2, ..., I! / I]]
     O       Sum. STACK: [I!, I! / 1 + I! / 2 + ... + I! / I]
      )      Wrap stack. STACK: [[I!, I! / 1 + I! / 2 + ... + I! / I]]
       D     Duplicate. STACK: [[I!, I! / 1 + ... + I! / I], [I!, I! / 1 +... + I! / I]]
        ¿    GCD. STACK: [[I!, I! / 1 + ... + I! / I], gcd(I!, I! / 1 +... + I! / I)]
         ÷   Vectorized integer division. 

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

#/GCD@@#&@{Tr[#!/Range@#],#!}&

ลองออนไลน์!

14 ไบต์หากได้รับอนุญาตประเภทเศษส่วนในตัว

HarmonicNumber

ลองออนไลน์!

JavaScript (ES6), 60 ไบต์

[numerator, denominator]ผลตอบแทน

f=(n,a=0,b=1)=>n?f(n-1,p=a*n+b,q=b*n):b?f(0,b,a%b):[p/a,q/a]

ลองออนไลน์!

อย่างไร?

วิธีการคล้ายกับ@ ChasBrown คำตอบของงูหลาม

$a$$b$$a=0$$b=1$

$n=0$

$(a,b)$$(p,q)$$a\gets \gcd(a,b)$

$b=0$

$p/a$$q/a$

Perl 6 , 57 53 ไบต์

{+($!=[*] 1..$_)/($!=($/=sum $! X/1..$_)gcd$!),$//$!}

ลองออนไลน์!

บล็อกรหัสที่ไม่ระบุชื่อที่ใช้เวลาเป็นจำนวนเต็มและส่งกลับ tuple denominator, numeratorของ

หากเราได้รับอนุญาตให้ใช้ประเภทเศษส่วนมันจะง่ายกว่า 32 byter:

{sum(map 1/*.FatRat,1..$_).nude}

ลองออนไลน์!

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

@(n)sym(sprintf('+1/%i',1:n))

ลองออนไลน์!

C ++ 17 (gcc) , 108 ไบต์

ใช้เลขคณิตจำนวนเต็มเท่านั้น:

#import<random>
int f(int x,long&n,long&d){n=0;d=1;int
a;while(n=n*x+d,d*=x,a=std::gcd(n,d),n/=a,d/=a,--x);}

ลองออนไลน์!

C ++ 17 (gcc) , 108 ไบต์

#import<random>
int f(long&n){double a=0;long
d=1;while(d*=n,a+=1./n,--n);n=a*d+.5;n/=a=std::gcd(n,d);d/=a;}

ลองออนไลน์!

เช่นเดียวกับด้านล่าง std::gcdแต่การใช้ภาษา C

C ++ (gcc) , 109 ไบต์

#import<regex>
int f(long&n){double a=0;long
d=1;while(d*=n,a+=1./n,--n);n=a*d+.5;n/=a=std::__gcd(n,d);d/=a;}

ลองออนไลน์!

เพราะภาษา C ++ ไม่ได้สนับสนุน bigint n>20พื้นเมืองนี้แน่นอนจะล้นสำหรับ

จำเป็นต้อง:

• importคำสั่งที่เลิกใช้ของ gcc
• std::__gcdGCC ของ
• -O0(ผมคิดว่าอย่างนั้น) d/=aมิฉะนั้นคอมไพเลอร์จะเพิ่มประสิทธิภาพออก
• อย่างน้อย long64

คำอธิบาย:

• $d=n!, a=H_n$
• รอบa*dการเลขที่ใกล้ที่สุดโดยการหล่อa*d+.5การและมอบหมายให้long nตอนนี้n/dเป็นผลลัพธ์
• std::__gcdลดความซับซ้อนของส่วนที่มี

Pari / GP , 34 ไบต์

n->l=[sum(i=1,n,n!/i),n!];l/gcd(l)

ลองออนไลน์!

17 ไบต์หากได้รับอนุญาตประเภทเศษส่วนในตัว

n->sum(i=1,n,1/i)

ลองออนไลน์!

MATL, 13 ไบต์

:tptb/sht&Zd/

ลองใช้กับ MATL Online

วิธีการเดียวกับที่ใช้ใน@Dennis' คำตอบของวุ้น

:t    % Range from 1 to n, duplicate. 
pt    % Take the product of that (= factorial), duplicate that too.     
b/    % Bring the range to top of stack, divide factorial by each element    
sh    % Sum those. Concatenate factorial and this into a single array.     
t&Zd/ % Compute GCD of those and divide the concatenated array elements by the GCD.     

(โดยปริยายเอาท์พุทพิมพ์ส่วนแรกแล้วตามด้วยตัวเศษ)

ความไม่ถูกต้องของคะแนนลอยตัวหมายความว่าสิ่งนี้ไม่ได้ผลสำหรับ n = 20 เนื่องจากค่ากลางมีขนาดใหญ่เกินไป ดูเหมือนว่าผลลัพธ์ของกรณีทดสอบคือการพิมพ์ผิดซึ่งจะส่งกลับคำตอบเดียวกับคำตอบอื่น ๆ สำหรับ n = 20

ต่อไปนี้เป็นเวอร์ชันการเก็บรักษาชนิดจำนวนเต็ม (25 ไบต์) ที่ฉันลองในระหว่างนี้ก่อนจะค้นหาสิ่งนี้:

25 ไบต์ใส่ได้สูงสุด 43

O1i:3Y%"t@*b@*b+wht&Zd/Z}

ลองออนไลน์!

ปลดเปลื้องตัวเลขuint64ก่อนที่จะดำเนินการกับพวกเขาทำเลขคณิตอย่างชัดเจนในวง (โดยไม่ต้องใช้prodหรือsum) ที่สำคัญยิ่งกว่านั้นหารตัวเศษและส่วนด้วย GCD ของพวกเขาทุกขั้นตอนไปตามทางในตอนท้ายของการวนซ้ำแต่ละครั้ง สิ่งนี้จะเพิ่มช่วงอินพุตให้nสูงสุด 43 ส่วนของรหัสขึ้นอยู่กับคำตอบ Python ของ @Chas Brown

วิธีสำรอง (ดั้งเดิม) โดยใช้ LCM แทนแฟกทอเรียล:

16 15 ไบต์

:t&Zmtb/sht&Zd/

ลองใช้กับ MATL Online

Excel VBA ขนาด 141 ไบต์

รับอินพุตจาก[A1]และเอาต์พุตไปยังคอนโซล

s="=If(Row()>A$1,":[B:B]=s+"1,Row())":l=[LCM(B:B)]:[C:C]=s &"0,"&l &"/B1)":g=[GCD(LCM(B:B),SUM(C:C))]:?Format([Sum(C:C)]/g,0)"/"Format(l/g,0)

Ungolfed และแสดงความคิดเห็น

Sub HarmonicSum(n)
    [A1] = n                            ''  Pipe input
    s = "=IF(ROW()>A$1,"                ''  Hold the start of formulas
    [B1:B40] = s + "1,ROW())"           ''  Get series of numbers 1 to N, trailing 1s
    l = [LCM(B1:B40)]                   ''  Get LCM
    [C1:C40] = s & "0," & l & "/B1)"    ''  Get LCM/M for M in 1 to N
    g = [GCD(LCM(B1:B40),SUM(C1:C40))]  ''  Get GCD
                                        ''  Format and print output
    Debug.Print Format([Sum(C1:C40)] / g, 0); "\"; Format(l / g, 0)
End Sub

dc , 87 ไบต์

?sn1dsNsD[lndlDdlNln*+sN*sD1-dsn1<M]sMln1<MlDsAlNsB[lAlB%sTlBsAlTsBlB0<G]dsGxlDlA/lNlA/

ลองออนไลน์!

ใบนี้เศษและส่วนบนของสแต็คในลำดับที่ตามที่ได้รับอนุญาตจากนี้เริ่มต้นการส่งออก เนื่องจากdcไม่ได้มีgcdในตัวนี้ใช้ขั้นตอนวิธี Euclideangcdในการคำนวณ

Stax , 11 ไบต์

ó╢Δ'åç4}ú┌7

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

คำอธิบาย:

เราต้องการคำนวณ:

ตอนนี้เราต้องการตัวส่วน $b$ และรายการของตัวเศษ $a_i$:

เราสามารถทำ $b=n!$จากนั้นเรามี:

ดังนั้นเราจึงมี:

|Fx{[/m|+L:_m Full program
|F            Factorial
  x           Push input again
   {  m       Map over range [1, n]
    [           Copy the factorial
     /          Divide factorial by current value
       |+     Sum
         L    Listify stack, top gets first element
          :_  Divide both values by gcd
            m Print each followed by newline

APL (NARS), 56 ตัวอักษร, 112 ไบต์

{⍵=1:⊂1 1⋄{(r s)←⍺⋄(i j)←⍵⋄m÷∨/m←((r×j)+s×i),s×j}/1,¨⍳⍵}

ทดสอบ:

  f←{⍵=1:⊂1 1⋄{(r s)←⍺⋄(i j)←⍵⋄m÷∨/m←((r×j)+s×i),s×j}/1,¨⍳⍵}
  f 1
1 1 
  f 2
3 2 
  f 3
11 6 
  f 20
55835135 15519504 

ในไม่กี่คำลด "ฟังก์ชั่นผลรวมกับตัวเลข 2 ส่วน" (หนึ่งเศษคือรายการ 2 จำนวนเต็ม) ในชุด:

1 2, 1 3,..., 1 n

ด้านล่างนี้ดูเหมือนผิด

 f 56
74359641471727289 16124934538402170

แต่ถ้าฉันเปลี่ยนประเภทของอินพุตมากกว่า:

  f 56x
252476961434436524654789 54749786241679275146400 
  f 226x
31741146384418617995319820836410246588253008380307063166243468230254437801429301078323028997161 529022507845189
  3176693594241665890914638817631063334447389979640757204083936351078274058192000

APL (Dyalog Unicode) , 15 12 ไบต์

⌽!(,÷∨)1⊥!÷⍳

ลองออนไลน์!

⍵ฟังก์ชั่นโดยปริยายการอาร์กิวเมนต์เดียว บันทึกไบต์ด้วยการลบ⌽ถ้าเราได้รับอนุญาตให้พิมพ์ส่วนก่อน

ขอบคุณ @dzaima เป็นเวลา 3 ไบต์

วิธี:

⌽!(,÷∨)1⊥!÷⍳ ⍝ Tacit function, argument will be called ⍵.
           ⍳ ⍝ Range 1..⍵ 
          ÷  ⍝ Dividing
         !   ⍝ the factorial of ⍵
       1⊥    ⍝ Base-1 decode, aka sum;
 !(   )      ⍝ Using that sum and the factorial of ⍵ as arguments, fork:
     ∨       ⍝ (GCD
    ÷        ⍝ dividing
   ,         ⍝ the vector with both arguments)
⌽            ⍝ reversed.