[Question]
  [
Earlier, we did the [pseudofactorial](https://codegolf.stackexchange.com/questions/82494/pseudofactorial) of a number, which is the LCM of the numbers from `1` to `n`.
It would be useful in adding fractions together.
However, we find that the denominator of `1/1 + 1/2 + 1/3 + 1/4 + 1/5 + 1/6` is `20` instead of the pseudofactorial of `6`, which is `60`.
Your task is to find the denominator of `1/1 + 1/2 + ... + 1/n` given positive integer `n`.
# Testcases
```
 n result
 1 1
 2 2
 3 6
 4 12
 5 60
 6 20
 7 140
 8 280
 9 2520
10 2520
11 27720
12 27720
13 360360
14 360360
15 360360
16 720720
17 12252240
18 4084080
19 77597520
20 15519504
21 5173168
22 5173168
23 118982864
24 356948592
25 8923714800
26 8923714800
27 80313433200
28 80313433200
29 2329089562800
30 2329089562800
```
* [List for `n` from `1` to `200`](https://oeis.org/A002805/b002805.txt).
* [List for `n` from `1` to `1000`](http://pastebin.com/raw/z1WaZQ87).
* [List for `n` from `1` to `10000`](https://gist.githubusercontent.com/kckennylau/a5a09ae50268a6e99cac30e15a25486a/raw/929b7ea98b38a3443cb4b6e1059bfe71598a3bc9/ppcg-q82815,%2520oeis-a002805).
# References
* Obligatory OEIS [A002805](https://oeis.org/A002805) (thanks to [@FryAmTheEggman](https://codegolf.stackexchange.com/users/31625/fryamtheeggman))
# Leaderboard
```
var QUESTION_ID=82815,OVERRIDE_USER=48934;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```
  
[Answer]
# [M](http://github.com/DennisMitchell/m), ~~9~~ 6 bytes
Thanks to **FryAmTheEggman** for saving 3 bytes! Code:
```
RİSg¹İ
```
**M** has a huge advantage here, because it works with fractions rather than floats. Explanation:
```
R       # Get the list [1 ... n].
 İ      # Inverse each, resulting into [1/1, 1/2, 1/3, ..., 1/n].
  S     # Sum it up. (86021/27720 for n=12)
   g¹   # Compute the greatest common denominator with n. (1/27720 for n=12)
     İ  # Calculate the inverse again. (27720 for n=12)
```
Uses the **Jelly encoding**. [Try it online!](http://m.tryitonline.net/#code=UsSwU2fCucSw&input=&args=MTI).
---
Also, there is a **4-byte** solution, which outputs a leading zero sometimes (e.g. `280 -> 0280`). I'm not sure if this is allowed or not:
```
RİSV
```
[Try it online!](http://m.tryitonline.net/#code=UsSwU1Y&input=&args=OA).
[Answer]
# Julia, 22 bytes
An anonymous function.
```
n->1.//(1:n)|>sum|>den
```
[Answer]
### Ruby, ~~57~~ 47 bytes
```
->n{(1..n).reduce{|a,i|a+1.to_r/i}.denominator}
```
Thanks to **Kevin Lau** for shortening this by ten bytes.
[Answer]
# Mathematica, 27 bytes
An anonymous function.
```
Denominator@*HarmonicNumber
```
For example:
```
 In[1] := (Denominator@*HarmonicNumber)[10]
 Out[1] = 2520
```
[Answer]
# Python 2, ~~69~~ 67 bytes
```
a=b=k=r=1
exec'a=a*k+b;b*=k;k+=1;'*input()
while r*a%b:r+=1
print r
```
Test it on [Ideone](http://ideone.com/RBXZCS).
### How it works
Let **H(n)** be the sum of the multiplicative inverses of the first **n** positive integers. At all times, we have that **a / b = 1 + H(k - 1)**. In fact, **a**, **b**, and **k** are all initialized to **1**, and **1 / 1 = 1 = 1 + H(0)**.
We repeat the code snippet
```
a=a*k+b;b*=k;k+=1;
```
(as a string) **n** (input) times and execute the result. In each step, we update **a**, **b**, and **k** using the identity **a / b + 1 / k = ak / bk + b / bk = (ak + b) / bk**.
After all copies have been executed, **a / b = 1 + H(n)**, which has the same denominator as **H(n)**.
The fully reduced form of **a / b** is **(a ÷ gcd(a,b)) / (b ÷ gcd(a,b))**. Instead of calculating the greatest common divisor, we initialize **r** as **1** and keep incrementing **r** until **ra** is a multiple of **b**.
Clearly, this makes **ra** the least common multiple of **a** and **b**. Since **gcd(a,b) · lcm(a,b) = ab**, we have that **b ÷ gcd(a,b) = lcm(a,b) ÷ a = ra ÷ a = r**, making **r** the desired output.
[Answer]
# Haskell, 52
```
Import Data.Ratio
f n=denominator$sum[1%k|k<-[1..n]]
```
If the file is loaded into GHCI, f can be used as a function.
[Answer]
# Jelly, 9 bytes
```
!©÷RSg®®÷
```
[Try it here.](http://jelly.tryitonline.net/#code=IcKpw7dSU2fCrsKuw7c&input=&args=MTA)
```
             Argument: n
! ÷R         Compute [n!÷1, n!÷2, … n!÷n].
 ©             (And store n! in the register.)
    S        Find the sum of this list.
     g®      GCD with n!.
       ®÷    Divide n! by this GCD.
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~14~~ 13 bytes
```
:p:G:!/s1\&X<
```
[**Try it online!**](http://matl.tryitonline.net/#code=OnA6RzohL3MxXCZYPA&input=Ng)
### Explanation
For input *N*, the output is upper-bounded by *N*! (factorial of *N*). The code computes *n*/*k* for *n* = 1, ..., *N*! and for *k* = 1, ..., *N*. Then it sums over *k*, which gives the harmonic number multiplied by each *n*. The desired result is the index *n* of the first of those values that is an integer.
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 8 bytes
Code:
```
!Ð¹L/O¿/
```
Explanation:
```
!         # Take the factorial of the input.
 Ð        # Triplicate this.
  ¹L      # Get the list [1 ... input].
    /O    # Divide and sum up.
      ¿   # Get the GCD of the sum and the factorial.
       /  # Divide the factorial by this.
```
There might be some accuracy problems for n > 19 due to Python's division... Uses the **CP-1252** encoding.
[Try it online!](http://05ab1e.tryitonline.net/#code=IcOQwrlML0_Cvy8&input=Ng).
[Answer]
## Mathematica, 26 bytes
```
Denominator@Tr[1/Range@#]&
```
An unnamed function taking `n` as input and returning the denominator. Uses the standard trick of abusing `Tr` (trace) to sum the list of reciprocals.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 6 bytes
```
is\ṁ\ḣ
```
[Try it online!](https://tio.run/##yygtzv7/P7M45uHOxpiHOxb////f2AAA "Husk – Try It Online")
Not too hard in Husk since it can do math with rational numbers. The hard part was extracting the denominator, I ended up inverting the fraction, converting it to string, and getting the first number from that string.
### Explanation
```
is\ṁ\ḣ
     ḣ     range [1..n]
   ṁ       sum the result of this function for each number:
    \        inverse
  \        invert
 s         convert to string
i          get the first number in the string (the numerator)
```
[Answer]
## JavaScript (ES6), 88 bytes
```
m=>{for(d=1,i=0;i<m;d*=++i);for(n=i=0;i<m;n+=d/++i);for(g=d;g;[g,n]=[n%g,g]);return d/n}
```
Only works up to m=20 because of the limits of JavaScript's numeric precision.
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 30 bytes
```
n->denominator(sum(i=1,n,1/i))
```
[Try it online!](https://tio.run/nexus/pari-gp#S1OwVfifp2uXkpqXn5uZl1iSX6RRXJqrkWlrqJOnY6ifqan5Pw0olgdUZ6ijYGygo1BQlJlXAhRQUtC1AxJpGnmaQEUA "Pari/GP – TIO Nexus")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 5 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
┬ΓΣ╞]
```
[Run and debug it](https://staxlang.xyz/#p=c2e2e4c65d&i=1%0A2%0A3%0A4%0A5%0A6%0A7%0A8%0A9%0A10%0A11%0A12%0A13%0A14%0A15%0A16%0A17%0A18%0A19%0A20%0A21%0A22%0A23%0A24%0A25%0A26%0A27%0A28%0A29%0A30&m=2)
6 bytes without packing.
[Answer]
# [Whispers v3](https://github.com/cairdcoinheringaahing/Whispers), 79 bytes
```
> Input
>> 1!
>> 2∕R
>> (1]
>> Each 3 4
>> ∑5
>> 6⊓2
>> 2∕7
>> Output 8
```
[Try it online!](https://tio.run/##K8/ILC5ILSo2@v/fTsEzr6C0hMvOTsFQEUQaPeqYGgRiaBjGgijXxOQMBWMFExD7UcdEUxBt9qhrshFMsTmI4V9aAjRFweL/f0MLAA "Whispers v3 – Try It Online")
Same idea as Lynn's Jelly answer.
[Answer]
# [Thunno](https://github.com/Thunno/Thunno), \$ 12 \log\_{256}(96) \approx \$ 10 bytes
(Actually 9.88 bytes but that doesn't show up on the leaderboard)
```
Fztz!R+/SAG/
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_wYKlpSVpuhZr3KpKqhSDtPWDHd31IUJQmQULzSAMAA)
Port of Adnan's 05AB1E answer.
#### Explanation
```
Fztz!R+/SAG/  # Implicit input
Fzt           # Get factorial and triplicate
   z!R+       # Push range(1, input+1)
       /S     # Divide and sum
         AG/  # Get GCD and divide
```
[Answer]
# J, 20 bytes
```
(!%!+.[:+/!%1+i.)@x:
```
Based on the approach used by @Lynn's [solution](https://codegolf.stackexchange.com/a/82825/6710).
If precision is not necessary for large values of **n** or if we can assume **n** will be passed as an extended integer, suffixed by `x`, a shorter solution can be used for **15 bytes**.
```
!%!+.[:+/!%1+i.
```
## Usage
```
   f =: (!%!+.[:+/!%1+i.)@x:
   f 30
2329089562800
   (,:f"0) >: i. 15
1 2 3  4  5  6   7   8    9   10    11    12     13     14     15
1 2 6 12 60 20 140 280 2520 2520 27720 27720 360360 360360 360360
```
## Explanation
```
(!%!+.[:+/!%1+i.)@x:  Input: n
                  x:  Convert n into an extended integer
              i.      Creates the range [0, 1, ..., n-1]
            1+        Add one to each, range is now [1, 2, ..., n]
          !           Get factorial of n
           %          Divide n! by each value in the range [1, 2, ..., n]
      [:+/            Sum those values
   !                  Get n!
    +.                Get gcd between n! and the sum
 !                    Get n!
  %                   Divide n! by the gcd and return
```
[Answer]
# [Perl 6](http://perl6.org), ~~36~~ 32 bytes
```
~~{([+] 1.FatRat X/1..$\_).denominator}~~
{([+] 1.FatRat X/1..$_).nude[1]}
```
### Explanation:
```
{
  (
    [+]        # reduce with &infix:<+>
      # the following produces a Seq of Rational numbers
      # 1/1, 1/2, 1/3 ... 1/n
      1.FatRat # FatRat.new: 1,1
      X/       # crossed using &infix:</>
      1 .. $_  # Range from 1 to the input inclusive
  ) # resulting in a FatRat
  .nude # (nu)merator (de)nominator
  .[1]  # grab the denominator
}
```
### [Test:](https://ideone.com/zEwFij)
```
my &hd = {([+] 1.FatRat X/1..$_).nude[1]}
say (1..10)».&hd; # (1 2 6 12 60 20 140 280 2520 2520)
say hd 100; # 2788815009188499086581352357412492142272
say chars hd 1000; # 433
say chars hd 10000; # 4345
```
[Answer]
## [Hoon](https://github.com/urbit/urbit), 95 bytes
```
|=
@
=+
n=(gulf 1 +<)
=+
f=(roll n mul)
(div f d:(egcd f (roll (turn n |=(@ (div f +<))) add)))
```
Create list `[1...n]`, fold over it with `++mul` for the factorial, create list `[n!/1, n!/2, ... n!/n]` and sum it, find GCD of `n!` and the list, and divide the factorial by that number.
There's probably a much easier way to calculate the denominator, but I can't figure it out :/
[Answer]
**Python 3, 153 150 146 142 bytes**
I'm sure this can golfed further. But I'm new here
```
f=lambda x:0**x or x*f(x-1)
z=int(input());i=f(z)
r=sum(i/y for y in range(1,z+1))  
p=lambda a,b:a if b<1else not a%b+b or p(b,a%b)
print(i/p(r,i))
```
[Answer]
# Axiom, 34 bytes
```
f(x)==denominator(sum(1/n,n=1..x))
```
test 
```
(24) -> [[i,f(i)] for i in 1..30]
   (24)
   [[1,1], [2,2], [3,6], [4,12], [5,60], [6,20], [7,140], [8,280], [9,2520],
    [10,2520], [11,27720], [12,27720], [13,360360], [14,360360], [15,360360],
    [16,720720], [17,12252240], [18,4084080], [19,77597520], [20,15519504],
    [21,5173168], [22,5173168], [23,118982864], [24,356948592],
    [25,8923714800], [26,8923714800], [27,80313433200], [28,80313433200],
    [29,2329089562800], [30,2329089562800]]
                                       Type: List List Expression Integer
```
[Answer]
# PHP, 81 Bytes
```
for($p=1;$z++<$argn;$n=$n*$z+$p/$z)$p*=$z;for($t=1+$n;$p%--$t||$n%$t;);echo$p/$t;
```
[Try it online!](https://tio.run/nexus/php#HcpBCoAgEAXQfef4QSoSrsehs0RUrnQQV@Ldzdw@nj8kyIIzv5Gdo/6kvEHYEaoxfjohMqIeANlRFUQzKs1Z2BmMIau1KK0hriik6L5C@neh3j8 "PHP – TIO Nexus")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 12 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
l
/yNÎõ@/XÃx
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=bAoveU7O9UAvWMN4&input=OA)
```
l\n/yNÎõ@/XÃx     :Implicit input of integer U
l                 :Factorial
 \n               :Reassign to U
   /              :Divide by
    y             :GCD with
     N            :  Array of all inputs
      Î           :  First element (i.e., original input)
       õ          :  Range [1,NÎ]
        @         :  Map each X
         /X       :    Divide U by X
           Ã      :  End map
            x     :  Reduce by addition
```
[Answer]
# [Factor](https://factorcode.org/) + `math.unicode`, 35 bytes
```
[ 1 swap [1,b] n/v Σ denominator ]
```
[Try it online!](https://tio.run/##S0tMLskv@h8a7OnnbqWQnVqUl5qjkJtYkgEm9IoS89JTiyHsslSQUiinNC8zOT8lVaGgKLWkpLKgKDOvRMGai8vsf7SCoUJxeWKBQrShTlKsQp5@mcK5xQopqXn5uZl5iUADFGL/Jyfm5Cjo/QcA "Factor – Try It Online")
[Answer]
# [Arturo](https://arturo-lang.io), 38 bytes
```
$=>[denominator∑map..1&=>reciprocal]
```
[Try it](http://arturo-lang.io/playground?auFcT5)
]