Thử thách

Cho một số nguyên dương N, xuất tổng của các Nđối ứng đầu tiên dưới dạng phân số chính xác, được biểu diễn dưới dạng một cặp số nguyên theo thứ tự nhất quán đại diện cho tử số và mẫu số.

Quy tắc

• Đầu ra phải chính xác.

• Đầu ra phải là một cặp số nguyên theo thứ tự nhất quán đại diện cho tử số và mẫu số.

• Sử dụng các kiểu số không nguyên (tích hợp hoặc thư viện) đều bị cấm.

  • Làm rõ / ngoại lệ: các kiểu số không nguyên vẫn ổn nếu và chỉ khi tất cả các giá trị được sử dụng, tính toán và trả về là số nguyên (nghĩa là ngôn ngữ của bạn sử dụng số hữu tỷ theo mặc định, nhưng bạn chỉ sử dụng số học số nguyên trong câu trả lời của mình)

• Đầu ra nên được giảm càng tốt. ( 3/2không sao, 6/4phải không)

• Sơ hở tiêu chuẩn bị cấm.

• Đệ trình nên hoạt động cho đầu vào ít nhất lên đến 20, hoặc meta này , tùy theo mức nào cao hơn.

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

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

Tạo trường hợp thử nghiệm (Python 3)

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

Tương tự với thử thách này và thử thách này .

Các tử số là OEIS A001008 và mẫu số là OEIS A002805 .

Python 2 , 80 79 byte

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

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

In tử số và mẫu số.

Yay! MathJax hỗ trợ !!!! Một người quan sát:

Sau đó, suy nghĩ về đệ quy, cho tích cực, trong bộ điều khiển:$n$N

và người ta không thể không nghĩ về Denominator đệ quy là tốt; do đó .$n!$exec

Chúng ta phải trả Piper giảm phân số bằng phép tính GCD trong whilevòng lặp; và sau đó chúng ta đã hoàn thành.

Thạch , 10 byte

!:RS,!:g/$

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

Làm thế nào nó hoạt động

!: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 byte

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

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

Chạy ví dụ

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

Làm thế nào nó hoạt động

!(,%+.)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 byte, sử dụng loại phân số

1#.1%1+i.

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

J đưa ra phân số cho phép chia int-int nếu không chia hết.

05AB1E , 10 byte

!DIL÷O)D¿÷

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

Sử dụng phương pháp tương tự như tất cả các mục khác. Đầu ra có dạng [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. 

Ngôn ngữ Wolfram (Mathicala) , 30 byte

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

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

14 byte nếu các loại phân đoạn tích hợp được cho phép

HarmonicNumber

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

JavaScript (ES6), 60 byte

Trả về [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]

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

Làm sao?

Phương pháp này tương tự như câu trả lời Python củ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 byte

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

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

Một khối mã ẩn danh lấy một số nguyên và trả về một tuple denominator, numerator.

Nếu chúng ta được phép sử dụng các loại phân số, nó sẽ đơn giản hơn 32 byter:

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

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

Octave , 29 byte

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

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

C ++ 17 (gcc) , 108 byte

Chỉ sử dụng số học số nguyên:

#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);}

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

C ++ 17 (gcc) , 108 byte

#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;}

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

Tương tự như dưới đây, nhưng sử dụng C ++ 17's std::gcd.

C ++ (gcc) , 109 byte

#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;}

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

Bởi vì C ++ không có hỗ trợ bigint riêng, điều này chắc chắn sẽ tràn ra n>20.

Yêu cầu:

• importtuyên bố phản đối của gcc .
• gcc std::__gcd.
• -O0(Tôi nghĩ vậy) nếu không trình biên dịch sẽ tối ưu hóa d/=a.
• Ít nhất là 64 bit long.

Giải trình:

• Để cho $d=n!, a=H_n$.
• Làm tròn a*dđến số nguyên gần nhất bằng cách truyền a*d+.5tới longvà gán cho n. Bây giờ n/dlà đầu ra.
• Đơn giản hóa phân số với std::__gcd.

Pari / GP , 34 byte

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

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

17 byte nếu các loại phân đoạn tích hợp được cho phép

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

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

MATL, 13 byte

:tptb/sht&Zd/

Dùng thử trên MATL Online

Phương pháp tương tự như được sử dụng trong câu trả lời Jelly của @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.     

(Ngõ ra ngầm định, in mẫu số trước rồi đến tử số.)

Không chính xác điểm nổi có nghĩa là điều này không hoạt động với n = 20, vì các giá trị trung gian quá lớn. Có vẻ như đầu ra trường hợp thử nghiệm là một lỗi đánh máy, điều này trả về cùng một câu trả lời như các câu trả lời khác cho n = 20.

Đây là phiên bản bảo toàn kiểu số nguyên (25 byte) Tôi đã thử trong thời gian này, trước khi tìm hiểu điều này:

25 byte, đầu vào tối đa 43

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

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

Đưa các số đến uint64trước khi vận hành trên chúng, thực hiện số học một cách rõ ràng trong một vòng lặp (không sử dụng prodhoặc sum). Quan trọng hơn, chia các tử số và mẫu số một phần cho GCD của chúng mỗi bước trên đường đi, vào cuối mỗi lần lặp. Điều này làm tăng phạm vi đầu vào để cho phép ntối đa 43. Một phần của mã dựa trên câu trả lời Python của @Chas Brown.

Phương pháp thay thế (bản gốc) bằng LCM thay vì giai thừa:

16 15 byte

:t&Zmtb/sht&Zd/

Dùng thử trên MATL Online

VBA Excel, 141 byte

Đưa đầu vào từ [A1]và đầu ra đến bàn điều khiển.

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 và bình luận

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 byte

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

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

Điều này để lại tử số và mẫu số trên đầu ngăn xếp theo thứ tự đó, như được cho phép bởi mặc định đầu ra này . Vì dckhông có tích gcdhợp sẵn, nên điều này sử dụng thuật toán Euclide để tính toán gcd.

Stax , 11 byte

ó╢Δ'åç4}ú┌7

Chạy và gỡ lỗi nó

Giải trình:

Chúng tôi muốn tính toán:

Bây giờ chúng ta cần một mẫu số $b$ và một danh sách các tử số $a_i$:

Chúng ta có thể làm $b=n!$, sau đó chúng tôi có:

Vì vậy chúng tôi có:

|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 ký tự, 112 byte

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

kiểm tra:

  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 

Trong một số từ, giảm "hàm tổng trên 2 số phân số" (một số phân số là danh sách 2 số nguyên) trên tập hợp:

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

Điều này dưới đây có vẻ sai:

 f 56
74359641471727289 16124934538402170

nhưng nếu tôi thay đổi loại đầu vào hơn:

  f 56x
252476961434436524654789 54749786241679275146400 
  f 226x
31741146384418617995319820836410246588253008380307063166243468230254437801429301078323028997161 529022507845189
  3176693594241665890914638817631063334447389979640757204083936351078274058192000

APL (Dyalog Unicode) , 15 12 byte

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

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

Hàm ngầm, lấy một đối số duy nhất ⍵. Lưu một byte bằng cách loại bỏ ⌽nếu chúng ta được phép in mẫu số trước.

Cảm ơn @dzaima cho 3 byte.

Làm sao:

⌽!(,÷∨)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.